text:
Muggles' Guide to Harry Potter/Places/Azkaban

General Overview
Azkaban is the wizard prison.

Extended Description
Azkaban is a horrendous place, where Sirius Black, along with many Death Eaters, were imprisoned after Lord Voldemort fell from power. Guarded by the hideous dementors, it is located on a remote island and is virtually escape proof. According to Remus Lupin, it is a "fortress... set on a tiny island, way out to sea, but they don't need walls and water to keep the prisoners in, not when they're all trapped inside their own heads, incapable of a single cheerful thought. Most of them go mad within weeks." Sirius Black is the first person known to have escaped unassisted. Although several Death Eaters also later escaped, it is believed they were able to escape only because the dementors had deserted the prison, having been promised richer feeding if they became loyal to Lord Voldemort.

The first mention of Azkaban is in Harry Potter and the Philosopher's Stone, when it is mentioned only in passing. In Harry Potter and the Chamber of Secrets, we are properly introduced to the nature of the place, when it is decided by the Ministry that Hagrid, who was accused of opening the Chamber fifty years earlier, was responsible for opening it again. When the decision to send him to Azkaban as a preventative measure is announced, we see Hagrid's fear of the place, and later his relief at being released from it. However, the full nature of the place is not fully explained until the events of the third book, Harry Potter and the Prisoner of Azkaban.

From there, it is mentioned in passing, as people are arrested and sent to Azkaban, and as people break out. By Harry Potter and the Half-Blood Prince, the reader may begin to feel, correctly as it turns out, that Azkaban should be fitted with revolving doors.

Past and Present Prisoners of Azkaban

 * Sirius Black - arrested for the murder of Peter Pettigrew and twelve Muggles, imprisoned without trial, escaped
 * Crabbe - arrested after the Battle at the Ministry
 * Barty Crouch Jr. - arrested shortly after the initial disappearance of Voldemort, for the torture of Alice and Frank Longbottom
 * Antonin Dolohov - arrested during or after Voldemort's first reign, escaped after the Dementors left Azkaban, returned to Azkaban after the Battle at the Ministry, escaped.
 * Percival Dumbledore - arrested for attacking Muggles
 * Mundungus Fletcher - arrested for impersonating an Inferius
 * Marvolo Gaunt - arrested for attacking an officer of the Ministry, completed sentence, died shortly after.
 * Morfin Gaunt - arrested for attacking an officer of the Ministry and cursing a Muggle, released, re-arrested for murder of the Riddle family, died in prison
 * Rubeus Hagrid - arrested and held without trial on suspicion of being the person who released the Monster in the Chamber, released
 * Jugson - arrested after the Battle in the Ministry
 * Igor Karkaroff - arrested during Voldemort's first reign, plea-bargained for a shorter sentence, presumably released
 * Bellatrix, Rabastan, and Rodolphus Lestrange - all arrested shortly after the initial disappearance of Voldemort, for the torture of Alice and Frank Longbottom, all escaped. Rodolphus and Rabastan were sent back after the battle at the Ministry.
 * Walden Macnair - arrested after the Battle at the Ministry
 * Lucius Malfoy - arrested after the Battle at the Ministry, escaped
 * Mulciber - arrested during Voldemort's first reign, escaped. Was sent back after the Battle at the Ministry.
 * Nott - arrested after the battle at the Ministry
 * Sturgis Podmore - arrested for trying to get through a sealed door at the Ministry, sentenced to six months
 * Augustus Rookwood - arrested for passing secrets to Voldemort in his first reign, on information from Karkaroff; escaped after the Dementors left Azkaban, returned to Azkaban after the Battle at the Ministry, escaped
 * Stan Shunpike - arrested for boasting about being aware of Death Eater secrets, escaped
 * Travers - arrested in Voldemort's first reign, escaped
 * Dolores Umbridge - arrested after the Second Wizarding War for horrible mistreatment of Muggles

Analysis
Quite clearly, the first thing one must do when you imprison a wizard is to confiscate his wand; a wizard with a wand is as well-armed as a Muggle with a gun, and significantly more capable. Yet wizards do have some ability to perform magic without wands; we see Harry do so on a number of occasions, when his tension is particularly high. We also believe Apparition does not require wands. There are evidently spells that can prevent Apparition, and of course those must be set on the prison proper. That does leave the possibility of an escape being carried out by a Wizard or Witch who does wandless magic when very tense. This may be the rationale for the Dementors: by damping all good feelings, it may be impossible for the prisoners to become agitated enough to perform wandless magic. Despite all these safeguards, however, it is certainly possible for a witch or wizard to break out of Azkaban; Dumbledore has stated that he could break out of Azkaban if he was imprisoned, and large numbers of Death Eaters do so on two known occasions, though it must be noted that both of these major breakouts occurred after the Dementors had abandoned Azkaban to enter Voldemort's service, and that Dumbledore is a wizard of extraordinary skill. (Though even he might have overestimated his capability.)

One does rather feel that the use of Dementors is a bit excessive, however. You do not rehabilitate an evil wizard by driving him insane. However, we must also note that the entire penal situation in the Wizarding world seems a bit excessive, as people are imprisoned for lengthy periods without benefit of trial — Rubeus Hagrid, for instance, is imprisoned for some months on suspicion alone, and Sirius Black is imprisoned for twelve years without a trial. Granted that this situation may have sprung from adversity, and have been done in reaction to the appearance and activities of Voldemort, still one would think that with the threat abated, the use of Azkaban might fall off. That does not seem to happen, however.

Greater Picture
We find out in Harry Potter and the Prisoner of Azkaban that the Animagus transformation does not require a wand, as Sirius is able to transform when he is incarcerated and thus wandless. We believe he was able to escape because he was an unregistered Animagus; presumably, there is some way to prevent the transformation that would be used on an incarcerated registered Animagus, likely a variant of the unnamed spell that Sirius and Lupin used to unmask Peter Pettigrew. However, as there are so very few Animagi in existence, it may have been considered unnecessary to provide for their being incarcerated.

As mentioned, the use of Azkaban as a deterrent in the series seems to be excessive; it is only after Voldemort's second fall, and the accession of Kingsley Shacklebolt to the position of Minister for Magic, that the penal system is returned to what it should be. J.K. Rowling mentioned, in one of the interviews she gave after the release of Harry Potter and the Deathly Hallows, that after Voldemort's death, one of the things Kingsley Shacklebolt does as Minister for Magic is to retire control of Azkaban from the Dementors. This is part of what makes the magical world in the epilogue of the book "a sunnier one".


text:
User talk:Mist7510 student

Copyright problem with Image:NET Web Service Page.jpg
--Derbeth talk 00:28, 15 November 2005 (UTC)

 * You cannot mark Image:NET Method Page.jpg as GFDL, because it contains visual parts of copyrighted Internet Explorer of Microsoft. Please change license of all of your images to screenshot. --Derbeth [[User talk:Derbeth|talk]] 09:52, 15 November 2005 (UTC)

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

title: User talk:Mist7510 student


text:
XML - Managing Data Exchange/XQL

Learning Objectives

 * What is XQL?
 * What is an XQL Query?
 * Tutorial
 * What are the different components of XQL?

Introduction
As more and more information is either stored in XML, exchanged in		 XML, or presented as XML through various interfaces, the ability to intelligently query our XML data sources becomes increasingly important. XML documents are structured documents – they blur the distinction between data and documents, allowing documents to be treated as data sources, and traditional data sources to be treated as documents. XQL is a query language designed specifically for XML. In the same sense that SQL is a query language for relational tables and OQL is a query language for objects stored in an object database, XQL is a query language for XML documents. The basic constructs of XQL correspond directly to the basic structures of XML, and XQL is closely related to XPath, the common locator syntax used by XSL and XPointers. Since queries, transformation patterns, and links are all based on patterns in structures found in possible XML documents, a common model for the pattern language used in these three applications is		 both possible and desirable, and a common syntax to express the patterns expressed by that model simplifies the task of the user who must master a variety of XML-related technologies. Although XQL originated before XSL Patterns, there were strong similarities between the two languages, and we have adopted XPath syntax for the constructs which differed. Not all constructs found in XPath were needed for queries, and some constructs used in XQL are not found in XPath, but the two languages share a common subset. The XQL language described in this chapter contains several features not found in previously published versions of the language, including joins, links, text containment, and extensible functions. These new features are inspired in		 large part by discussions stemming from the W3C QL '98 Workshop, and make it		  possible to combine information from heterogeneous data sources in powerful ways. Great care has been made to maintain the fundamental simplicity of XQL while adding these features. This chapter is intended as input for the upcoming W3C Query Language Activity, and for the further development of XPath.

XML Query Language
Traditionally, structured queries have been used primarily for relational or object oriented databases, and documents were queried with relatively unstructured full-text queries. Although quite sophisticated query engines for structured documents have existed for some time, they have not been a mainstream application. In the last year, a number of very different approaches to querying XML have been proposed, with several distinct perspectives on what constitutes a query. Several particularly interesting proposals have come from the semi-structured database community, including XML-QL and Lorel, and adopt semi-structured approaches to XML. This proposal incorporates several ideas from those languages into XQL. XQL was designed to be used in a number of different XML environments, using a syntax that may be used in XML attributes, embedded in programming languages, or incorporated in URIs. From the beginning, we have endeavored to		 keep the language simple and small, and we have been careful not to add functionality that would make it difficult to implement XQL. During the last year, we have been persuaded to add several powerful new features that allow users to combine information from multiple sources, use the relationships expressed in links as part of a query, and search based on text containment. Queries that can make use of information in multiple documents allow the information contained in those documents to be reused in ways not foreseen by the people who created the original documents. This is extremely useful when many documents or data sources may each contain part of the information needed on a given topic. For instance, suppose one document contains a set of		 recommended books for a given course of study, another lists books and prices for a store, and third contains a set of reviews of books. A query can be		 constructed to list recommended books, their prices, and the reviews they have received. XQL is closely related to XPath, and we hope to be able to maintain compatibility with XPath as it evolves. We see XQL as complementary to XSLT, which may be used for sophisticated reshaping and formatting of query results.

XML as a Data Model
An important motivation for the design of XQL is the realization that XML has its own implied data model, which is neither that of traditional relational databases nor that of object oriented or object-relational databases. In XQL, a document is an ordered, labelled tree, with nodes to			 represent the document entity, elements, attributes, processing instructions, and comments. The model is compatible with the XML Information Set (http://www.w3.org/XML/Group/1999/04/WD-xml-infoset-19990428.html). It is important to note that the relationships among data contain a			 large proportion of the information contained in a document, which is one of			 the reasons that structured document formats like XML are useful in the first place. The original formulation of XQL was based completely on the tree structure of XML documents:   Hierarchy   parent/child   ancestor/descendant     Sequence (within a sibling list or in document order)   Position (within a sibling list or in document order)   absolute   relative

 ranges

 These relationships have long been basic to the XPointer model, and are now reflected in XPath in the form of axes. In XQL, all queries use the child axis, so we will speak in terms of parent/child and ancestor/descendant relationships rather than use the term Locator Path from the XPath Working Draft. The current draft extends this model to support the following:

 Ad-hoc relationships established via joins

 Dereferencing of links

 Joins allow subtrees of documents to be combined in queries; links allow queries to support references as well as tree structure.

What is an XML Query?
In XQL, a query returns XML document nodes from one or more XML documents. To examine the characteristics of an XQL query, it is useful to			 consider four basic questions about the environment in which a query takes place:

 What is a database?

 What is the query language?

 What is the input to a query?

 What is the result of a query?

The following table provides a brief answer to each of these questions, including a comparison with the SQL query language, which is widely used for querying relational databases: From the preceding table, it should be clear that document nodes play a central role in XQL queries. These nodes are an abstraction. Any real XQL implementation will find some concrete way to implement the nodes used in queries. For instance, XQL engines may represent the input to a query via DOM nodes, XSL nodes, index structures, or XML text. Any of these might also be			 used to represent the results of queries; in addition, hyperlinks or other references into the original document might be used, a new virtual document might be created, or DOM Level Two TreeWalkers or Iterators might be used. The nodes which form the input to a query may come from a variety of different sources. They may be the result of a prior query, the contents of a			 document repository, the nodes from a Document Object Model Nodelist, or any other source that identifies nodes from one or more documents. XQL does not specify how these nodes are brought to the query. Current XQL implementations take a variety of approaches, including the following: using Document Object Model subtrees as the basis for a query, querying whole documents supplied as			 the input to a Unix-style pipe, reading a document from the command line, using data dictionaries or repository directory structures to identify nodes to be queried, and identifying documents using a URL. This proposal adds support for merging information from heterogeneous data sources using joins. In XQL, nodes have identity, and they retain their identity, containment relationships, and sequence in query results. Grouping operators allow levels of a tree to be omitted, while still retaining the relative sequence and containment of the nodes which are returned by a query. Joins allow subtrees from one data source to be inserted into another document subtree, subject to the join conditions. Link functions are similar to joins, allowing a hypertext link in a document to be replaced by the node or nodes to which it refers. Some functions in XQL return values, which may be boolean, integer, or string. These values are also treated as nodes in the query model.

XQL Tutorial
Before going into further detail, we feel it would be helpful to present some typical XQL queries to help convey a feeling for the language. This tutorial discusses the simplest XQL queries, which are also likely to be the most common. In this tutorial, we will present a quick overview of XQL without taking the time to be precise. A simple string is interpreted as an element name. For instance, this query specification returns all <table> elements:

The child operator ("/") indicates hierarchy. This query specification returns <author> elements that are children of		 <front> elements:

The root of a document may be indicated by a leading "/" operator:

'''Ed. Note: ''' In XQL, the root of a document refers to the document entity, in the technical XML sense, which is basically equivalent to the document itself. It is not the same as the root element, which is the element that contains the rest of the elements in the document. The document root always contains the root element, but it may also contain a doctype, processing instructions, and comments. In this example,<novel> would be the root element. Paths are always described from the top down, and unless otherwise specified, the right-most element on the path is returned. For instance, in the above example, <author> elements would be returned. The content of an element or the value of an attribute may be specified using the equals operator ("="). The following returns all authors with the name "Theodore Seuss Geisel" that are children of the <front> element:

Attribute names begin with "@". They are treated as children of the elements to which they belong:

The descendant operator ("//") indicates any number of intervening levels. The following shows addresses anywhere within <front>:

When the descendant operator is found at the start of a path, it means all nodes descended from the document. This query will find any address in the document:

The filter operator ("[ ]") filters the set of nodes to its left based on the conditions inside the brackets. The following query returns addresses; each of these addresses must have a nattribute called "type" with the value "email":

Note that"address[@type='email']" returns addresses, but"address/@type='email'" returns type attributes. Multiple conditions may be combined using Boolean operators.

Brackets are also used for subscripts, which indicate position within a document. The following refers to sections 1, 3, 4, 5, and 8, plus the last section:

Conditions and subscripts may not both occur in the same brackets, but both uses of brackets may occur in the same query. The following refers to the first three sections whose level attributes have the value "3"; in other words, it returns the first three "level3" sections:

Now that we know the basics, let's take a look at a document and try some XQL queries on it. The following is an invoice document. Traditionally, invoices are often stored in databases, but invoices are both documents and data. XQL is designed to work on both documents and data, provided they are represented via XML through some interface. This document will be the basis for the sample queries that follow: <?xml version="1.0"?> <invoicecollection> <invoice> <customer> Wile E. Coyote, Death Valley, CA   </customer> <annotation> Customer asked that we guarantee return rights if these items should fail in desert conditions. This was approved by Marty Melliore, general manager. </annotation> <entries n="2"> <entry quantity="2" total_price="134.00"> <product maker="ACME" prod_name="screwdriver" price="80.00"/> </entry> <entry quantity="1" total_price="20.00"> <product maker="ACME" prod_name="power wrench" price="20.00"/> </entry> </entries> </invoice> <invoice> <customer> Camp Mertz </customer> <entries n="2"> <entry quantity="2" total_price="32.00"> <product maker="BSA" prod_name="left-handed smoke shifter" price="16.00"/> </entry> <entry quantity="1" total_price="13.00"> <product maker="BSA" prod_name="snipe call" price="13.00"/> </entry> </entries> </invoice> </invoicecollection> Now let's look at some sample queries. For these examples, we will present query results as text, using a serialization approach described in the section "Query Results and Serialization". In general, XQL queries return lists of nodes, which may be represented in any way convenient to the environment in which the query is performed, e.g. as DOM nodes, serialized XML text, XPointers, hyperlinks, or by creating an iterator to navigate the results. Since XML text is easily read, we find it suitable as a way of representing results in our examples. Suppose we wanted to see just the customers from the database. We could do the following query: Query:

Result:

<xql:result> <customer> Wile E. Coyote, Death Valley, CA </customer> <customer> Camp Mertz </customer> </xql:result> We might want to look at all the products manufactured by BSA. This query would do the trick: Query:

Result:

<xql:result> <product maker="BSA" prod_name="left-handed smoke shifter" price="16.00"/> <product maker="BSA" prod_name="snipe call" price="13.00"/> </xql:result> Filters are particularly useful when specifying conditions on paths that are not the same as what is returned. For instance, the following query returns the products ordered by Camp Mertz: Query:

Result:

<xql:result> <product maker="ACME" prod_name="screwdriver" price="80.00"/> <product maker="ACME" prod_name="power wrench" price="20.00"/> </xql:result> This is the end of the tutorial, which covers only the most basic features of XQL. For examples illustrating newer or more advanced features, such as return operators, sequence, joins, references, and user-defined functions, see the appropriate parts of the next section.

XQLExpressions
An XQL query is always evaluated for a context, which is a list of document nodes. The initial context for a query is known as the start context. In XQL, the nodes in a start context may come from different documents, and even if they are in the same document, there is no assumption that they come from contiguous portions of the document. Some XQL operators establish a new context in which a subexpression will be evaluated; for instance, in the expression "author/name", "author" is evaluated in the start context. For each author, the "/" operator establishes a new context consisting of the children of that author, and "name" is evaluated in that context. The operators that establish a new context are /, //, and []. '''Ed. Note: ''' In XSL, expressions are evaluated with respect to a node which is called the context node. Our use of the term "context" is intended to allow semantic consistency with XSL Patterns without imposing unecessary restrictions on the query language. As a consequence, XSL Patterns are defined in terms of children of the context node, and XQL queries are defined in terms of the context node directly. We maintain the correspondence of XSL Pattern definitions and XQL definitions by constructing an imaginary context node that contains the nodes of the context, and allowing the XSL term "." to map to this context node.

Terms
The following expressions are terms, which select particular nodes from the context based on the type or name of the node:

Namespaces and names
In XML expressions, names may be associated with namespace prefixes. A namespace prefix can be declared using a variable declaration. In the following query, the first line declares "b" to be a variable equivalent to the namespace URL "http://www.TwiceSoldTales.com". The second line of the query searches for all <book> elements belonging to this namespace: b := "http://www.TwiceSoldTales.com"; //b:book An XML document may well use a different namespace prefix for the same namespace URI. Matching is done on the basis of the namespace URI, not the prefix associated with it in the document or in the XQL query. XQL expressions can explicitly state whether namespaces should be taken into account when matching node names: The same conventions apply to attribute names. In attribute names, the attribute prefix comes before the namespace prefix: @lib:isbn Namespaces are preserved in the output of a query. To change the namespaces of nodes in the output, use the Renaming Operator.

Comparisons
Comparisons add constraints based on the content or value of nodes. Consider the following examples:

Regardless of the node type on the left hand of the comparison, it is compared to the value on the right. For systems that use a schema that supports data types, they are used in comparisons:

Since some environments in which XQL is used have restricted character sets, e.g. URIs or queries stored in attribute values, many comparisons have an alternative syntax that meets the syntactic constraints of these environments. For instance, the following two queries are equivalent:

The following comparison operators are available in XQL: Text comparisons support the wildcard characters "*" and "?". Consider the following example: Data:

<editor> <name> <first> Ramesh </first> <last> Lekshmynarayanan </last> </name> </editor></customer>

Query:

The value "Leksh*" matches the name "Lekshmynarayanan", and the <editor> element is returned. The following operators may be defined in XQL environments that support data types:

Hierarchy and Filters
These operators establish a new search context and evaluate a subexpression within that context. In this table, Q1 and Q2 are used to denote arbitrary XQL expressions.

Boolean and Set Operators
Terms or other XQL expressions may be combined using boolean operators and set operators: The "both" operator was introduced because we found that many queries use filters to express constraints on the same data that is returned outside the filter, resulting in expressions that are rather redundant. For instance, the following query uses filters to express that only invoices for the customer named "Wile E. Coyote"that also contain products are of interest, and both the customer name and the set of products should be returned:

//invoice[customer[name='Wile E. Coyote'] and .//product]/(customer | .//product)

Using the "both" operator, this same query can be expressed more concisely:

//invoice/(customer[name='Wile E. Coyote'] ~ .//product)

Note that the "both" operator is neither the boolean "or" operator nor the set intersection operator. The expression "customer intersect product" always returns an empty result since no element is ever simultaneously a <customer> element and a <product> element. The "both" operator is used to specify conditions which must simultaneously be satisfied for the context.

Grouping Operator
It is often useful to group results using the structure of the original document. For instance, a query that lists the products on invoices might want to group products by invoice, placing each group of products within an invoice tag. XQL provides a grouping operator that provides exactly this functionality. In the following query, the element to the left of the curly braces (the Grouping Element) is used to group the results of the query within the braces:

For each grouping element matched by the query, the grouping operator creates an empty element with the same name. The results of the query contained within the curly braces are then appended to this new node as children. If we apply this query to the invoice data presented in the tutorial, we obtain these results: <xql:result> <invoice> <product maker="ACME" prod_name="screwdriver" price="80.00"/> <product maker="ACME" prod_name="power wrench" price="20.00"/> </invoice> <invoice> <product maker="BSA" prod_name="left-handed smoke shifter" price="16.00"/> <product maker="BSA" prod_name="snipe call" price="13.00"/> </invoice> </xql:result> Complex queries that use the grouping operator can be made more readable by the appropriate use of whitespace, eg:

invoice { .//customer[name contains "Coyote"] { name | address } ~  entries { .//product[@maker="ACME"] }	}

Sequence
XQL defines the following operators for sequence: The list concatenation operator is used to specify order in return lists. In general, XQL operators maintain document order; the concatenation operator allows an order to be specified within a return list. For instance, the following query specifies that the order of the returned results should be author, then title, then isbn:

//book//(author, title, isbn)

If there is more than one author, all authors will be listed before the title. In systems where XML is used mainly to represent data from object oriented systems or relational databases, sequence may not be particularly important. However, sequence is important in documents, and it also can be useful in data-oriented applications where the markup does not clearly indicate the role of each element. Consider the following table, which lists the latest scores for some fictitious sport:

The markup for this table looks like this:

<table width="50%" border="1"> <tbody> <tr> <td colspan="2"><emph>Western League</emph> </td> </tr> <tr> <td Aardvarks 12</td> <td>Weasels 10</td> </tr> <tr> <td Mosquitos 17</td> <td>Bulls 2</td> </tr> <tr> <td colspan="2"><emph>Southern League</emph></td> </tr> <tr> <td Tortoises 25</td> <td>Hares 0</td> </tr> <tr> <td Platypii 17</td> <td>Amoebae 16</td> </tr> </tbody> </table> Purists may object that this is not particularly good markup, since it does not clearly distinguish the leagues from the scores. We agree, and when we write our own documents, we would write them differently; however, there is a lot of mediocre markup in the real world, and when querying documents, we do not have the luxury of rewriting them first. Therefore, we feel that a query language should be able to manage data like that shown above. To find all the latest scores for the Western League, we can use the following query:

table//((tr after (tr contains "Western League")) before (tr contains "Southern League")) '''Ed. Note: ''' Sequence is handled by axes in XPath. We believe that an XML query language should provide some means for allowing sequence in queries, and that various approaches should be considered. The approach discussed here has advantages in expressing relationships among multiple nodes, especially when comparisons are to be made only within the descendants of a particular node.

Functions
Most of the functions of XQL have been taken directly from XSL Pattern Language. A few functions have been added, many more have been omitted because we found them to be less relevant in a pure query environment than in a general purpose transformation environment. Collection functions

Extensible Functions
Many XQL implementations are part of a programming environment. In these environments, it is helpful to allow users to write their own functions, which may be used in queries. This must be done in a language-independent manner, since XQL implementations have been done in a variety of languages, including C++, Java, Haskell, and Perl. To allow user-defined functions to be written, XQL provides a function called "function". Suppose a user wanted to add a function that computes the average for a list of values. The user could write a function called "average" and call it in an XQL query like this:

User-defined functions are typically written in the language environment of the XQL implementation; for instance, if the XQL implementation is written in Java, user-defined functions are generally written as Java functions. All XQL functions are passed the list of nodes in the current context. If the function has parameters, these are passed as strings to the XQL function. Typically, the function will evaluate these parameters as queries against the current context; for instance, the user code that implements the "average" function might first execute the query "property//price" for the current context to obtain a set of <price> elements, then compute the average of these elements. The result of a function call is also a nodelist. If a single value is to be returned, such as a string or a number, it should be returned as an element node of that type:

The available set of types that may be returned by functions is described in the section "Query Results and Serialization", which follows the current section. If a function is called with the wrong parameters, this may be communicated by returning an <xql:warning> element in the result:

'''Ed. Note: ''' Some vendors have asked that extensible operators be provided as well. This would be a useful feature; so far, we have not found a clean design for extensible operators in XQL. Issue (function-namespace):  There are differing opinions as to whether namespaces add significant value as vendors and users add functions to XQL.

Joins
'''Ed. Note: ''' Joins are a new feature in XQL. The approach to joins discussed in this section comes largely from Peter Fankhauser of the GMD-IPSI and Harald Schöning of Software AG. Gerald Huck of the GMD-IPSI has been particularly helpful in refining the initial model. There is some preliminary implementation experience with this approach. In many environments, it is useful to be able to combine information from multiple sources to create one unified view. For instance, suppose we have a source of books and a source of reviews: <book> <isbn> 84-7169-020-9 </isbn> <title> Tales of the Alhambra </title> <author> Washington Irving </author> </book>

<review> <isbn> 84-7169-020-9 </isbn> <title> Tales of the Alhambra </title> <reviewer> Ricardo Sanchez </reviewer> <comments> A romantic and humorous account of the time that the author of "The Legend of Sleepy Hollow" lived in an Arabian palace in Spain. </comments> </review> We may want to combine these to create a view of the book that includes the comments found in reviews:

<book> <isbn> 84-7169-020-9 </isbn> <title> Tales of the Alhambra </title> <author> Washington Irving </author>

<review> <reviewer> Ricardo Sanchez </reviewer> <comments> A romantic and humorous account of the time that the author of "The Legend of Sleepy Hollow" lived in an Arabian palace in Spain. </comments> </review> </book> This amounts to inserting information from the review into the book. If we had a database that consisted only of this one book and this one review, we could obtain the desired result with this query: /book { isbn | title | author | //review { reviewer | comments } } If we are using a database with many books and many reviews, the above query would include the whole list of reviews in every single book, not just the reviews for the book in question. We need some way to restrict our reviews to those that have the same ISBN number as the book. We will do this by introducing correlation variables. In the following example, "$i := isbn" assigns the variable "$i" to the evaluation of isbn in the context of each book. The expression "//review[isbn=$i]" restricts the reviews to those that match "$i":

/book[$i:=isbn] { isbn | title | author | //review[isbn=$i] { reviewer | comments } } '''Ed. Note: ''' Although filters and variable bindings both use square bracket notation, variable bindings do not filter results. For instance, the expressions "/book" and "/book[$i:=isbn]" will always return the same set of books, whether or not any <isbn> elements are present. Variable bindings propogate as new search contexts are created; when a new context is created, e.g. as the result of a child or descendant operator, it inherits all variable bindings that are active. This allows bindings declared high in the document hierarchy to be used for joins performed lower down. If a correlation variable is bound to a subexpression that evaluates to more than one result, any value in the list of results will be used as the basis for a join. To be precise, "list1 relop list2" evaluates to "all e1 in list1 such that for some e2 in list2, e1 relop e2 is satisfied". The following query returns books whether or not they have an isbn; reviews are returned only if they have a matching isbn:

/book[$i:=isbn] { $i | title  | author | //review[isbn=$i] { reviewer | comments } }

'''Ed. Note: ''' In this example, it seems intuitive to say that you can't join on null - a book with no isbn does not match all reviews that have no isbn. On the XQL mailing list, there is some difference of opinion as to whether it should be possible to join on null. In XQL, square brackets are used for three distinct things that can not be mixed: subscripts, filters, and variable bindings. If you want both a filter and a variable binding, you must use separate sets of brackets:

/book[isbn][$i:=isbn] { $i | title  | author | //review[isbn=$i] { reviewer | comments } }

RenamingOperator
The nodes in a list may be renamed using the renaming operator "->". In joins, this can be used to reflect a meaningful name that describes the synthesized result:

/book[isbn][$i:=isbn] -> BookWithReviews { $i | title  | author | //review[isbn=$i] { reviewer | comments } }

The renaming operator may also be used to adjust namespaces in query results. Since renaming changes the name of a node, it also changes the namespace. For instance, suppose <book> is in the namespace of "http://www.TwiceSoldTales.com", and we rename the <book> element to <livre>: //book->livre

We can assume that <livre> is not defined in the namespace associated with "http://www.TwiceSoldTales.com". Since renaming often creates element names that do not exist in the original namespace, renaming in XQL does not keep the namespace of the original node name. This property of the renaming operator can be used to remove namespaces; for instance, the following query places <book> elements in the default namespace, regardless of their original namespace: //book->book

New namespace prefixes may be explicitly applied with the rename operator: //book->a:book

Precedence of Operators
XQL expressions are evaluated from left to right. The following table shows the precedence of operators in XQL:

Parentheses may be used for grouping: (author | editor)/name

author | (editor/name)

Query Results and Serialization
In some environments, the results of a query are returned as XML text. XQL defines a serialization format to allow the results of queries to be returned as well-formed XML documents. Namespaces are used to distinguish tags belonging to the serialization format from tags returned by the query. When query results are serialized, they are wrapped in an <xql:result> element: <xql:result xmlns:xql="http://www.metalab.unc/xql/serialization"> <customer> Wile E. Coyote, Death Valley, CA </customer> <customer> Camp Mertz </customer> </xql:result>

The reason for this is that a well-formed XML document may have only one root element, and queries may return any number of results. Other XQL serialization elements are used to return values from functions, provide additional information about a query, or indicate errors or warnings. The following elements are defined in the XQL serialization namespace:

title: XML - Managing Data Exchange/XQL


text:
Talk:TI-Basic Z80 Programming

This version two of this talk page. To see the archived version, goto Talk:Programming:TI-Basic/Archive

Where does the TI 86 fit in?
Where does the TI-86 fit into this? All the info about applicability to different versions skip any mention of the TI-86 which is confusing. -Brentt 75.83.67.181 (talk) 19:35, 27 September 2008 (UTC)

 * Most Likely it's due to the fact that the TI-86 isn't as popular as the TI-83/84 and the TI-89. I don't know anything about the TI-86, but I would assume that they are completely different. --Jimmyatic (talk) 00:22, 24 October 2008 (UTC)

Removed "old" notice
Previously, there was a notice at the top of this page stating, "This is the old discussion page, about the old Programming:TI-Basic. All further edits/talks should be made at the new TI-Basic 84 Programming." However, this book has more information than TI-Basic 84 Programming. Either the information was incompletely moved, or people have continued to edit this book. Both projects are not very active. I believe this book should continue to be developed for two reasons. First, the name TI-84 Basic Programming is too specific. The TI-84 uses the TI Basic Z80 version of the language, as well as the TI-83. I do acknowledge, however, that the name "TI-Basic 84" will catch more hits versus TI Basic Z80 on a list. However, the search suggestions only reluctantly list the TI-Basic 84 project,. Second, and as I mentioned before, the TI Basic Z80 project has more information. In any case, I have added "see also" links to both pages, to ensure readers briefly examine both resources. I do think that the cover page of the TI-Basic 84 project looks nicer and is more organized. Good night. AllenZh (discuss • contribs) 02:50, 28 May 2012 (UTC)

title: Talk:TI-Basic Z80 Programming


text:
User:Inuchan74

Hi everyone, My name's Emi (栄光). I'm a pre-vet student in college and animals and everything Japanese is my life ^_^

栄光(えみ)

title: User:Inuchan74


text:
Novial/Wizard of Oz 2

Novial home

Kontenaje - Chapitre 1 - Chapitre 2

Chapitre Du

Li Konsilo kun li Munchkines

La blid vekisa per choko, talim subiti e severi ke si Dorothy non liad sur li moli lite la povud ha bli nosa. Kom esed, li skuso fad la ye halta pokitem spira e ye questiona se quu had eventa; e Toto posid sen koldi, mikri nase en lan fasie e ploretad malim. Dorothy sideskad rekti e observeskad ke li hause non movad; anke non esed sinlumosi, den li sune-brilio inveni tra li fenestre, lumisant li mikri chambre. La saltad fro sur sen lite e kun Toto an sen talones kursed e apertad li porte.

Li mikri puera kriad surprisat e regardad sirk la, sen okules kreskant plu e plu grandi pro li marvelosi vidatus kel la vidad.

Li siklone had subplasa li hause tre dolsim – relat siklone – mid lande de marvelosi beleso. Esed amindi areas de verdosi gasone an omni flanke, kun majestosi arbres portant richi e saporosi fruktes. Multi belisi flores esed an omni flanke, e fogles kun rari e brilianti plumaje kantad e voletad in li arbres e arbustes. Pokim for esed mikri riverete, torentant e sintiletant inter verdi rives, e sursurant per voise tre gratitudisant a mikri puera kel had lojia talim longitem sur li siki, grisi stepes.

Durant ke la stead regardant voluntim li stranji e beli vidatus, la observeskad venienti vers la grupe del maxim stranji homes kel la had irgitem unque vida. Les non esed tam grandi kam li kreskat homes kun kel la had sempre es familiari; ma anke les non esed tre mikri. Faktim, les semblad sirk tam alti kam Dorothy, kel esed bonim kreskat puere relat sen aje, quankam les esed, segun lesen aspektos, multi yares plu oldi.

Tri ek les esed viros e un esed fema, e omnes esed stranjim vestat. Les portat rondi chapeles kel vadad supru a mikri punte ye un pede super lesen kapes, kun mikri kloches sirk li bordes kel klochetad dolsim durant ke les movad. Li chapeles del viros esed blui; li mikri feman chapele esed blanki, e la portad blanki robe kel pendad kom faldes fro lan shultres. Super lu esed arosat mikri astres kel sintileskad in li sune kom diamantes. Li viros esed vestat in blue, del sami kolore kam sen chapeles, e portad bonim polit butes kun profundi rule de blue an li kulmines. Li viros, Dorothy pensad, esed sirk tam oldi kam Onklo Henry, den du ek les haved barbes. Ma li mikri fema esed sinduto multi plu oldi. Lan fasie esed kovrat per sulkes, lasen hares esed preske blanki, e la marchad kelkigrad rigidim.

Kand disi homes proximeskad li hause vor Dorothy stead in li porte, les pausad e chuchotad a mutu, quasi pavorosi ye veni plusim. Ma li mikri, oldi fema marchad til Dorothy, flekted basim e dikted, kun dolsi voise:

“Vu es bonvenit, maxim nobli Sorsiera, al lande del munchkines. Nus es talim gratitudosi a vu pro havant tua li Mali Sorsiera del Este, e pro liberisant nusen popule fro sklaviro.”

Dorothy askoltad disi diktione surprisat. Quu li mikri fema volid dikte per noma la sorsiera, e per dikte ke la had tua li Mali Sorsiera del Este? Dorothy esed inosenti, non-nosiv, mikri puera, kel had bli porta per siklone a multi mailes fro sen heme; e la had nulitem tua ule durant sen toti vivo.

Ma li mikri fema evidentim expektad lan responso; dunke Dorothy dikted, sin hesito, ”Vu es tre kordial, ma mus es erore. Me non ha tua ule.“

“Vun hause ha, qualim unque,“ li mikri oldi fema repliked, kun rido, “e tu es li sami kose. Vida!“ la kontinuad, indikant al angule del hause. “Dar es lan du pedes, ankore saliant fro sub bloke de ligne.“ Dorothy regardad, e krietad pro timo. Dar, verim, presisim sub li angule del grandi trave sur kel li hause stead, du pedes saliad, shuad in arjenti shues kun puntisat pede-fingres.

“Ho ve! Ho ve!” Dorothy kriad, tenant sen manus kunu konsternatim. ”Li hause mus ha fala a sur la. Quu nus sal fa?”

”Nulu es faenda”, li mikri fema dikted kalmim.

”Ma que la esed?” Dorothy questionad.

“La esed li Mali Sorsiera del Este, kom me ha dikte,” li mikri fema responsad. ”La ha tena omni li munchkines in sklaviro durant multi yares, forsant les sklavira por la noktim e jornim. Nun les omni es liberisat, e es gratitudosi a vu pro li favore.”

“Que li munchkines es?“, Dorothy questionad.

“Les es li popule kel habita dis lande del Este vor li Mali Sorsiera regnad.”

“Ob vu es munchkine?” Dorothy questionad.

“No, ma me es lesen amike, quamkam me habita li lande del Norde. Kand les vidad kel Sorsiera del Este esed morit li munchkines sendad rapidi masajere a me, e me venid instantim. Me es li Sorsiera del Norde.“

“Ho, gratiosi!“ Dorothy kriad. “Ob vu es reali sorsiera?”

“Yes, verim,“ li mikri fema responsad. “Ma me es bon sorsiera, e li popule ama me. Me non es tam potenti kam esed li Mali Sorsiera kel regnad hir, si talim me self vud ha liberisa li popule.”

“Ma me kredad ke omni sorsieras esed mali,” dikted li puera, kel esed mi-pavorisat fasiant real sorsiera.

“Ho, no, tu es grandi erore. Esed nur quar sorsieras in omni li Lande de Oz, e du ek las, tas kel lojia in li Norde e li Sude, es bon sorsieras. Me sava ke dis es veri, den me self es un ek las, e non pove erora. Tas kel lojiad in li Este e li Weste esed, ya, mali sorsieras; ma nun pro ke vu ha tua un ek las, es nur un Mali Sorsiera in omni li Lande de Oz – ta kel lojia in li Weste.“

“Ma,“ Dorothy dikted after penso durant un momente,“Tanta Em ha dikte a me ke omni li sorsieras esed morit – yares e yares ante nun.“

“Que es Tanta Em?“, questionad li mikri oldi fema.

“La es men tanta kel lojia in Kansas, fro vor me venid.”

Li Sorsiera del Norde semblad pensa durant kelki tempe, kun sen kape sube e sen okules vers li tere. Tand la regardeskad supru e dikted, ”Me non sava vor Kansas es, den me nulitem ante audid ti lande ye bli mentiona. Ma dikte a me, ob lu es sivilisat lande?”

”Ho, yes,” Dorothy respondad.

”Dunke tu explika lu. In sivilisat landes me kreda ke es nuli restanti sorsieras, ni sorsieros, ni magas, ni magos. Ma, komprenda, li Lande de Oz nulitem ha es sivilisat, pro ke nus es separat fro omni li seteri monde. Pro tu nus ankore have sorsieras e sorsieros inter nus.“

“Que es li sorsieros?” Dorothy questionad.

“Oz self es li Grandi Sorsiero,” li Sorsiera respondad, basifikant sen voise a susuro. “Lo es plu potenti kam omni seteri nus kombinat. Lo lojia in li Urbe de Smeraldes.”

Dorothy saled questiona altri questione, ma jus tand li munchkines, kel had proximu stea silentiosim, klamad lautim e indikad vers li angule del hause vor li Mali Sorsiera had lia.

“Quu es?” li mikri oldi fema questionad, e regardad, e komensad rida. Li pedes del morit Sorsiera had totim desaperi, e nulu restad exept li arjenti shues.

”La esed talim oldi,” li Sorsiera del Norde explikad, ke la parsikeskad rapidim sub li sune. Tu es li fine de la. Ma li arjente shues es vun, e vu sal have lus por porta.” La moved sen manu subu e prendad supru li shues, e after skusa li polve ek lus donad lus a Dorothy.

“Li Sorsiera del Este esed fieri ye ti arjenti shues,” un ek li munchkines dikted, “e es kelki sorsio relat lus; ma quu lu es nus nulitem savad.”

Dorothy portad li shues en li hause e plasad lus sur li table. Tand la riveni eku al munchkines e dikted:

“Me pavoreta e voli retrovada a men tanta e onklo, pro ke me es serti ke les sal pavoreta pri me. Ob vu pove helpa me trova men vie?”

Li munchkines e li Sorsiera regardad mutu, e tand Dorothy, e tand osilifikad sen kapes.

“In li Este, non ferni fro hir,” dikted un, “es grandi desertu, e nule povud vado trans lu e viva.“

“Es sami in li Sude,“ altre dikted, “den me ha es dar e vida lu.“ Li Sude es li lande del quadlinges.“

“On ha dikte,“ li triesmi home dikted, "ke es sami in li Weste. E ti lande, vor li Winkies lojia, es regnat dal Mali Sorsiera del Weste, kel vud fa vu sen sklave si vu vada lan vie.“

“Li Norde es men heme,“ li oldi siniora dikted, "e an sen borde es li sami grandi desertu kel sirkumda disi Lande de Oz. Me regreta, men kara, ke vu sal mus lojia che nus.“

Dorothy komensad ploreta pro disu, den la sentid solitari inter dis omni stranji homes. Lan lakrimes semblad chagrina li kordial munchkines den les instantim ekprendad sen nase-tukes e komensad plora anke. Pri li mikri oldi fema, la froprendad sen bonete e balansad li punte sur li kulmine de sen nase, durant ke la kontad ”Un, du, tri” kun soleni voise. Instantim li bonete chanjad en plake de ardese, sur kel esed skriptet kom grandi, blanki literes de krete:

”LET DOROTHY VADA AL URBE DE SMERALDES”

Li mikri oldi fema prendad li plake fro sen nase, e hant lekte li vordes sur lu, questionad, ”Ob vun nome es Dorothy, men kara?”

"Yes," li puere respondad, regardant supru e sikisant sen lakrimes.

"Dunke vu mus vada al Urbe de Smeraldes. Tamen Oz sal helpa vu."

"Vor es li urbe?" Dorothy questionad.

"Lu es exaktim mid li lande, e es regnat da Oz, li Grandi Sorsiero pri kel me ha dikte a vu."

"Ob lo es bon viro?" li puere questionad pavoretosim.

"Lo es bon Sorsiero. Ob lo es viro o non me non pove dikte, den me nulitem ha vida lo."

"Qualim me pove ariva dar?" Dorothy questionad.

"Vu mus marcha. Lu es longi voyaje, tra lande kel es kelkitem plesanti e kelkitem deslumosi e horosiv. Tamen, me sal usa omni magi artes kel me sava por protekte vu."

"Ob vu non sal vada kun me?" pledad li puera, kel had komensa vida li mikri, oldi fema kom sen soli amike.

"No, me non pove fa lu," la respondad, "ma me sal dona a vu men basio, e nule sal osa nosa persone kel ha bli basia dal Sorsiera del Norde."

La proximeskad Dorothy e basiad la dolsim sur li fronte. Vor lan labies tuchad li puera les restisad rondi, briliant marke, kom Dorothy deskovrad bald aftru.

"Li vie al Urbe de Smeraldes es pavat per gelbi brike," li Sorsiera dikted, "dunke vu non pove misa lu. Kand vu sal ariva a Oz non tima lo, ma dikte vun rakonte e prega ke lo helpa vu. Adie, men kara."

title: Novial/Wizard of Oz 2


text:
XML - Managing Data Exchange/XML Encryption

Author: Shayla S. Lee 02:38, 15 November 2005 (UTC)

Introduction
XML encryption was developed to address two common areas not addressed by the Transport Layer Security and Secure Socket Layer protocol (TLS/SSL). TLS/SSL is a very secure and reliable protocol that provides end-to-end security sessions between two parties. XML adds an extra layer of security to TLS/SSL by encrypting part or all of the data being exchanged and by allowing for secure sessions between more than two parties. In other words, each party can maintain secure or insecure sessions with any of the communicating parties, and both secure and non-secure data can be exchanged in the same document. Furthermore, XML encryption can handle both XML and non-XML (e.g. binary) data.

Encryption Syntax
All XML encrypted files must start with the following XML preamble, declaration, internal entity, and import.

Schema Definition:  <!DOCTYPE schema PUBLIC "-//W3C//DTD XMLSchema 200102//EN" "http://www.w3.org/2001/XMLSchema.dtd" [    <!ATTLIST schema xmlns:xenc CDATA #FIXED 'http://www.w3.org/2001/04/xmlenc#' xmlns:ds CDATA #FIXED 'http://www.w3.org/2000/09/xmldsig#'> <!ENTITY xenc 'http://www.w3.org/2001/04/xmlenc#'> <!ENTITY % p '' > <!ENTITY % s '' > ]>

EncryptedType Element
EncryptedType is the abstract type from which EncryptedData and EncryptedKey are derived.

Schema Definition:

Syntax Explanation

EncryptionMethod is an optional element that describes the encryption algorithm applied to the cipher data. If the element is absent, the encryption algorithm must be known by the recipient or the decryption will fail.

ds:KeyInfo is an optional element that carries information about the key used to encrypt the data. Subsequent sections of this specification define new elements that may appear as children of ds:KeyInfo.

CipherData is a mandatory element that contains the CipherValue or CipherReference with the encrypted data.

EncryptionProperties can contain additional information concerning the generation of the EncryptedType (e.g., date/time stamp). <element ref='xenc:EncryptionProperties' minOccurs='0'/>

Id is an optional attribute providing for the standard method of assigning a string id to the element within the document context. <attribute name='Id' type='ID' use='optional'/>

Type is an optional attribute identifying type information about the plaintext form of the encrypted content. While optional, this specification takes advantage of it for mandatory processing in dycryption. If the EncryptedData element contains data of Type 'element' or element 'content', and replaces that data in an XML document context, it is strongly recommended the Type attribute be provided. Without this information, the decryptor will be unable to automatically restore the XML document to its original cleartext form. <attribute name='Type' type='anyURI' use='optional'/>

MimeType is an optional (advisory) attribute which describes the media type of the data which has been encrypted. The value of this attribute is a string with values defined by [MIME]. For example, if the data that is encrypted is a base64 encoded PNG, the transfer Encoding may be specified as 'http://www.w3.org/2000/09/xmldsig#base64' and the MimeType as 'image/png'. This attribute is purely advisory; no validation of the MimeType information is required and it does not indicate the encryption application must do any additional processing. Note, this information may not be necessary if it is already bound to the identifier in the Type attribute. For example, the Element and Content types defined in this specification are always UTF-8 encoded text. <attribute name='MimeType' type='string' use='optional'/>

EncryptionMethod Element
EncryptionMethod is an optional element that describes the encryption algorithm applied to the cipher data. If the element is absent, the encryption algorithm must be known by the recipient or the decryption will fail. The permitted child elements of the EncryptionMethod are determined by the specific value of the Algorithm attribute URI.

Schema Definition: <complexType name='EncryptionMethodType' mixed='true'> <element name='KeySize' minOccurs='0' type='xenc:KeySizeType'/> <element name='OAEPparams' minOccurs='0' type='base64Binary'/> <any namespace='##other' minOccurs='0' maxOccurs='unbounded'/> <attribute name='Algorithm' type='anyURI' use='required'/> </complexType>

CipherData Element
CipherData is a mandatory element that provides the encrypted data. It must either contain the encrypted octet sequence as base64 encoded text of the CipherValue element, or provide a reference to an external location containing the encrypted octet sequence via the CipherReference element.

Schema Definition: <element name='CipherData' type='xenc:CipherDataType'/> <complexType name='CipherDataType'> <element name='CipherValue' type='base64Binary'/> <element ref='xenc:CipherReference'/> </complexType>

CipherReference Element
CipherReference identifies a source which, when processed, yields the encrypted octet sequence CipherReference is used when CipherValue is not supplied directly. The actual value is obtained as follows. The CipherReference URI contains an identifier that is dereferenced. Should the CipherReference element contain an OPTIONAL sequence of Transforms, the data resulting from dereferencing the URI is transformed as specified so as to yield the intended cipher value. For example, if the value is base64 encoded within an XML document; the transforms could specify an XPath expression followed by a base64 decoding so as to extract the octets.

Schema Definition: <element name='CipherReference' type='xenc:CipherReferenceType'/> <complexType name='CipherReferenceType'> <element name='Transforms' type='xenc:TransformsType' minOccurs='0'/> <attribute name='URI' type='anyURI' use='required'/> </complexType>

<complexType name='TransformsType'> <element ref='ds:Transform' maxOccurs='unbounded'/> </complexType>

Cipher Reference with Optional Tranform feature and Tranform Algorithm:

<CipherReference URI="http://www.example.com/CipherValues.xml"> <Transforms> <ds:Transform Algorithm="http://www.w3.org/TR/1999/REC-xpath-19991116"> <ds:XPath xmlns:rep="http://www.example.org/repository"> self::text[parent::rep:CipherValue[@Id="example1"]] </ds:XPath> </ds:Transform> <ds:Transform Algorithm="http://www.w3.org/2000/09/xmldsig#base64"/> </Transforms> </CipherReference>

EncryptedData Element
EncryptedData is the core element in the syntax. Not only does its CipherData child contain the encrypted data, but it's also the element that replaces the encrypted element, or serves as the new document root.

Schema Definition: <element name='EncryptedData' type='xenc:EncryptedDataType'/> <complexType name='EncryptedDataType'> <complexContent> <extension base='xenc:EncryptedType'> </complexContent> </complexType>

Resources
The information above was obtained from W3C and IBM. For more information, please visit the following links: http://www.w3.org/TR/2002/CR-xmlenc-core-20020802/#sec-Encryption-Syntax http://www-128.ibm.com/developerworks/xml/library/x-encrypt/


text:
User:MatthewMitchell~enwikibooks

Welcome to my Wikibooks domain. I spend my time in Wikipedia working in military history, but here I will be working in the Media Studies Department, specifically working in developing Film History. Look me up as I start compiling and creating texts for the curriculum in the future...(help greatly appreciated!!!)

title: User:MatthewMitchell~enwikibooks


text:
File:Exchanger1.png

Summary
I used the exchanger xml lite and coppied a print screen to illustrate the toolbar.

title: File:Exchanger1.png


text: Template:Bookbinding/TOC

title: Template:Bookbinding/TOC


text:
File:Exchange2.png

Summary
Screenshot of Exchanger Lite used to illustrate how to create a project folder.

title: File:Exchange2.png


text:
XML - Managing Data Exchange/Exchanger XML Lite

Exchanger XML Lite
Cladonia offers an xml editor at http://www.exchangerxml.com/ for free noncommercial use, and can be downloaded without registration.

This is a Java-based product that runs on all platforms including Windows, Linux, Mac OSX and UNIX.

(NOTE: If you need an XML editor for commercial use, you can get a free 30-day trial of Exchanger XML Professional at http://www.exchangerxml.com)

Single Entity in Exchanger XML Lite
The following directions will lead you step-by-step through doing the same project that is found in the ../A single entity chapter.

Part One: Creating the Project Folder
1) Open Exchanger XML Lite

2) Click on:      -Project       -New Project : a "New Project" folder will appear                  in the project folder window 3) Type "TourGuide" over the "New Project" title to change the name of the new project to TourGuide.

Part Two: Creating the Schema File
1) Click on:      -File       -New        -For Type        -Scroll to "XML Schema Definition" and highlight it        -OK 2)Exchanger automatically puts the beginning and ending tags in the file for you, however, for our example, delete those automatic tags, and copy and paste the following code into the file:

                <xsd:element name="elevation" type="xsd:integer"/> <xsd:element name="longitude" type="xsd:decimal"/> <xsd:element name="latitude" type="xsd:decimal"/> <xsd:element name="description" type="xsd:string"/> <xsd:element name="history" type="xsd:string"/> </xsd:sequence> </xsd:complexType> </xsd:schema>

3) Click on the GREEN CHECK to Validate, and the BROWN CHECK to check for Well-Formedness. These can be found on the toolbar:

(NOTE: Be sure to eliminate any "white space" before the text that you paste, or you may have an error when validating.)

4)Click on:  -File   -Save    -"city.xsd" 5)Right Click on: -"TourGuide" project folder -Add File -click on "city.xsd" -open (Note: Now the project "TourGuide" should contain one file,    "city.xsd".)

Part Three: Creating the Style Sheet
1)Click on:  -File   -New    -For Type    -Scroll to "XML StyleSheet Language" and highlight it     -OK 2)Delete any automatic tags that appear, and cut and paste the following code into the file: <?xml version="1.0" encoding="UTF-8"?> <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> <xsl:output method="html"/> <xsl:template match="/"> Tour Guide Cities <xsl:apply-templates select="tourGuide"/> </xsl:template> <xsl:template match="tourGuide"> <xsl:for-each select="city"> <xsl:text>City: </xsl:text> <xsl:value-of select="cityName"/> <xsl:text>Population: </xsl:text> <xsl:value-of select="population"/> <xsl:text>Country: </xsl:text> <xsl:value-of select="country"/> </xsl:for-each> </xsl:template> </xsl:stylesheet>

3) Click on the GREEN CHECK to Validate, and the BROWN CHECK to check for Well-Formedness. (NOTE: Be sure to eliminate any "white space" before the text that you paste, or you may have an error when validating.)

4)Click on:  -File    -Save As    -"city.xsl" 5)Right Click on: -"TourGuide" project folder -Add File -"city.xsl" -open

(Note: Now the project "TourGuide" contains two files,    "city.xsd", and "city.xsl".)

Part Four: Creating the XML File
1) Click on: -File   -New   -Default XML Document    -OK 2) Delete any automatic tags that appear and copy and paste the following code: <?xml version="1.0" encoding="UTF-8"?> <?xml-stylesheet href="city.xsl" type="text/xsl"?>

<tourGuide> xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:noNamespaceSchemaLocation='city.xsd'> <cityName>Belmopan</cityName> <adminUnit>Cayo</adminUnit> Belize 11100    5     130     88.44     17.27     Belmopan is the capital of Belize Belmopan was established following the devastation of the former capitol, Belize City, by Hurricane Hattie in 1965. High ground and open space influenced the choice and ground-breaking began in 1966. By 1970 most government offices and operations had already moved to the new location. <cityName>Kuala Lumpur</cityName> <adminUnit>Selangor</adminUnit> Malaysia 1448600    243     111     101.71     3.16     Kuala Lumpur is the capital of Malaysia and the largest city in the nation The city was founded in 1857 by Chinese tin miners and perseded Klang. In 1880 the British government transferred their headquarters from Klang to Kuala Lumpur, and in 1896 it became the capital of Malaysia. </tourGuide>

3) Click on the GREEN CHECK to Validate, and the BROWN CHECK to check for Well-Formedness. (NOTE: Be sure to eliminate any "white space" before the text that you paste, or you may have an error when validating.) (Also NOTE: You may need to select -Schema -Infer XML Schema -then choose city.xsd in order to validate the xml file.)

4)Click on: -File  -Save As   -city.xml 5) Right click on: -TourGuide -Add File -"city.xml" -open (Note: Now project "TourGuide" should contain three files, "city.xsd","city.xsl", and "city.xml".)

Part Five: Executing your code
1) Open the city.xml file.

2) Click on: -Transform  -Execute Simple XSLT   -Current Document   -OK

-XSL input -From URl -pick city.xsl -open -OK

-Use Default Processor -OK Note: the window should say "Transformation Complete"

Now you may close this window and follow step 3 to get the results.

3)Click on: -Tools  -Start Browser Note: Results should look like this:


text:
XML - Managing Data Exchange/XForms

What Is XForms?
Forms are an important part of many web applications today. An HTML form makes it possible for web applications to accept input from a user. Web users now do complex transactions that are starting to exceed the limitations of standard HTML forms. XForms is the next generation of HTML forms and is richer and more flexible than HTML forms. XForms uses XML for data definition and HTML or XHTML for data display. XForms separates the data logic of a form from its presentation. Separating data from presentation makes XForms device independent, because the data model can be used for all devices. The presentation can be customized for different user interfaces, like mobile phones and handheld devices and can provide interactivity between such devices. It is also possible to add XForms elements directly into other XML applications like VoiceXML (speaking web data), WML (Wireless Markup Language), and SVG (Scalable Vector Graphics).

The Purpose of XForms
XForms is the separation of purpose from presentation. For example, the purpose of a questionnaire application is to collect information about the user. This is done by creating a presentation that allows the user to provide the required information. Web applications typically render such a presentation as an interactive document that is continuously updated during user interaction. By separating the purpose from its presentation, XForms enables the binding of different interactions to a single model.

The Main Aspects of XForms
The XForms model defines what the form is, what data it contains, and what it should do. The XForms user interface defines the input fields and how they should be displayed. The XForms Submit Protocol defines how XForms send and receive data, including the ability to suspend and resume the completion of a form. XForms is "instance data", an internal representation of the data mapped to the familiar "form controls". Instance data is based on XML and defined in terms of XPath’s internal tree representation and processing of XML

The XForms Framework
With XForms, input data is described in two different parts:
 * 1) XForm model
 * 2) XForm user interface

The XForms Model
The XForm model defines what the form is, what data it contains, and what it should do.

The data model is an instance (a template) of an XML document. The XForms model defines a data model inside a element:

From the example above, you can see that the XForms model uses an element to define the XML template for data to be collected, and a element to describe how to submit the data.

The XForms model does not say anything about the visual part of the form (the user interface).

The Element
The data collected by XForms is expressed as XML instance data. XForms is always collecting data for an XML document. The element in the XForms model defines the XML document.

In the example above the "data instance" (the XML document) the form is collecting data for looks like this: After collecting the data, the XML document might look like this: Jim Jones

The Element
The XForms model uses a element to describe how to submit the data. The element defines a form and how it should be submitted. In the example above, the id="form1" attribute identifies the form, the action="submit.asp" attribute defines the URL to where the form should be submitted, and the method="get" attribute defines the method to use when submitting the data.

The following diagram shows how the XForm model has the capability to work with a variety of user interfaces.

The XForms User Interface
The XForms user interface is used to display and input the data. The user interface elements of XForms are called controls (or input controls): First Name Last Name Submit In the example above the two elements define two input fields. The ref="fname" and ref="lname" attributes point to the and elements in the XForms model. The element has a submission="form1" attribute which refers to the element in the XForms model. A submit element is usually displayed as a button. Notice the elements in the example. With XForms every input control element has a required element.

Putting Everything Together
XForms has to run inside another XML document. It could run inside XHTML 1.0, and it will run inside XHTML 2.0. If we put it all together, the document will look like this:  First Name Last Name Submit

The XForms Processor
An XForms Processor built into the browser will be responsible for submitting the XForms data to a target. The data can be submitted as XML and could look something like this:

Jim Jones

Or it can be submitted as text, looking something like this: fname=Jim;lname=Jones

The XForms Namespace
The official namespace for XForms is: http://www.w3.org/2002/xforms. If you want to use XForms in HTML (or XHTML 1.0), you should declare all XForms elements with an XForms namespace. XForms is expected to be a standard part of XHTML 2.0, eliminating the need for the XForms namespace.

An XForms Example
Take a look at this document using XForms:  First Name

Last Name

Submit

The Form Controls
The components of the form that deal with data entry and display are referred to as the form controls or user interface controls. XForms defines a comprehensive set of device-neutral, platform-independent form controls. For each element of data defined in the model, a form control defines its appearance via the client. These controls can be combined with stylesheets to provide sophisticated form displays.

XForms Action
In the course of form processing, often some particular action needs to happen.

XForms Methods
The XForms specification uses and builds upon XPath, which includes adding some method calls useful for forms: These can be called at any point where XPath is allowed. Additionally, implementations can support “extension functions” to provide additional functionality.

title: XML - Managing Data Exchange/XForms


text:
Microeconomics/Perfect Competition

Goals:
 * To explain how firms decide how much to produce
 * To explain how prices are determined

In order to achieve these goals, let's start with some definitions.

Profit
The assumption is that the goal of the firm is to maximize profit -- to make as much money as possible.

$$Profit = Revenue - Cost$$

$$Revenue = Price * Quantity$$

There are 2 types of profit:
 * 1) Accounting profit = Revenue - Explicit costs
 * 2) * explicit costs are actual payments for inputs
 * 3) * wages you pay employees, cost of machines, other physical inputs
 * 4) * firms report accounting profits
 * 5) Economic profit = Revenue - Explicit costs - Implicit costs
 * 6) * implicit costs are the opportunity costs of non-purchased inputs
 * 7) * extra money you could have earned, doing something else
 * 8) * what the owner of a business could have been earning, working for another company
 * 9) * return you could have earned by investing money in the stock market, instead of buying machines for your startup

Firm makes USD 100,000 in revenue. Firm spends USD 50,000 to produce the good. Owner used to make USD 40,000 at another job before opening this business.

 * Accounting profit = USD 100,000 - 50,000 = 50,000
 * Economic profit = USD 100,000 - 50,000 - 40,000 = 10,000
 * Relationship between accounting profit and economic profit
 * Accounting profit >= Economic profit

Economists (almost) always think and speak in terms of economic profit.

We also often refer to "zero profit". When we say, "zero economic profit" we mean that you are doing just as well with this business as with the next-best alternative.

If you are earning zero economic profit, you should stay in business.

The Short Run (SR) v. The Long Run (LR)

 * SR: Period of time during which you cannot change all inputs to production. At least one input is fixed.
 * Ex. The size of your factory is fixed in the short run.
 * LR: Period of time in which all inputs can be changed. All inputs can be varied in the long run.
 * Ex. You can expand your factory in the long run.

We can redefine the SR and the LR in terms of costs.

 * Fixed Cost (FC): Cost that does not change with the amount of output.
 * Ex. The cost of land, machines, factories, your lease, your property taxes.
 * No matter how much I produce, it costs me the same.
 * Variable Cost (VC): Cost that changes with the amount of production.
 * Ex. Amount spent on workers, electricity, etc.

If you increase your output, your VC increases.

 * In the SR, at least one input is fixed, so at least one input cost is fixed. Therefore in the SR, FC>0.
 * In the LR, there are no fixed inputs, therefore FC=0.
 * Total Cost (TC) = FC + VC

Hint: Make a separate sheet of paper in your notes where you define all the costs and write the relevant equations.

For now let us focus on the SR.

This section is mainly concerned with macroeconomics.

Production Function
The production function describes the relationship between all the inputs and the quantity of the output.

Ex. Suppose that you have a machine which originally cost USD 100. It has no resale value. You can hire workers at USD 20/hr each.

Inputs include labor (L) and the machine.

The machine is a fixed input, and the number of workers varies according to output/quantity.

The marginal product of labor (MPL) is the amount by which the output changes if you change the amount of the variable input (the number of workers).

From the example: In the beginning, as L is increased, Q increases by an increasing amount. But as workers are added, the increase in Q decreases. Notice L(2) -> L(3) results in increase of 8 for the corresponding Q, while L(3) -> L(4) results in increase of only 3.

Principle of diminishing returns
Suppose output is produced using 2 or more inputs and you increase one input while hold the other fixed. Beyond some point -- the point of diminishing returns -- output will increase at a decreasing rate.

Why is this? Because more and more workers are sharing a fixed quantity of other inputs. An example illustration is a cafe; for 2 to 3 employees, division of labor would be meaningful; one could take order, while the other could make the coffee at his table, and the 3rd employee could aid either one who is busier; but if the number of employee increases, say, to 10, while other things remain constant, there would not be enough table to even let the employees stand. Thus, at some point, additional employees do not add as much value as the ones before a certain number, which is called the point of diminishing return.

As such, this concept of diminishing returns explains why we can not grow all the world's crops on a single acre of land, just by adding enough fertilizer. Because at some point, the increase in output due to increase in input, the marginal increase, doesn't do as much.

The point of diminishing returns in the table above is at L=4. When you hire the 4th worker, he doesn't add as much to total output as did the previous worker.

Returning to the example, suppose you have a machine which costs $100. It has no resale value. You can hire workers at $20 each.

Consider the example. Is this firm in the short run or the long run? Answer: the short run, because of the presence of fixed cost of $100 for the machine.

Long run is still subject to law of diminishing returns, but in some corporation examples, this may be due to the limit in the number of consumers. Just like the limited land and fertilizer example, there is a limit to the number of supermarkets, hamburger chains, bakery chains, white goods stores, consumer electronic chain stores and hardware stores that can be opened before there is not enough customers to cover the variable costs and per outlet fixed costs.

How much of a fixed input(s) is responsible for every q produced, on average?

Graph AFC (Average Fixed Cost)

$$AFC = \frac{FC}{q}$$

On average, how much am I spending on the variable input(s)?

Graph AVC (Average Variable Cost):

$$AVC = \frac{VC}{q}$$

Graph ATC:

$$ATC = \frac{TC}{q} = AFC + AVC$$

If I increase or decrease my output slightly, how do my costs change?

MC looks like:

$$MC = \frac{TC_2 - TC_1}{q_2 - q_1}$$

Marginal costs begin to increase when you add the 4th worker (point of diminishing returns)

Why? Beyond this point, each worker is relatively less productive, but you are paying each worker the same wage.

Graph the relationship between MC and MPL:

MC intersects AVC and ATC at their respective minimum points.

Why? Think of ATC as your GPA. Think of MC as your grade in this class.

 * If your grade in this class is less than your GPA then your GPA will fall a little.
 * If your grade in this class is greater than your GPA then your GPA will rise a little.
 * If your grade in this class is equal to your GPA then your GPA will not change.

Similarly, when the cost of producing an additional good is less than the average cost, the average cost will fall a little.

When the cost of producing an additional good is greater than the average cost, the average cost will rise a little.

The AFC of producing 5 widgets is:

The AVC of producing 4 widgets is:

Example: You observe that at your current production of daikon radishes, the ATC is $1 and the MC is $2. What will happen if you increase production of daikon radishes by 1?

 * 1) MC will remain constant
 * 2) MC will decline
 * 3) ATC will rise
 * 4) ATC will decline
 * 5) Not enough information to say

Firm Production Decision
Q: How much should a firm produce in order to maximize profits?

Goal of any firm is to choose the quantity $$q$$. b

Profit Maximization Rule
Profit is maximized where $$MR = MC$$.

Profit maximization rule: Produce until the point where the change in revenue from producing 1 more unit equals the change in cost from producing 1 more unit.

Why?

Suppose MR > MC. If I produce 1 more unit, my revenues increase by more than my costs. Therefore, if MR > MC, producing more will increase my profit. If I can increase my profit by changing how much I produce, then when producing where MR > MC can't be profit-maximizing.

Suppose MR < MC. If I produce 1 less unit, my revenues decrease by less than my costs decrease. Therefore, if MR < MC, I can increase profit by decreasing output. If I can increase profit when MR < MC, then choosing q such that MR < MC can not be profit-maximizing.

So, in order to maximize profit, I must choose a quantity q such that MR = MC.

MR = MC is an equilibrium in the sense that it is the only place where there is no incentive to change the production level.

This rule, the profit maximization rule, is just an application of the marginal principle (MB = MC).

Why? This MB of producing an extra unit is the extra revenue you get. MR is the MB. So the 2 statements are equivalent. The marginal principle is more general, and the profit maximization rule is specific to the firm production decision.

Perfect Competition
Now let us apply the profit maximization rule to the specific case of perfect competition. First, list the characteristics of a perfectly competitive firm.

Characteristics
 * 1) Homogeneous: every firm produces exactly the same good.  Consumers can't tell any difference between what one firm produces and what another firm produces.
 * 2) Many firms: each firm represents a very small part of the overall industry.
 * 3) Price taker: any individual firms's decision of how much to produce will not affect the market price.  This is a result of the first 2 characteristics.
 * 4) Free entry and free exit: There exist no barriers to prevent firms from entering or exiting a certain market in the long run.  This implies zero economic profits in the long run.

Very few firms or markets would satisfy these characteristics. Closest example of a perfectly competitive market is agriculture
 * 1) a particular variety of wheat is the same no matter where it is grown
 * 2) there are many small farmers, so that whether or not Farmer Bob produces an extra 5 units does not affect the market price

Despite the rare and extreme nature of perfect competition, it provides a useful baseline case.

Graph the typical representative perf. comp. firm next to the industry to which it belongs. Show how price is determined in the market and then guides the individual firm's decision.

Profit-maximization rule: Choose q such that MR=MC.

q* = that amount which a perfectly competitive firm will produce given P* in the market.

Revenue = Pq*

Profit Maximization in Perfect Competition
From the assumption of perfect competition, any individual firm's decision of how much to produce does not affect the market price. Therefore, P = MR for an individual firm ,( because it is known that price is constant for any quantity produced, and marginal revenue is the price of producing one further unit of quantity, and price is constant ; price is constant because price does not increase at any quantity demanded because most other companies will still sell at the same price and no one can compete at a higher price).

Remember that profit maximization rule says to set q such that MR = MC ( because of the law of diminishing returns, when MC is rising and has reached MR, MC will be greater than MR for any more units, or the marginal profit which is MR - MC will be less than zero ).

Since P = MR and the firm sets MR = MC, we can write that in perfect competition,

Set q* such that P = MC ( because for every unit before the qth unit, there was a net profit of P-MC > 0 for each unit, because MC was rising and has to be less than the MC at MC = P ).

On the graph, find the point where the price line intersect the marginal cost curve. Then look at the horizontal axis to determine which q corresponds to that point. This is the firm's profit maximizing quantity.

Cost and Price Minimization in Perfect Competition
There is also an equalitarian, non-corrupt side of perfectly competing market that suggests transparent market competition is good for the consumer: as each company seeks to to produce the last unit where the marginal cost is just less than the price, and therefore have produced as many profitable units as possible, so they will try to sell at a price that is the lowest and still profitable, which is above the average total cost, and they will try to price at a quantity above the minimum average total unit cost. If they sell below the ATC, they can cover variable but not fixed cost, and so they try to reduce costs. If they sell above the minimum ATC, their competitor will sell more and they will try to increase efficiency to match the minimal ATC. So this brings up the Utopian vision that in a perfectly competing market, the fair price is that buyers get the same price as the minimum unit cost which covers all the cost of production including the fair minimum costs for labour and management, and no more. And producers sell at a maximum quantity where their last units of production still turn a profit. The lowest prices and as much as possible while letting the adequately efficient producer survive. P = MC = minATC. Economic heaven!

Case 1: Positive Profits
Profit > 0

Revenue > Total Cost

Intuitive example: On average, it costs $5 to make each unit. Can sell each unit for $7. Must be making a profit.

ATC(q*) = how much it costs you on average to produce each unit, given that you are producing q* units.

Revenue = p q* = A + B

TC = B

Profit = Revenue - TC = A

Note: it is a common mistake to identify q* as the q where MC = minimum ATC. This is wrong! This quantity does not generally maximize profit. It maximizes profit per unit.

However, in the LR, because of free entry and exit, profit will equal zero, and ATC will be minimized. This is a feature of perfect competition. But the firm is not trying to minimize ATC -- it tries to maximize (TR - TC). ATC is only minimized indirectly in the long run.

Should a firm stop producing (shut down) if profits are negative? (Recall this is in the SR.) Answer: It depends.

This an old joke about economists. They can never give a Yes or No answer to a question. They always say, "It depends." That isn't really true in general, but in this case, "It depends," is the correct answer.

Note: stopping production does not mean going out of business.

Ex. Tourist businesses might shut down in the off-season.

Why? Whether or not you are producing anything, in the SR, you still have to pay your FC.

You should stop producing only if you are losing more money by producing than by shutting down.

We need a rule. Let's derive it.

 * Loss > FC
 * TC - Revenue > FC
 * FC + VC - Revenue > FC
 * VC - Revenue > 0

"VC > Revenue

That is, shut down if you can't afford to pay your workers. If you continue producing, your profit will be negative. But if you shut down, you limit your losses to the amount of FC you have to pay. If VC > Revenue, you'd lose even more than FC by staying open. In general, if you are losing money, you have to decide whether shutting down or staying open will minimize your losses.

Case 2: Negative Profits: Stay Open
You lose money because P < ATC

But since P > AVC,

P > AVC

P*q > AVC*q

Revenue > VC

So you are able to cover the cost of your labor inputs, and pay some of your fixed cost as well, by staying open.

Revenue = B + C

TC = A + B + C

Negative profit = A

VC = C

FC = A + B

If you keep producing, lose A

If you stop producing, lose A + B

Example: P* = 8. Calculate loss, fixed cost, and explain why the firm should keep producing. This is the mini we had in class. Your answer can be showing the amount of VC, FC, and calculating profits for the case of staying open and for shutting down.

For fixed costs such as capital, it then depends on the after-tax cost of capital resource over the life of the capital resource, because if say the resource has a life of 10 years, and it takes 8 years to cover the replacement cost after tax deductions for depreciation, then it is still profitable to stay open for 10 years.

If there is a recurring fixed cost, then if the fixed cost minus tax deduction exceeds the revenue less variable cost, then money is being slowly lost over the long term.

Case 3: Negative Profits: Stop Production
Negative profits:

Stop production if:

VC > Revenue

q * AVC > P * q

AVC > P

Shut down if P < AVC on the graph.

Graph the perf. comp. firms costs, with P below the AVC curve.

Revenue = C

TC = A + B + C

Negative profit = A + B

VC = B + C

FC = TC - VC = A

If you keep producing, you lose A + B

If you shut down, you lose A

So you lose less money by shutting down.

Derivation of the Firm's Supply Curve
We have shown that a firm will keep producing as long as P >= AVC.

Suppose P < AVC. Then q* = 0

 * If P = AVC then q > 0
 * If P > AVC then q > 0

So for all P >= AVC, there exists a certain q that a firm will supply. The firm supply curve is the MC at or greater than AVC.

By the Law of Supply, as P increases, Qs increases.

Why? Firms produce more. Firms that have stopped producing, but haven't gone out of business, may start producing again.

The elasticity of supply depends on the MC curve.

 * An elastic S curve means that a firm can increase its Qs without a very large increase in MC.
 * An inelastic S curve means that MC increases sharply for an increase in the Qs.

Market Supply: Add up all the firms' S at every P.

title: Microeconomics/Perfect Competition


text:
Talk:Raising Cattle

It would be good if this book would also address miniature cattle, for people who have an interest in raising cattle but have space/land concerns. Some residential zoning laws can accommodate miniature cattle if they are below certain height/weight thresholds. —Preceding unsigned comment added by 67.100.216.14 (discuss • contribs) 02:16, 15 November 2005

title: Talk:Raising Cattle


text:
User talk:193.226.126.134

You have been temporarily blocked from editing Wikibooks. You were warned several times that linking to commercial sites is not allowed. If you wish to make useful contributions, you are welcome to come back after the block expires.

title: User talk:193.226.126.134


text:
User talk:63.219.0.14

Please stop adding nonsense to Wikibooks. It is considered vandalism. If you would like to experiment, use the sandbox. Thank you.

title: User talk:63.219.0.14


text:
User talk:83.29.72.207

Svaraltur
Sorry, but we do not accept original research. Your book is becoming candidate for speedy deletion. Check link I provided you: there's a link to Wikicity hosting such projects. Regards --Derbeth 10:52, 15 November 2005 (UTC)

title: User talk:83.29.72.207


text: User talk:57.250.231.247

title: User talk:57.250.231.247


text:
Wikibooks:Maintenance

Maintenance work is vital to keeping Wikibooks running optimally. You can help with most of these tasks to make Wikibooks a better project!

Structural
For these tasks, see CCO Resources.
 * Pages, Categories, Templates, and Files that need to be organized. Only Category:Categories should be left uncategorized.
 * Books to be Alphabetized.
 * Pages missing a reference section Pages with inline references but no or.
 * Category:Book:Wikibooks Stacks/Attention needed Pages that have detected problems interfering with the hierarchical shelving of pages in the Wikibooks Stacks.
 * Naming convention

Transwikis

 * Pages to be transwikied to another wiki.
 * Requests for import to Wikibooks. Only admins and importers can do the actual import, but all Wikibookians are welcome to comment on requests.
 * Transwikis needing a home may be useful to merge into an appropriate book.
 * Pages needing to be dewikified – When appropriate these pages may be dewikified. Pages that do not meet our inclusion requirements may be marked for deletion.

Files

 * Unused files – Look for duplicates, nonsense, and copyright violations, and tag them accordingly.
 * Files now at Commons & Files now at Commons (different name) – Files now available on Commons that can be deleted from Wikibooks.
 * Files with unknown copyright status – These will be deleted after a week if the author does not provide proper license information.
 * Files with no non-free use rationale – These will be deleted after a week if the uploader does not provide a full non-free use rationale.
 * Files lacking an author – These files need information on who created them in the first place.
 * Files with unknown source – These files need information as to where they came from.

Content and Contributions

 * Accuracy and NPOV disputes
 * Books to be merged and History merge requests
 * Broken and Double redirects
 * Copyright violations – Check whether permission was granted by the copyright owner for works.
 * Correct typos in one click
 * New pages – Add category templates to pages, to pages that might be in a transition stage to becoming real books, and add  to very short pages that meet the speedy deletion criteria.
 * Pages needing attention like fixing wikicode, spelling, layout, etc.
 * Pending changes – Accept or reject edits to previously reviewed pages.
 * Requests for deletion – Discussions about books that don't meet the speedy deletion criteria.
 * Requests for edits to protected pages.
 * Requests for expansion of books, pages, and sections.
 * Requested books – Check for existing books, remove some of those already created.
 * Speedy deletions – Read the Deletion policy first.
 * Stubs, Orphans, Queries, and Short pages are often missing categories, links, explanations, and other elements books and pages are expected to include. They may be speedy deleted when abandoned and improves are unlikely.
 * Recent changes by [ new] and [ anonymous] contributors. Verify edits. Welcome new and anonymous contributors who have made good contributions. See Templates/User messages
 * Requests for unblock – Requests by users to be unblocked.

fr:Wikilivres:Maintenance nl:Wikibooks:Onderhoud pt:Wikilivros:Manutenção

title: Wikibooks:Maintenance


text:
XML - Managing Data Exchange/XML and JDBC

Overview
ODBC is the acronym for the oft used API Open Database Connectivity. Many applications and application programmers use ODBC in order to access relational databases, such as SQL and Microsoft Access, and to manipulate the data within the databases. Specifically, JDBC (Java Database Connectivity), which is based on ODBC, is the API used by applications developed in Java to perform these various tasks. Moreover, JDBC is now capable of handling advanced datatypes in SQL which in turn becomes useful when dealing with XML. Also, JDBC has within it the ability to actually create XML data. Furthermore, the use of JAXP (Java API for XML Processing) along with JDBC provides yet another way of manipulating and using relational databases and XML. In any event, there are multiple ways to use the JDBC API with XML.

JDBC and XML Documents
Many Java Applications written today will more than likely interact with an SQL database (or a relational database, but for the sake of uniformity, we will work with SQL.) Depending on the intent of the application, there may be the case of actually storing an XML document for display or for manipulation. Whatever the case, JDBC now supports all datatypes defined in the SQL:1999 specification. One of theses datatypes is the CLOB (character large object) datatype. This datatype is perfect for storing XML documents. This is one way XML and the JDBC API works with each other.

JDBC and XML Production
One of the more interesting things about JDBC is that it can be used to gather MetaData. Meta-data is nothing more than data about data. From an XML standpoint, this is very useful because we can create XML data on the fly with nothing more than a table name. The class that makes this possible is java.sql.ResultSetMetaData. Consequently this class is a part of the JDBC API.

JDBC and JAXP
Another intriguing way of dealing with XML objects is within the JAXP (Java API for XML Processing). JAXP and JDBC together provide an infrastructure for developing applications using XML and SQL.

Whenever XML instances in applications are dealt with, an XML parser is a good tool to use. The XML parser turns the XML document into an object or something the application can uses. Specifically, Document Object Model (DOM) takes and XML instance and converts it into a tree. This specific parser can be found in the JAXP API. You may then store the parsed object in an SQL database for future use. This may open up many ideas of how one may use JAXP and JDBC together when an issue presents itself of dealing with XML and SQL.


text:
Talk:Puzzles/Logic puzzles/Two Boys and a River

How about : First boy rows over, has alook about, then rows back. The second boy then takes the boat and rows over for a look, then rows back. Both boys have then been across, but not necessarily at the same time!