While planning a trip to Mexico, Nadia reads "Oaxaca weather information: 'http://weather.example.com/oaxaca'" in a glossy travel magazine. Nadia has enough experience with the Web to recognize that "http://weather.example.com/oaxaca" is a URI. Given the context in which the URI appears, she expects that it allows her to access weather information[skw5] . When Nadia enters the URI into her browser:

1.      The browser performs an information retrieval action in accordance with its configured behavior for resources identified via the "http" URI scheme.

2.      The authority responsible for "weather.example.com" provides information in a response to the retrieval request.

3.      The browser displays the retrieved information, which includes hypertext links to other information. Nadia can follow these hypertext links to retrieve additional information.

1.1.1. Audience of this Document

This document is intended to inform discussions about issues of Web architecture. The intended audience for this document includes:

1.      Participants in W3C Activities

2.      Other groups and individuals designing technologies to be integrated into the Web

3.      Implementers of W3C specifications

4.      Web content authors and publishers

Readers will benefit from familiarity with the Requests for Comments ( RFC ) series from the IETF , some of which define pieces of the architecture discussed in this document.

Note: This document does not distinguish in any formal way the terms "language" and "format." Context determines which term is used. The phrase "specification designer" encompasses language, format, and protocol designers.

1.1.2. Scope of this Document

This document presents the general architecture of the Web. Other groups inside and outside W3C also address specialized aspects of Web architecture, including accessibility, internationalization, device independence, and Web Services. The section on Architectural Specifications includes references.

This document strikes a balance between brevity and precision [skw9] while including illustrative examples. TAG findings are informational documents that complement the current document by providing more detail about selected topics. This document includes some excerpts from the findings. Since the findings evolve independently, this document also includes references to approved TAG findings. For other TAG issues covered by this document but without an approved finding, references are to entries in the TAG issues list .

Many of the examples in this document that involve human activity suppose the familiar Web interaction model where a person follows a link via a user agent, the user agent retrieves and presents data, the user follows another link, etc. This document does not discuss in any detail other interaction models such as voice browsing (see, for example, [ VOICEXML2 ]). For instance, when a graphical user agent running on a laptop computer or hand-held device encounters an error, the user agent can report errors directly to the user through visual and audio cues, and present the user with options for resolving the errors. On the other hand, when someone is browsing the Web through voice input and audio-only output, stopping the dialog to wait for user input may reduce usability since it is so easy to "lose one's place" when browsing with only audio-output. This document does not discuss how the principles, constraints, and good practices identified here apply in all interaction contexts.

1.1.3. Principles, Constraints, and Good Practice Notes

The important points of this document are categorized as follows:

Principle

An architectural principle is a fundamental rule that applies to a large number of situations and variables. Architectural principles include "separation of concerns", "generic interface", "self-descriptive syntax," "visible semantics," "network effect" (Metcalfe's Law), and Amdahl's Law: "The speed of a system is limited by its slowest component."

Constraint

In the design of the Web, some design choices, like the names of the p and li elements in HTML, or the choice of the colon (:) character in URIs, are somewhat arbitrary; if paragraph had been chosen instead of p or asterisk (*) instead of colon, the large-scale result would, most likely, have been the same. Other design choices are more fundamental; these are the focus of this document. Design choices can lead to constraints, i.e., restrictions in behavior or interaction within the system. Constraints may be imposed for technical, policy, or other reasons to achieve certain properties of the system, such as accessibility and global scope, and non-functional properties, such as relative ease of evolution, re-usability of components, efficiency, and dynamic extensibility.

Good practice

Good practice — by software developers, content authors, site managers, users, and specification designers — increases the value of the Web.

1.2.1. Orthogonal Specifications

Identification, interaction, and representation are orthogonal concepts, meaning that technologies used for identification, interaction, and representation may evolve independently. For instance:

·         One identifies [skw10] a resource with a URI. One may assign and then use a URI without building any representations of the resource or determining whether any representations are available.

·         A generic URI syntax allows agents to function in many cases without knowing specifics of URI schemes.

·         In many cases one may change the representation of a resource without disrupting references to the resource[skw11] .

When two specifications are orthogonal, one may change one without requiring changes to the other, even if one has dependencies on the other. For example, although the HTTP specification depends on the URI specification, the two may evolve independently. This orthogonality increases the flexibility and robustness of the Web. For example, one may refer by URI to an image without knowing anything about the format chosen to represent the image. This has facilitated the introduction of image formats such as PNG and SVG without disrupting existing references to image resources.

Orthogonal abstractions benefit from orthogonal specifications. Specifications should clearly indicate those features that simultaneously access information from otherwise orthogonal abstractions. For example a specification should draw attention to a feature that requires information from both the header and the body of a message.[skw12] 

Although the HTTP, HTML, and URI specifications are orthogonal for the most part, they are not entirely so. Experience demonstrates that where they are not, problems have arisen:

·         The HTML specification — a data format specification — includes a protocol extension of sorts: it specifies how a user agent sends HTML form data to a server (as a URI query string). The design works reasonably well, although there are limitations related to internationalization (see the TAG finding " URIs, Addressability, and the use of HTTP GET and POST " ) and the query string design impinges on the server design. Software developers (for example, of [ CGI ] applications) might have an easier time finding the specification if it were published separately and then cited from the HTTP, URI, and HTML specifications.

·         The HTML specification allows content providers to instruct HTTP servers to build response headers from META element instances. This is an abstraction violation; the software developer community would benefit from being able to find all HTTP headers from the HTTP specification (including any associated extension registries and specification updates per IETF process). Perhaps as a result, this feature of the HTML specification is not widely deployed. Furthermore, this design has led to confusion in user agent development. The HTML specification states that META in conjunction with http-equiv is intended for HTTP servers, but many HTML user agents interpret http-equiv='refresh' as a client-side instruction.

·         Some content authors use the META / http-equiv approach to declare the character encoding scheme of an HTML document. By design, this is a hint that an HTTP server should emit a corresponding "Content-Type" header field. In practice, the use of the hint in servers is not widely deployed. Furthermore, many user agents use this information to override the "Content-Type" header sent by the server, violating protocol semantics.

1.2.2. Extensibility

The information in the Web and the technologies used to represent that information change over time. Extensibility describes the property of a technology that promotes both evolution and interoperability. Some examples of successful technologies designed to allow change while minimizing disruption include:

·         the fact that URI schemes are orthogonally specified;

·         the use of an open set of Internet media types in mail and HTTP to specify document interpretation;

·         the separation of the generic XML grammar and the open set of XML namespaces for element and attribute names;

·         extensibility models in Cascading Style Sheets (CSS), XSLT 1.0, and SOAP;

·         user agent plug-ins.

An example of an unsuccessful extension mechanism is HTTP mandatory extensions[skw13] . The community has sought mechanisms to extend HTTP, but apparently the costs of the mandatory extension proposal (notably in complexity) outweighed the benefits and thus hampered adoption.

Below we discuss the property of "extensibility," exhibited by URIs, some data formats, and some protocols (through the incorporation of new messages).

Subset language : one language is a subset (or, "profile") of a second language if any document in the first language is also a valid document in the second language and has the same interpretation in the second language.

Extended language : If one language is a subset of another, the latter superset is called an extended language; the difference between the languages is called the extension. Clearly, extending a language is better for interoperability than creating an incompatible language.[skw14] 

Ideally, many instances of a superset language can be safely and usefully processed as though they were in the language subset. Languages that exhibit this property are said to be "extensible." Language designers can facilitate extensibility by defining how implementations must handle unknown extensions — for example, that they be ignored (in some way) or should be considered errors.

For example, from early on in the Web, HTML agents followed the convention of ignoring unknown elements. This choice left room for innovation (i.e., non-standard elements) and encouraged the deployment of HTML. However, interoperability problems arose as well. In this type of environment, there is an inevitable tension between interoperability in the short term and the desire for extensibility. Experience shows that designs that strike the right balance between allowing change and preserving interoperability are more likely to thrive and are less likely to disrupt the Web community. Orthogonal specifications help reduce the risk of disruption.

For further discussion, see the section on versioning and extensibility . See also TAG issue xmlProfiles-29 .

1.2.3. Error Handling

Errors occur in networked information systems. An error condition can be well-specified (e.g., well-formedness errors in XML or 4xx client errors in HTTP) or arise unpredictably. Error correction means that an agent repairs an condition so that within the system, it is as though the error never occurred. One example of error correction involves data retransmission in response to a temporary hardware failure. Error recovery means that an agent does not repair an error condition but continues processing.[skw15] 

Agents frequently correct errors without user awareness, sparing users the details of complex network communications. On the other hand, it is important that agents recover from error in a way that is transparent [skw16] to users, since the agents are acting on their behalf.

An agent is not required to interrupt the user (e.g., by popping up a confirmation box) to obtain consent. The user may indicate consent through pre-selected configuration options, modes, or selectable user interface toggles, with appropriate reporting to the user when the agent detects an error. Agent developers should not ignore usability issues when designing error recovery behavior.

To promote interoperability, specification designers should identify [skw17] predictable error conditions. Experience has led to the following observations about error-handling approaches.

·         Protocol designers should provide enough information about an error condition so that an agent can address the error condition. For instance, an HTTP 404 message [skw18] (not found) is useful because it allows user agents to present relevant information to users, enabling them to contact the representation provider in case of problems.

·         Experience with the cost of building a user agent to handle the diverse forms of ill-formed HTML content convinced the designers of the XML specification to require that agents fail upon encountering ill-formed content. Because users are unlikely to tolerate such failures, this design choice has pressured all parties into respecting XML's constraints, to the benefit of all.

·         An agent that encounters unrecognized content may handle it in a number of ways, including by considering it an error; see also the section on extensibility and versioning .

·         Error behavior that is appropriate for a person may not be appropriate for software. People are capable of exercising judgement in ways that software applications generally cannot. An informal error response may suffice for a person but not for a processor.

See the TAG issues contentTypeOverride-24 and errorHandling-20 .

1.2.4. Protocol-based Interoperability

The Web follows Internet tradition in that its important interfaces are defined in terms of protocols, by specifying the syntax, semantics, and sequence [skw19] of the messages interchanged. Protocols designed to be resilient in the face of widely varying environments have helped the Web scale and have facilitated communication across multiple trust boundaries. Traditional application programming interfaces ( APIs ) do not always take these constraints into account, nor should they be required to. One effect of protocol-based design is that the technology shared among agents often lasts longer than the agents themselves[skw20] .

It is common for programmers working with the Web to write code that generates and parses these messages directly. It is less common, but not unusual, for end users to have direct exposure to these messages. It is often desirable to provide users with access to format and protocol details: allowing them to " view source ," whereby they may gain expertise in the workings of the underlying system.

Good practice: Identify with URIs

To benefit from and increase the value of the World Wide Web, agents should provide URIs as identifiers for resources.[skw26] 

2.3.1. URI aliases

Although there are benefits (such as naming flexibility) to URI aliases, there are also costs. For example, the assignment association of more than one URI for with a resource undermines the network effect. URI aliases can also raise the cost or may even make it impossible for software to determine by following specifications that the URIs identify the same resource. URI producers should thus be conservative about the number of different URIs they produce associate with for the same resource.

URI consumers also have a role in ensuring URI consistency. For instance, when transcribing a URI, agents should not gratuitously percent-encode characters. The term "character" refers to URI characters as defined in section 2 of [ URI ]; percent-encoding is discussed in section 2.1 of that specification.[skw33] 

When a URI alias does become common currency, the URI owner should use protocol techniques such as server-side redirects to connect associate the two resources. The community benefits when the URI owner supports both the "official" URI and the alias.

Good practice: Avoiding URI Overloading

Agents SHOULD find out what resource a URI identifies before using that URI.[skw36] 

2.4.1. Indirect Identification

Listening to a news broadcast, one might hear a report on Britain that begins, "Today, 10 Downing Street announced a series of new economic measures." Generally, "10 Downing Street" identifies the official residence of Britain's Prime Minister. In this context, the news reporter is using it (as English rhetoric allows) to indirectly identify the British government. Similarly, URIs identify resources, but they can also be used in many constructs to indirectly identify arbitrary entities. Certain properties [skw37] of URIs make them appealing as general-purpose identifiers. Local policy establishes what they indirectly identify.[skw38] 

For example, the URI "mailto:nadia@example.com" identifies an Internet mailbox (as licensed specified by the "mailto" URI scheme). Suppose this particular URI identifies Nadia's Internet mailbox. The organizers of a conference attended by Nadia might use "mailto:nadia@example.com" to refer indirectly to her (e.g., using the URI as a database key in their database of conference participants).

Good practice: New URI schemes

A specification SHOULD NOT introduce a new URI scheme when an existing scheme provides the desired properties of identifiers and their relation to resources.[skw46] 

2.6.1. URI Scheme Registration

The Internet Assigned Numbers Authority ( IANA ) maintains a registry [ IANASchemes ] of mappings between URI scheme names and scheme specifications. For instance, the IANA registry indicates that the "http" scheme is defined in [ RFC2616 ]. The process for registering a new URI scheme is defined in [ RFC2717 ].

The use of unregistered URI schemes is discouraged for a number of reasons:

·         There is no generally accepted way to locate the scheme specification.

·         Someone else may be using the scheme for other purposes.

·         One should not expect that general-purpose software will do anything useful with URIs of this scheme beyond URI comparison; the network effect is lost.

Note: Some URI scheme specifications (such as the "ftp" URI scheme specification) use the term "designate" where the current document uses "identify."

TAG issue siteData-36 is about expropriation of naming authority.[skw47] 

Good practice: URI opacity

Agents making use of URIs MUST NOT attempt to infer properties of the referenced resource except as licensed allowed by relevant specifications.

Story

2.9.1. Internationalized Identifiers

The integration of internationalized identifiers (i.e., composed of characters beyond those allowed by [ URI ]) into the Web architecture is an important and open issue. See TAG issue IRIEverywhere-27 for discussion about work going on in this area.

2.9.2. Assertion that Two URIs Identify the Same Resource

Emerging Semantic Web technologies, including the "Web Ontology Language (OWL)" [ OWL10 ], define RDF properties such as sameAs to assert that two URIs identify[skw49]  the same resource or functionalProperty to imply it.

Nadia follows a hypertext link labeled "satellite image" expecting to retrieve a satellite photo of the Oaxaca region. The link to the satellite image is an XHTML link encoded as <a href="http://example.com/satimage/oaxaca">satellite image</a> . Nadia's browser analyzes the URI and determines that its scheme is "http". The browser configuration determines how it locates the identified information, which might be via a cache of prior retrieval actions, by contacting an intermediary (such as a proxy server), or by direct access to the server identified by a portion of the URI. In this example, the browser opens a network connection to port 80 on the server at "example.com" and sends a "GET" message as specified by the HTTP protocol, requesting a representation of the resource.

The server sends a response message to the browser, once again according to the HTTP protocol. The message consists of several headers and a JPEG image. The browser reads the headers, learns from the "Content-Type" field that the Internet media type of the representation is "image/jpeg", reads the sequence of octets that make up the representation data, and renders the image.

3.2.1. Details of Retrieving a Representation

Dereferencing a URI generally involves a succession of steps as described in multiple specifications and implemented by the agent. The following example illustrates the series of specifications that are involved when a user instructs a user agent to follow a hypertext link that is part of an SVG document. In this example, the URI is "http://weather.example.com/oaxaca" and the application context calls for the user agent to retrieve and render a representation of the identified resource.

1.      Since the URI is part of a hypertext link in an SVG document, the first relevant specification is the SVG 1.1 Recommendation [ SVG11 ]. Section 17.1 of this specification imports the link semantics defined in XLink 1.0 [ XLink10 ]: "The remote resource (the destination for the link) is defined by a URI specified by the XLink href attribute on the ' a ' element." The SVG specification goes on to state that interpretation of an a element involves retrieving a representation of a resource, identified by the href attribute in the XLink namespace: "By activating these links (by clicking with the mouse, through keyboard input, voice commands, etc.), users may visit these resources."

2.      The XLink 1.0 [ XLink10 ] specification, which defines the href attribute in section 5.4, states that "The value of the href attribute must be a URI reference as defined in [IETF RFC 2396], or must result in a URI reference after the escaping procedure described below is applied."

3.      The URI specification [ URI ] states that "Each URI begins with a scheme name that refers to a specification for assigning identifiers within that scheme." The URI scheme name in this example is "http".

4.      [ IANASchemes ] states that the "http" scheme is defined by the HTTP/1.1 specification (RFC 2616 [ RFC2616 ], section 3.2.2).

5.      In this SVG context, the agent constructs an HTTP GET request (per section 9.3 of [ RFC2616 ]) to retrieve the representation.

6.      Section 6 of [ RFC2616 ] defines how the server constructs a corresponding response message, including the 'Content-Type' field.

7.      Section 1.4 of [ RFC2616 ] states "HTTP communication usually takes place over TCP/IP connections." This example does not address that step in the process, or other steps such as Domain Name System ( DNS ) resolution.

8.      The agent interprets the returned representation according to the data format specification that corresponds to the representation's Internet Media Type (the value of the HTTP 'Content-Type') in the relevant IANA registry [ MEDIATYPEREG ].

Precisely which representation(s) are retrieved depends on a number of factors, including:

1.      Whether the URI owner makes available any representations at all;

2.      Whether the agent making the request has access privileges for those representations (see the section on linking and access control );

3.      If the URI owner has provided more than one representation (in different formats such as HTML, PNG, or RDF; in different languages such as English and Spanish; or transformed dynamically according to the hardware or software capabilities of the recipient), the resulting representation may depend on negotiation between the user agent and server.

4.      The time of the request; information changes over time, and so representations of that information are also likely to change.

Note also that the choice and expressive power of a format can affect how precisely a representation provider communicates resource state. The use of natural language to communicate information may lead to ambiguity about what the associated resource is, which in turn can lead to URI overloading .

3.3.1. Media Types and Fragment Identifier Semantics

Per [ URI ], given a URI "U#F", and a representation retrieved by dereferencing URI "U" (which is authoritative), the ( secondary ) resource identified by "U#F" is determined by interpreting "F" according to the specification associated with the Internet media type of the representation data. Thus, in the case of Dirk and Nadia, the authoritative interpretation of the fragment identifier is given by the SVG specification, not the XHTML specification (i.e., the context where the URI appears).

The semantics of a fragment identifier are defined by the set of representations that might result from a retrieval action on the primary resource. The fragment's format and resolution is therefore dependent on the media type [ RFC2046 ] of a potentially retrieved representation, even though such a retrieval is only performed if the URI is dereferenced. If no such representation exists, then the semantics of the fragment are considered unknown and, effectively, unconstrained. Fragment identifier semantics are orthogonal to URI schemes and thus cannot be redefined by URI scheme specifications.

Interpretation of the fragment identifier is performed solely by the agent; the fragment identifier is not passed to other systems during the process of retrieval. This means that some intermediaries in the Web architecture (such as proxies) have no interaction with fragment identifiers and that redirection (in HTTP [ RFC2616 ], for example) does not account for them.

As with any URI, use of a fragment identifier component does not imply that a retrieval action will take place. A URI with a fragment identifier may be used to refer to the secondary resource without any implication that the primary resource is accessible or will ever be accessed. One may compare URIs with fragment identifiers without a retrieval action. Parties that draw conclusions about the interpretation of a fragment identifier based solely on a syntactic analysis of all or part of a URI do so at their own risk; such interpretations are not authoritative because they are not licensed by specification (specifically [ URI ]).

Please note the following about primary and secondary resources:

1.      A resource may be both a primary and secondary resource since more than one URI may identify the resource.

2.      One cannot carry out an HTTP POST operation using a URI that identifies a secondary resource.

3.3.2. Fragment Identifiers and Content Negotiation

Content negotiation refers to the practice of making available multiple representations via the same URI. Negotiation between the requesting agent and the server determines which representation is served (usually with the goal of serving the "best" representation a receiving agent can process). HTTP is an example of a protocol that enables representation providers to use content negotiation.

Individual data formats may define their own restrictions on, or structure within, the fragment identifier syntax for specifying different types of subsets, views, or external references that are identifiable as secondary resources by that media type. Therefore, representation providers must manage content negotiation carefully when used with a URI that contains a fragment identifier. Consider an example where the owner of the URI "http://weather.example.com/oaxaca/map#zicatela" uses content negotiation to serve two representations of the identified resource. Three situations can arise:

1.      The interpretation of "zicatela" is defined consistently by both data format specifications. The representation provider decides when definitions of fragment identifier semantics are are sufficiently consistent.

2.      The interpretation of "zicatela" is defined inconsistently by the data format specifications.

3.      The interpretation of "zicatela" is defined in one data format specification but not the other.

The first situation — consistent semantics — poses no problem.

The second case is a server management error: representation providers must not use content negotiation to serve representation formats that have inconsistent fragment identifier semantics. This situation also leads to URI overloading .

The third case is not a server management error. It is a means by which the Web can grow. Because the Web is a distributed system in which formats and agents are deployed in a non-uniform manner, Web architecture does not constrain authors to only use "lowest common denominator" formats. Content authors may take advantage of new data formats while still ensuring reasonable backward-compatibility for agents that do not yet implement them.

In case three, behavior by the receiving agent should vary depending on whether the negotiated format defines fragment identifier semantics. When a received data format does not define fragment identifier semantics, the agent should not perform silent error recovery unless the user has given consent; see [ CUAP ] for additional suggested agent behavior in this case.

See related TAG issue RDFinXHTML-35 .

Principle: Data-metadata inconsistency

Agents MUST NOT ignore message metadata without the consent of the user.

Story

Principle: Safe retrieval

Agents do not incur obligations by retrieving a representation.

3.5.1. Unsafe Interactions and Accountability

Transaction requests and results are valuable resources, and like all valuable resources, it is useful to be able to refer to them with a persistent URI . However, in practice, Nadia cannot bookmark her commitment to pay (expressed via the POST request) or the airline company's acknowledgment and commitment to provide her with a flight (expressed via the response to the POST).

There are ways to improve the situation. For transaction requests, user agents can provide an interface for managing transactions where the user agent has incurred an obligation on behalf of the user. For transaction results, HTTP allows representation providers to assign a URI to the results of an HTTP POST request using the "Content-Location" header (described in section 14.14 of [ RFC2616 ]).

Story

Good practice: Available representation

A URI owner SHOULD provide representations of the identified resource.

3.6.1. URI Persistence

As is the case with many human interactions, confidence in interactions via the Web depends on stability and predictability. For an Information Resource , persistence generally depends directly on the consistency of information conveyed by a series of representations. The representation provider decides when representations are sufficiently consistent (although that determination generally takes user expectations into account).

Although persistence in this case is observable as a result of representation retrieval, the term URI persistence is used to describe the desirable property that, once assigned to a resource, a URI should continue indefinitely to refer to that resource.

URI persistence is a matter of policy and commitment on the part of the URI owner . The choice of a particular URI scheme provides no guarantee that those URIs will be persistent or that they will not be persistent.

HTTP [ RFC2616 ] has been designed to help manage URI persistence. For example, HTTP redirection (using the 3xx response codes) permits servers to tell an agent that further action needs to be taken by the agent in order to fulfill the request (for example, the resource has been assigned a new URI).

In addition, content negotiation also promotes consistency, as a site manager is not required to define new URIs when adding support for a new format specification. Protocols that do not support content negotiation (such as FTP) require a new identifier when a new data format is introduced. Improper use of content negotiation can lead to inconsistent representations.

For more discussion about URI persistence, see [ Cool ].

3.6.2. Linking and Access Control

It is reasonable to limit access to a resource (for commercial or security reasons, for example), but it is unreasonable to prohibit others from merely identifying the resource.

As an analogy: The owners of a building might have a policy that the public may only enter the building via the main front door, and only during business hours. People who work in the building and who make deliveries to it might use other doors as appropriate. Such a policy would be enforced by a combination of security personnel and mechanical devices such as locks and pass-cards. One would not enforce this policy by hiding some of the building entrances, nor by requesting legislation requiring the use of the front door and forbidding anyone to reveal the fact that there are other doors to the building.

The Web provides several mechanisms to control access to resources; these mechanisms do not rely on hiding or suppressing URIs for those resources. For more information, see the TAG finding " 'Deep Linking' in the World Wide Web " .

4.2.1. Versioning

There is typically a (long) transition period during which multiple versions of a format, protocol, or agent are simultaneously in use.

4.2.2. Versioning and XML Namespace Policy

Dirk and Nadia have chosen a particular namespace change policy that allows them to avoid changing the namespace name whenever they make changes that do not affect conformance of deployed content and software. They might have chosen a different policy, for example that any new element or attribute has to belong to a namespace other than the original one. Whatever the chosen policy, it should set clear expectations for users of the format.

As an example of a change policy designed to reflect the variable stability of a namespace, consider the W3C namespace policy for documents on the W3C Recommendation track. The policy sets expectations that the Working Group responsible for the namespace may modify it in any way until a certain point in the process ("Candidate Recommendation") at which point W3C constrains the set of possible changes to the namespace in order to promote stable implementations.

Note that since namespace names are URIs, the owner of a namespace URI has the authority to decide the namespace change policy.

4.2.3. Extensibility

Designers can facilitate the transition process by making careful choices about extensibility during the design of a language or protocol specification.

Application needs determine the most appropriate extension strategy for a specification. For example, applications designed to operate in closed environments may allow specification designers to define a versioning strategy that would be impractical at the scale of the Web.

Two strategies have emerged as being particularly useful:

1.      "Must ignore": The agent ignores any content it does not recognize.

2.      "Must understand": The agent treats unrecognized markup as an error condition.

A powerful design approach is for the language to allow either form of extension, but to distinguish explicitly between them in the syntax.

Additional strategies include prompting the user for more input and automatically retrieving data from available links. More complex strategies are also possible, including mixing strategies. For instance, a language can include mechanisms for overriding standard behavior. Thus, a data format can specify "must ignore" semantics but also allow for extensions that override that semantics in light of application needs (for instance, with "must understand" semantics for a particular extension).

Extensibility is not free. Providing hooks for extensibility is one of many requirements to be factored into the costs of language design. Experience suggests that the long term benefits of extensibility generally outweigh the costs.

4.2.4. Composition of Data Formats

Many modern data format include mechanisms for composition. For example:

·         It is possible to embed text comments in some image formats, such as JPEG/JFIF. Although these comments are embedded in the containing data, they have little or no effect on the display of the image.

·         There are container formats such as SOAP which fully expect to be composed from multiple namespaces but which provide an overall semantic relationship of message envelope and payload.

·         The semantics of combining RDF documents containing multiple vocabularies is well-defined.

These relationships can be mixed and nested arbitrarily. In principle, a SOAP message can contain an SVG image that contains an RDF comment which refers to a vocabulary of terms for describing the image.

Note however, that for general XML there is no semantic model that defines the interactions within XML documents with elements and/or attributes from a variety of namespaces. Each application must define how namespaces interact and what effect the namespace of an element has on the element's ancestors, siblings, and descendants.

See TAG issues mixedUIXMLNamespace-33 , xmlFunctions-34 , and RDFinXHTML-35 .

Good practice: Separation of content, presentation, interaction

A specification SHOULD allow authors to separate content from both presentation and interaction concerns.

Good practice: Link mechanisms

A specification SHOULD provide mechanisms for identifying links to other resources and to portions of representation data (via fragment identifiers).

Good practice: Web linking

A specification SHOULD provide mechanisms that allow Web-wide linking, not just internal document linking.

Good practice: Generic URIs

A specification SHOULD allow content authors to use URIs without constraining them to a limited set of URI schemes.

Good practice: Hypertext links

A data format SHOULD incorporate hypertext links if hypertext is the expected user interface paradigm.

4.4.1. URI References

Links are commonly expressed using URI references (defined in section 4.2 of [ URI ]), which may be combined with a base URI to yield a usable URI. Section 5.1 of [ URI ] explains different mechanisms for establishing a base URI for a resource and establishes a precedence among the various mechanisms. For instance, the base URI may be a URI for the resource, or specified in a representation (see the base elements provided by HTML and XML, and the HTTP 'Content-Location' header). See also the section on links in XML .

Agents resolve a URI reference before using the resulting URI to interact with another agent. URI references help in content management by allowing content authors to design a representation locally, i.e., without concern for which global identifier may later be used to refer to the associated resource.

4.5.1. When to Use an XML-Based Format

XML defines textual data formats that are naturally suited to describing data objects which are hierarchical and processed in a chosen sequence. It is widely, but not universally, applicable for data formats; an audio or video format, for example, is unlikely to be well suited to expression in XML. Design constraints that would suggest the use of XML include:

1.      Requirement for a hierarchical structure.

2.      The data's usefulness should outlive the tools currently used to process it (though obviously XML can be used for short-term needs as well).

3.      Ability to support internationalization in a self-describing way that makes confusion over coding options unlikely.

4.      Early detection of encoding errors with no requirement to "work around" such errors.

5.      A high proportion of human-readable textual content.

6.      Potential composition of the data format with other XML-encoded formats.

4.5.2. Links in XML

Sophisticated linking mechanisms have been invented for XML formats. XPointer allows links to address content that does not have an explicit, named anchor. XLink is an appropriate specification for representing links in hypertext XML applications. XLink allows links to have multiple ends and to be expressed either inline or in "link bases" stored external to any or all of the resources identified by the links it contains.

Designers of XML-based formats should consider using XLink and, for defining fragment identifier syntax, using the XPointer framework and XPointer element() Schemes.

See TAG issue xlinkScope-23 .

4.5.3. XML Namespaces

The purpose of an XML namespace (defined in [ XMLNS ]) is to allow the deployment of XML vocabularies (in which element and attribute names are defined) in a global environment and to reduce the risk of name collisions in a given document when vocabularies are combined. For example, the MathML and SVG specifications both define the set element. Although XML data from different formats such as MathML and SVG can be combined in a single document, in this case there could be ambiguity about which set element was intended. XML namespaces reduce the risk of name collisions by taking advantage of existing mechanisms for allocating globally scoped names: the URI system (see also the section on URI ownership ). When using XML namespaces, each local name in an XML vocabulary is paired with a URI (called the namespace URI) to distinguish the local name from local names in other vocabularies. All of the globally grounded terms in an XML namespace share the same syntactic prefix: the namespace URI.

The use of URIs confers additional benefits. First, each local name / URI pair can be mapped to another URI, grounding the terms of the vocabulary in the Web. These terms may be important resources and thus it is appropriate to be able to assign URIs to them. One particularly useful mapping in the case of flat namespaces (specified, for example, in [ RDF10 ]) is to combine the namespace URI, a hash ("#"), and the local name, thus creating a URI for a secondary resource (the identified term). Other mappings are likely to be more suitable for hierarchical namespaces; see the related TAG issue abstractComponentRefs-37 .

Designers of XML-based data formats who declare namespaces thus make it possible to reuse those data formats and combine them in novel ways not yet imagined. Failure to declare namespaces makes such re-use more difficult, even impractical in some cases.

Attributes are always scoped by the element on which they appear. An attribute that is "global," that is, one that might meaningfully appear on elements of any type, including elements in other namespaces, should be explicitly placed in a namespace. Local attributes, ones associated with only a particular element type, need not be included in a namespace since their meaning will always be clear from the context provided by that element.

The type attribute from the W3C XML Schema Instance namespace "http://www.w3.org/2001/XMLSchema-instance" ([ XMLSCHEMA ], section 4.3.2) is an example of a global attribute. It can be used by authors of any vocabulary to make an assertion in instance data about the type of the element on which it appears. As a global attribute, it must always be qualified. The frame attribute on an HTML table is an example of a local attribute. There is no value in placing that attribute in a namespace since the attribute is unlikely to be useful on an element other than an HTML table.

Applications that rely on DTD processing must impose additional constraints on the use of namespaces. DTDs perform validation based on the lexical form of the element and attribute names in the document. This makes prefixes syntactically significant in ways that are not anticipated by [ XMLNS ].

4.5.4. Namespace Documents

Another benefit of using URIs to build XML namespaces is that the namespace URI can be used to identify an Information Resource that contains useful information, machine-usable and/or human-usable, about terms in the namespace. This type of Information Resource is called a namespace document . When a namespace URI owner provides a namespace document, it is authoritative for the namespace.

There are many reasons to provide a namespace document. A person might want to:

·         understand the purpose of the namespace,

·         learn how to use the markup vocabulary in the namespace,

·         find out who controls it and associated policies,

·         request authority to access schemas or collateral material about it, or

·         report a bug or situation that could be considered an error in some collateral material.

A processor might want to:

·         retrieve a schema, for validation,

·         retrieve a style sheet, for presentation, or

·         retrieve ontologies, for making inferences.

In general, there is no established best practice for creating representations of a namespace document; application expectations will influence what data format or formats are used. Application expectations will also influence whether relevant information appears directly in a representation or is referenced from it.

For example, the following are examples of data formats for namespace documents: [ OWL10 ], [ RDDL ], [ XMLSCHEMA ], and [ XHTML11 ]. Each of these formats meets different requirements described above for satisfying the needs of an agent that wants more information about the namespace. Note, however, issues related to fragment identifiers and content negotiation if content negotiation is used.

See TAG issues namespaceDocument-8 and abstractComponentRefs-37 .

4.5.5. QNames in XML

Section 3 of "Namespaces in XML" [ XMLNS ] provides a syntactic construct known as a QName for the compact expression of qualified names in XML documents. A qualified name is a pair consisting of a URI, which names a namespace, and a local name placed within that namespace. "Namespaces in XML" provides for the use of QNames as names for XML elements and attributes.

Other specifications, starting with [ XSLT10 ], have employed the idea of using QNames in contexts other than element and attribute names, for example in attribute values and in element content. However, general XML processors cannot reliably recognize QNames as such when they are used in attribute values and in element content; for example, the syntax of QNames overlaps with that of URIs. Experience has also revealed other limitations to QNames, such as losing namespace bindings after XML canonicalization.

For more information, see the TAG finding " Using QNames as Identifiers in Content " .

Because QNames are compact, some specification designers have adopted the same syntax as a means of identifying resources. Though convenient as a shorthand notation, this usage has a cost. There is no single, accepted way to convert a QName into a URI or vice versa. Although QNames are convenient, they do not replace the URI as the identification mechanism of the Web. The use of QNames to identify Web resources without providing a mapping to URIs is inconsistent with Web architecture.

One particularly useful mapping in the case of flat namespaces is to combine the namespace URI, a hash ("#"), and the local name; see the section on XML namespaces for more examples.

See also TAG issues rdfmsQnameUriMapping-6 , qnameAsId-18 , and abstractComponentRefs-37 .

4.5.6. XML ID Semantics

Consider the following fragment of XML: <section name="foo"> . Does the section element have what the XML Recommendation refers to as the ID foo (i.e., "foo" must not appear in the surrounding XML document more than once)? One cannot answer this question by examining the element and its attributes alone. In XML, the quality of "being an ID" is associated with the type of an attribute, not its name. Finding the IDs in a document requires additional processing.

1.      Processing the document with a processor that recognizes DTD attribute list declarations (in the external or internal subset) might reveal a declaration that identifies the name attribute as an ID. Note: This processing is not necessarily part of validation. A non-validating, DTD-aware processor can perform ID assignment.

2.      Processing the document with a W3C XML schema might reveal an element declaration that identifies the name attribute as an W3C XML Schema ID .

3.      In practice, processing the document with another schema language, such as RELAX NG [ RELAXNG ], might reveal the attributes declared to be of ID in the XML Schema sense. Many modern specifications begin processing XML at the Infoset [ INFOSET ] level and do not specify normatively how an Infoset is constructed. For those specifications, any process that establishes the ID type in the Infoset (and Post Schema Validation Infoset ( PSVI ) defined in [ XMLSCHEMA ]) may usefully identify the attributes of type ID.

4.      In practice, applications may have independent means (such as those defined in the XPointer specification, [ XPTRFR ] section 3.2 ) of locating identifiers inside a document.

To further complicate matters, DTDs establish the ID type in the Infoset whereas W3C XML Schema produces a PSVI but does not modify the original Infoset. This leaves open the possibility that a processor might only look in the Infoset and consequently would fail to recognize schema-assigned IDs.

The TAG expects to continue to work with other groups to help resolve open questions about establishing "ID-ness" in XML formats. See TAG issue xmlIDSemantics-32 .

4.5.7. Media Types for XML

RFC 3023 defines the Internet media types "application/xml" and "text/xml", and describes a convention whereby XML-based data formats use Internet media types with a "+xml" suffix, for example "image/svg+xml".

These Internet media types create two problems: First, for data identified as "text/*", Web intermediaries are allowed to "transcode", i.e., convert one character encoding to another. Transcoding may make the self-description false or may cause the document to be not well-formed.

Second, representations whose Internet media types begin with "text/" are required, unless the charset parameter is specified, to be considered to be encoded in US-ASCII. Since the syntax of XML is designed to make documents self-describing, it is good practice to omit the charset parameter, and since XML is very often not encoded in US-ASCII, the use of "text/" Internet media types effectively precludes this good practice.

4.5.8. Fragment Identifiers in XML

The section on media types and fragment identifier semantics discusses the interpretation of fragment identifiers. Designers of an XML-based data format specification should define the semantics of fragment identifiers in that format. The XPointer Framework [ XPTRFR ] provides an interoperable starting point.

When the media type assigned to representation data is "application/xml", there are no semantics defined for fragment identifiers, and authors should not make use of fragment identifiers in such data. The same is true if the assigned media type has the suffix "+xml" (defined in "XML Media Types" [ RFC3023 ]), and the data format specification does not specify fragment identifier semantics. In short, just knowing that content is XML does not provide information about fragment identifier semantics.

Many people assume that the fragment identifier #abc , when referring to XML data, identifies the element in the document with the ID "abc". However, there is no normative support for this assumption.

See TAG issue fragmentInXML-28 .

6.1. Architectural Specifications

ATAG10

Authoring Tool Accessibility Guidelines 1.0 , J. Treviranus, C. McCathieNevile, I. Jacobs, J. Richards, Editors, W3C Recommendation, 3 February 2000, http://www.w3.org/TR/2000/REC-ATAG10-20000203 . Latest version available at http://www.w3.org/TR/ATAG10 .

CHARMOD

Character Model for the World Wide Web 1.0: Fundamentals , T. Texin, M. J. Dürst, F. Yergeau, R. Ishida, M. Wolf, Editors, W3C Working Draft (work in progress), 25 February 2004, http://www.w3.org/TR/2004/WD-charmod-20040225/ . Latest version available at http://www.w3.org/TR/charmod/ .

DIPRINCIPLES

Device Independence Principles , R. Gimson, Editor, W3C Working Group Note, 1 September 2003, http://www.w3.org/TR/2003/NOTE-di-princ-20030901/ . Latest version available at http://www.w3.org/TR/di-princ/ .

EXTLANG

Web Architecture: Extensible Languages , T. Berners-Lee, D. Connolly, 10 February 1998. This W3C Note is available at http://www.w3.org/TR/1998/NOTE-webarch-extlang-19980210.

Fielding

Principled Design of the Modern Web Architecture , R.T. Fielding and R.N. Taylor, UC Irvine. In Proceedings of the 2000 International Conference on Software Engineering (ICSE 2000), Limerick, Ireland, June 2000, pp. 407-416. This document is available at http://www.ics.uci.edu/~fielding/pubs/webarch_icse2000.pdf.

QA

QA Specification Guidelines , L. Rosenthal, K. Dubost, D. Hazaël-Massieux, L. Henderson, Editors, W3C Working Draft (work in progress), 2 June 2004, http://www.w3.org/TR/2004/WD-qaframe-spec-20040602/ . Latest version available at http://www.w3.org/TR/qaframe-spec/ .

RFC1958

IETF RFC 1958: Architectural Principles of the Internet , B. Carpenter, June 1996. Available at http://www.ietf.org/rfc/rfc1958.txt.

UAAG10

User Agent Accessibility Guidelines 1.0 , I. Jacobs, J. Gunderson, E. Hansen, Editors, W3C Recommendation, 17 December 2002, http://www.w3.org/TR/2002/REC-UAAG10-20021217/ . Latest version available at http://www.w3.org/TR/UAAG10/ .

WCAG20

Web Content Accessibility Guidelines 2.0 , B. Caldwell, W. Chisholm, G. Vanderheiden, J. White, Editors, W3C Working Draft (work in progress), 11 March 2004, http://www.w3.org/TR/2004/WD-WCAG20-20040311/ . Latest version available at http://www.w3.org/TR/WCAG20/ .

WSA

Web Services Architecture , H. Haas, F. McCabe, E. Newcomer, M. Champion, C. Ferris, D. Orchard, D. Booth, Editors, W3C Working Group Note, 11 February 2004, http://www.w3.org/TR/2004/NOTE-ws-arch-20040211/ . Latest version available at http://www.w3.org/TR/ws-arch/ .

XAG

XML Accessibility Guidelines , D. Dardailler, S. B. Palmer, C. McCathieNevile, Editors, W3C Working Draft (work in progress), 3 October 2002, http://www.w3.org/TR/2002/WD-xag-20021003 . Latest version available at http://www.w3.org/TR/xag .