Please get in touch with corrections for similar evidence that can contain some corrections. The w3c liability rules, use of trademarks, and documents apply.
The rdf resource description structure allows users to describe both web documents and concepts from our best efforts to — citizens: institutions, topics, computer products. – Processed method. The publication of such descriptions via the world wide web creates a semantic web. Uri (uniform resource identifiers) are very valuable, as they provide both the core of the structure itself and the link between rdf and the internet. This standard provides advice on how to use them effectively. It discusses two techniques called 303 uri and hash uri. Inside it lists several portals using these fixes and briefly discusses why some of the other proposals are having trouble.
This section describes the state of this document at the time it was published. This certificate may be superseded by other standards. A list of current w3c publications and the latest revision of this technical report can be found in the w3c technical reports index to us http://www.W3.Org/tr/.
This is a note from the w3c interest team containing a guide explaining tag decisions for some players in semantic web production. It was originally based on the dfki tech memorandum tm-07-01, cool uris for the semantic world wide web, and then published as a final w3c project in december 2007, and further in march 2008 semantic web education and outreach (sweo ) interest. W3c group, part of w3c semantic web activity. The drafts have been publicly reviewed, especially by the technical architecture team (tag) or the semantic web deployment team (swd). The only change when compared to the previous version of this document is the addition of a bookmark to the page incorrectly.
The brigade charter in the right direction semantic web education and outreach (sweo) expired at the end of march 2008 all – however, this certificate has the right to be applied by some other groups in the future for further development. Therefore, feedback on these documents is welcome. Please send comments about this document to public-sweo-ig@w3.Org (with a public archive). Limit of changes available.
Positioning as a note of an interested page does not imply endorsement by w3c members. Such certificate is a draft and may be updated, superseded or obsolete by other regulations at any time. It is inappropriate to refer to a single document as well as a work in progress.
This document was prepared by the group working to comply with the w3c patent policy of february 5, 2004. The group does not expect this kind of documentation to become a w3c recommendation. W3c maintains a public catalog of any patent disclosures made in connection with the group’s work; this page also contains guidance on patent disclosure. An individual who has actual knowledge of a patent that it believes contains substantial claims must disclose information in accordance with section 6 of the w3c patent policy.
The disclosure obligations of the participants are similar to statute.
This document is a practical guide for the creators of the rdf specification. The name is inspired by tim berners-lee’s article “cool uris don’t change” [cool]. Two approaches to these rdfs hosted on http servers are explained here. The intended audience is web developers and ontology creators who will decide how to model their rdf uris for use with http. Applications using non-http uri are not considered. This kind of document is an informative guide, covering certain aspects of previously published detailed technical specifications. 303 uris use the httprange-14 [httprange] resolution of the technical architecture group (tag). We assume that you are familiar with the basics of the rdf data model [rdfprimer]. We also assume some familiarity with the http [rfc2616] protocol. The wikipedia article [wp-http] serves as a good starting point.
1. Introduction2. Uri for web documents 2.1. Http and content negotiation
4.1. Hash-uri4.2. 303 uri sent in one shared document4.3. 303 uri forwarded to different documents4.4. Choice between 303 and hash4.5. Cool uri4.6. Binding4.7. Implementation of content coordination
6.1. New plans uri6.2. Description link
The semantic web is conceived as a decentralized, worldwide information place for the dissemination of machine-readable data with minimal integration costs.Its 2 big goals are distributed modeling of the world with a common data model, and an infrastructure where information and schemas can be published, searched, and bought. Players have the likely benefit of requesting data “raw and increasingly” [give] also in portable data formats [dp]. Vendors often publish their information embedded in a fixed interface in html format. Thus, the main issue is how to publish resource information so that regular customers and software applications can pick it up and interpret it.
In the semantic web, all information must be expressed as statements. About resources, for example, alice and bob are members of example.Com, or bob’s phone number is 1 555 262, or this page is hosted by alice. Resources are identified by uniform resource identifiers (uri) [rfc3986]. This way of modeling lies at the heart of the resource description framework (rdf) [rdfprimer]. A good introduction is given in the n3 tutorial [n3primer].
Using rdf, reports can be located on a company resource. Others can read the information and publish their own information by linking to existing resources. This forms a distributed model of the world. This allows the buyer to pick up any application to pass the evening and work with the same data, for example, to see alice’s published address in the selected address book.
At the same time, web documents were always addressed with uri (colloquially often referred to as uniform resource locators, urls). This is useful in that help means we can easily make rdf assertions about web pages, but it’s also insecure because we can easily confuse web pages with the things or resources described on the page.
So. The question is what uri should we leave in rdf? For example, to define the home page of the portal example inc. We can use http://www.Example.Com/. However, what uri identifies a company as an organization but not a site? Should we serve any content – html pages, rdf files – at these uris? In such a regulation, we answer these questions according to the relevant specifications. We explain how to use uri for non-web objects like people, products, places, offers, and concepts like ontology classes. We provide detailed examples of how a semantic web can and should be implemented as part of a web.
2. Uri for web documents
Let’s start with an example. Let’s say example inc. A fictitious company that makes extreme guitar amps, has a website at http://www.Example.Com/. Part of the portal is a white resource service and lists the names and address details of employees. Alice and bob both work at example inc. For example, the structure of a web resource might be as follows:
Like any on a traditional web, each of the above pages is a web document. Each web document has its own uri. Take into account that a web certificate is not the same step as a file: one web certificate may be available in many different versions and under numerous languages, and one file, for example a php script, may be responsible for creating many web papers with different uri. A web document is defined as something that offers a uri and is capable of returning representations (style resolutions that included html, jpeg, or rdf) of the identified resource in response to http requests. In technical literature such as the architecture of the web volume one [awww], the term “urban resource” is used instead of a web document. On which and for the purpose of getting it through the browser window. The concept of portal identity was not so important in the traditional web, the url simply identified whatever we see when we type it through the browser window.
2.1. Http and content negotiation
Web clients and modems use the http [rfc2616] protocol to request representations of web documents and send responses. Http has a powerful mechanism for suggesting different directions and language versions of the same web document, known as content negotiation.
When a user agent (like a browser) makes an http request, it sends some http headers to indicate which information formats and language it selects. The server then chooses the best match from its own file system or generates the desired video on demand and sends it to itself to the client. For example, a browser might send this http request to mention that it needs an html or xhtml representation of http://www.Example.Com/people/alice in a foreign or german language:
The server can answer:
Followed by the content of the html document with english subtitles.
Here we see [tag-alt] content matching in action. The server interprets the accept-language headers in the request and decides to return an english representation of the resource in question. Also be aware that the view’s uri is passed back in the content-location header, this is not required, but we advise (see [chips], 7.2). Clients see that this uri serves clients with a particular representation (in this case, english), and search engines can refer to the given representations using different uris. And this means that it is possible to have more views of the same resource.
Content negotiation is often done with a twist: instead of a direct response, the server redirects to the back url where the corresponding view is found:
A redirect is indicated by a special status code, here 302 found. The client will now send another http claim to the promoted url. By having separate urls for different views, this method allows web authors to link directly to a particular view.
Rdf/xml, the standard rdf serialization format, has its own content type, application/ rdf xml . Thus, content negotiation allows publishers to provide html representations of a web document to traditional web browsers and rdf representations to user agents using the semantic web. It also allows servers to provide alternative rdf serialization formats such as notation3 [n3] or trix [trix].
3. Uri for real world objects
In the semantic web, uri not only identify web documents, but also reality objects such as many and cars and even abstract sentences and non-existent things like the mythical unicorn. We name these objects or objects of the surrounding world.
From such a uri, how can we find out what it identifies? We need some way to eliminate this decision, because otherwise it will not be easy to achieve partnerships between independent information systems. We are able to provide a service in which we offer to search for a description of an identified resource, similar to modern search engines. However, such a single point of failure goes against the decentralized nature of the web.
Instead of these swindles, we should use the web itself, a highly secure and scalable signal publishing system, as a resource description lookup service. Each time a uri is mentioned, we can review it to format a description containing the information you need and links to related data. It’s so necessary that our organization makes this our number one requirement for classy uris:
Let’s say example inc. Wants to publish their employees’ contact details on the semantic web so that their business partners can import them. To your address books. For example, the published data would contain the following statements about alice, written on the resource in n3 [n3] syntax:
What uri should be used instead of the placeholder? Emphatically not http://www.Example.Com/people/alice, because that would confuse people with a web document, leading to misunderstandings: is alice’s homepage also called “alice”? Can the home page have an email address? And does it make sense for the room page to have its powers as its home page? Therefore, any adult needs a different uri. (For a detailed discussion of this issue, see “what do http uris describe? [Http-uri2]” and 4 uses of url: name, concept, location in search engines, and document instance [booth]).
so our second requirement is:
We note that the requirements here seem to conflict with each other. If we are not able to use documentation uri to identify objects in the most objective way, then how are we able to get an idea about regiondv.Ru objects based on their uri? The mission is to find a solution that will allow us to find descriptive documents if we only have a resource uri, using standard web technologies.
The following figure shows the desired relationship between a site and its document representations:
3.1 difference between shows and descriptions
It is important to be aware that a uri can be identified as a thing that will function offline, and a web a document that defines a thing. For example, the person alice is described on her home page. Bob may not like the look of the homepage, but he likes the character alice. Thus two uris are needed: one for alice, one for the home page or rdf document describing alice. The problem is where to draw the line between the case when both are available and the case when only descriptions are available.
According to w3c guidelines ([awww], section 2.2.), We have a web document (there called an information resource) if all of its main characteristics can be conveyed in a message. Examples are a web page, a photo, or a product catalog.
In http, since a 200 response code must be sent when accessing a web document, only publishing requires a different setting. Uri required to identify entities that are no longer considered web documents.
The next page describes solutions that allow you to create uri for things, and also provide an opportunity for players to get a description of the thing. Through standard web technologies.
4. Two solutions
There are two outputs that meet the game requirements for identifying real objects: 303 uri and hash uri. Which one to use depends on the situation, both have strengths and weaknesses.
The solutions below are applicable to deployment scenarios where rdf data and html information are served separately, such as standalone rdf document/ xml along with the html document. Metadata can also be embedded in html using these devices, like rdfa [rdfa primer], microformats and other documents that grddl [grddl] mechanisms can suit. In this case, the rdf data is retrieved from the returned html document.
4.1. Hash uri
The first solution is to use a “hash uri” for undocumented resources. Uri may contain a fragment, a special part that is separated from the rest of the uri by a pound sign (“#”). Request uri from the server. This leads to the fact that the uri containing the hash cannot be obtained on the internet and, therefore, does not identify the web document. However, we are willing to use them to identify other, undocumented resources without causing ambiguity.
If example inc. Makes this decision, they will be able to use these uris to host the company, alice and bob:
Clients always remove part of the fragment before requesting any of these uris, resulting in a request for them uri:
In this uri, example inc. Is able to produce an rdf document containing descriptions of all three resources, using the original hash uri to identify the resources.
The following figure shows a relationship using a hash uri without content negotiation:
Alternatively, content negotiation (see section 2.1.) Can be used to redirect from an about uri to an html or rdf representation. The decision of what to return depends on the vagaries of the stronger sex and the server configuration, as described in section 4.7 below. The content-location header must be set to indicate whether the hash-uri refers to part of an html or rdf document.
The following figure shows the hash-uri approach with content negotiation:
4.2. 303 uri redirecting to one shared document
The second solution is to try a special http status code, 303 see other, to indicate that the requested resource has not become a regular web document. The web architecture says that it is inappropriate to return 200 for a thing (uri) resource, for the reason that, by the way, there is no suitable representation for these resources. However, it is useful to inform about all resources. The w3c technical architecture team provides a solution in their httprange-14 [httprange] document that should direct you to a document containing information about the subject you were asking about. By doing the right thing, we avoid ambiguity between the original, real object and the resource that represents it.
Because 303 is a redirect status code, the server can specify the location of the paper that represents the resource. If, on the other hand, the request is answered with one of the usual status codes from 2xx, such as 200 ok, the client is aware that the uri identifies the web document.
If example inc. Accepts this task, they are able to use these uris to represent the company, alice and bob:
The web server will be oriented to respond to requests to any of these uris with a 303 status code and a location http header a that contains the url of the document that represents the resource. Eg: to redirect from http://www.Example.Com/id/alice to http://www.Example.Com/doc/alice.
Then content-negotiation is used. When getting views from document uri using http request. The server decides (see section 4.7) to return either html or rdf (or optional miscellaneous forms), and sets the content-location header to the uri where to actually get the particular view.
This setting should be applied when rdf and html (and quite possibly other alternative representations) convey the same information to the specifications in different forms. When the information in the variants differs significantly, approach 303 should be used, as described below.
Seesee the following illustration for a solution providing a generic document uri.
in this setup, the server redirects the uri to the generic document uri. The advantage of this is that clients allow you to create bookmarks and work with a common document after a while. A user with an rdf-enabled buyer will help bookmark the document on the desktop, and send it to another user (or device), who will then dereference it and get an html or rdf representation. And in the future, the server may add views in ready-made languages. Just because the client started with a uri of nothing, this situation does not mean that the spec involved is not a first-class document in www. General data about the shared resources of documents are described in [genres].
4.3. 303 uri redirecting to different documents
If the rdf and html representations of the resource are very different, the previous setting is not allowed. The above are not two versions of the same certificate – but completely different snapshots. Also, the web server will be configured to respond to requests with a 303 status code and a location http header that provides the url of the document representing the resource.
The following figure shows redirects for a 303 uri solution without a generic document uri:
A server can use content negotiation (see section 2.1.) To send either an html-url descriptions, or rdf. Http requests for html content will be redirected to the html urls we specified in directory 2. Messages to these rdfs will be redirected to rdf documents like:
Each of the rdf documentation will contain statements about the highest resource, using the original uri, e.G. Http://www.Example.Com/id/alice, to identify the described resource.
4.4. Choosing between 303 and hash
Which approach is better? It depends. The advantage of hash uri is that it reduces the number of http requests needed, which in turn reduces access latency. The uri family can survive the same unhashed part. Descriptions http://www.Example.Com/about#exampleinc, http://www.Example.Com/about#alice, https://keycodesoftware.com/ and http://www.Example.Com /about #bobs are retrieved with a single order http://www.Example.Com/about. However, the specific approach has another side to the coin. A client only interested in #product123 will inadvertently download qualities for other enthusiastic resources as well, since such predictions are in the same file. 303 uris, on the other hand, are very flexible, as the redirect target can be configured separately for each portal. There can be one descriptive help for each site, or one serious document for all of them, or any combination in between. You can also change the policy later.
When using uri 303 for an ontology such as foaf, network latency can significantly degrade client performance. A lot of redirects can result in increased latency. A client looking for a term set through 303 can use many queries, even when the first query has already downloaded absolutely everything there is to know. All the information using a lot of queries. We advise additionally providing sparql endpoints or similar services to directly respond to complex site orders rather than allowing the client to download a large set of data via http.
Note that both 303 and hash match correctly , which makes it possible to split the whole dataset into a couple of parts and issue an identifier for a platform that is not a document. An example of a combination of 303 and a hash:
Any fragment id is valid, can be seen in the above uri is a suggestion that everyone can copy for production implementations.
Hash uri without content negotiation can be done by simply uploading static rdf videos to a web server without much special server configuration. This makes them popular for quick-and-dirty rdf publishing.
Uris of the form bob#this can be used for mature datasets that are or may grow beyond the point at which it is appropriate to serve all related resources document immediately. 303 uris are also meant for this kind of information sets, it makes uris neater, but worrying has an impact on production time performance and server load.
When in doubt, follow your nose.
4.5. Cool uri
The best site identifiers don’t just provide descriptions of citizens and cars, but are designed with simplicity, restraint, and manageability in mind, as tim berners-lee explains in cool uris don’t change in the w3c command either. Common http implementation problems (sections 1 and 3):
All uris associated with one real resource object id, rdf document url, html medical help url should also be kept explicitly linked to help information consumers recognize them connection. For example in the 303 uri solution for example inc. There are 3 uris associated with alice:
Two of them are web document urls. An rdf document hosted at http://www.Example.Com/data/alice can have the following claims (expressed in n3):
The document contains claims about alice, the person using the identifier resource. The thickest two properties associate a resource id with 2 document uris. The foaf:page statement links it to an html document. This allows rdf-aware clients to find a human-readable website – and at the same time, by associating a tab with its theme, determines useful metadata about that html document. The rdfs:isdefinedby statement associates people with the document containing its rdf description and allows rdf browsers to distinguish this main site from other ancillary services that are accidentally mentioned in the contract. We work with rdfs:isdefinedby instead of its weaker rdfs:seealso superproperty, due to the fact that the content in /data/alice is authoritative. The rest of the statements are the actual data of the white pages.
The html document at http://www.Example.Com/people/alice should contain an element in the specialized header pointing to the corresponding rdf document:
This allows web clients that support rdf to discover rdf information. Such a method is reasonable in the rdf/xml specification ([rdfxml], section 9). If such rdfs refer to a web page but not to an expression of the information it contains, we recommend using rel=”meta” instead of rel=”alternate”.
The client can also display similar information regarding the link from the http headers themselves: much is described in the web document, which you can find at the end of the 303 redirect; that the content-location resource is a content-specific version of the shared document, and more. The ontologies for these relationships are not discussed here.
The following figure shows how the rdf and html documents should associate three uris with each other:
4.7. Implementing content negotiation
The w3c feedback working group to deploy the semantic web has published a document that describes how to run the solutions presented here on the apache web server. The guidelines for publishing rdf dictionaries [recipes] only discuss publishing rdf dictionaries, but such dreams can also be applied to other kinds of small rdf datasets that are published from static files.
However, in particular when it comes to content negotiation, the recipes supporting documentation does not cover some important details. Arranging files in your favor is a little trickier due to mixed mode clients that can function with both html and rdf, among them firefox with a tabulator extension.
These browsers claim their own ability to use both rdf and html via accept headers using q (quality) values:
This browser accepts rdf with a q value of 0.7 and html with a q value of 1.0 (default). This means that the browser has a slight preference for html over rdf.
Now client preference for html does not necessarily mean that every server should send html. The server must study the requirements of the buyer and then choose from the quality platform of the different options that it has to offer. For example:
– If the html variant is a simple poor-quality rendering of rdf, such as a table of property values or a list of triples, then the server should send the rdf unless the client strongly prefers html. – If the html and rdf variants contain the same data and both are of excellent quality, then the server should treat both variants with equal preference and leave the choice to the client. .- If the rdf option remains solely part of the information offered in the html, or is taken from the html, then the server should probably send the html unless the buyer prefers rdf.
There are selection algorithms the best match by comparing the tastes of the client with a guarantee of the available varieties of the server. For example, the apache server needs to be configured with server-side qs values that determine their relative quality.
A qs value of 1.0 for application/rdf xml and 0.5 for text/html , will mean that the html version is about half the quality of rdf and is ready to fit in the first version of them above. If the html is a news article and the rdf contains minimal information such as title, date, and author, then 1.0 for html and 0.#1 for rdf would be appropriate.
To determine the best way for a particular client, apache multiplies the client’s q value for html by the configured qs value for html; and the same for rdf. The method with a significant number wins. The apache document has an archive detailing the content negotiation algorithm [apcn]. The accept http header is detailed in registry 14.1 of the http [http-spec].
Negotiating content with all of its details is tricky, but it’s a powerful choice. Best way to discharge for hybrid clients able to work with html and rdf.
5. Examples from the internet
Not all semantic web ideas make their recordings, drawings, and favorite songs available on the world wide web. With more and more projects following the methods described here. It gives some examples.
Ecs southampton. The school of electronics and computer science at the university of southampton has a semantic web site using the 303 solution that is a great example of semantic web development. This is documented in the ecs uri [ecs] system specification. Separate subdomains are used for html passports, rdf documents, and resource ids. Take the following examples:
Entering the first uri into a weekday web browser redirects to an html page about wendy hall. It presents a web representation of all possible delivery information about it. The page also references its uri and its rdf document.
D2r server is exactly this application with free primary code, which is allowed to be used to place information from consumer relational databases in the semantic web in accordance with these recommendations. It applies the 303 decision and content negotiation. For example, the d2r server that publishes the dblp bibliography database publishes several thousand bibliographic records and data about their authors. Example uris reconnected via a 303 redirect:
The rdf document for chris beezer is the result of a sparql request from the sparql server destination:
The sparql request is encoded in the given uri :
This hints, as well as using the sparql endpoint as a convenient method for serving resource descriptions.
Semantic mediawiki is open source. Semantic wiki engine. Authors use a special wiki syntax to add semantic attributes and relationships to wiki articles. For any article, the program generates a uri 303 that identifies the subject of the article and maintains rdf descriptions generated from attributes and relationships. Semantic mediawiki manages the ontoworld wiki. Inside it has an article about the town of karlsruhe:
The rdf description uri is far from perfect because it exposes the implementation (php) and redundantly references rdf in the path and in the request. A noticeably more comfortable uri would not break, for example, http://ontoworld.Org/data/karlsruhe, since it has the ability to fix content negotiation for data repair in rdf, rif (rule exchange format) or in any other that we come up with further.
6. Other sections on resource naming
A lot of other approaches have been proposed so far. Although most publications are suitable for special conditions, we know for sure that midges do not meet the criteria from category 3 that must be online and may not contain ambiguous. Therefore, our hackers will not be suitable as general solutions for building a standards-based, non-fragmented, decentralized semantic web. We will discuss two of these approaches in more detail.
6.1. New uri plans
Uri http already identify sites and web crusts, but not other types of resources. Shouldn’t we create a new uri scheme to identify other resources? In these circumstances, we can simply tell them apart from web documents just by looking at the underlying uri characters. For example, the information scheme is allowed to be used to identify books by lccn number: info:lccn/2002022641.
Here are examples of these new uri schemes. A more weighty list is provided by thompson and orchard in urn, namespaces, and [tag-urn] registries. File management tools. It’s generated from hash values, the uri looks like this: magnet:?Xt=urn:sha1:ynckhtqcwbtrnjiv4wnae52sjuqczo5c.- Info: a uri scheme is proposed to identify information assets that have been given identifiers in existing public namespaces. . Examples are uri for lccn numbers (info:lccn/2002022641) and dewey decimal (info:ddc/22/eng//004.678). Domain name and uri allocation date. Even if the domain later changes ownership, the uri will remain unambiguous. Example: tag:hawke.Org,2001-06-05:taiko.Xri defines a resolution scheme and protocol for abstract identifiers.The idea is to use wildcard uris to adapt to changes in organizations, servers, etc. Examples are @jones.And.Company/( phone.Number) or xri://northgate.Library .Example. Com/(urn:isbn:0-395-36341-1).
To be truly useful, the new scheme must be accompanied by a protocol specifying how to gain access to additional information about the identified resource. . For example, the ftp:// uri scheme identifies resources (video is on an ftp server) and also contains the protocol for it to receive (ftp protocol).
Some of the new uri schemes provide little to no such protocol. Others provide a web service that allows you to earn descriptions using the http protocol. The identifier is passed to a service that looks up the information in a central knowledge base or in a federated fashion. The point here is that overlays in this service make the system unusable.
Another disadvantage is possibly dependence on a standards body. To register new parts in the virtual space, one must contact the standardization body. Either paying a license fee before creating a new uri slows down adoption. In such cases, you would like the standards center to guarantee that all uris are unique (for example, with isbn). But other things can be achieved by using an http uri inside the http namespace, which is owned and controlled by the standards company.
Regardless of the standards body and searchability, pending patents and legal issues can affect adoption new uri. Scheme. When using proprietary technology, developers should ensure that a royalty-free license is available.
Problems with advanced uri schemes are discussed in detail in urn, namespaces, and registries.
6.2. Link by description
“Link by description” radically eliminates the task of uri, completely abandoning uri: instead of naming resources using uri, anonymous nodes are used, which are described by information that enables us to choose the right one. For example, a person can be identified by name, date of birth, and social security number. These pieces of information should be enough to uniquely identify a person.
It is becoming a popular practice to mount a person’s email address as unique identifying information. For this purpose, the friend of a friend (foaf) account uses the foaf:mbox property. In owl, such a property is known as an inverse functional property (ifp). When an agent encounters two resources with just the same email address, he can conclude that both belong to the same people and treat them as the same person.
But how with such attention work on the internet? How to allow agents to download more information about the resources we mentioned? To achieve this goal, it is recommended to use not only the ifp of the resource (for example, the person’s email address), but also the rdfs:seealso property, which points to the internet resource of the rdf-diploma with increased data about it. We find that http uri, as before, are used to determine location where additional information is loaded from.
Moreover, now we need a few pieces of analysis to refer to the resource, ifp value and rdf document location the simple act of linking involving uri is recognized as a process involving a few moving parts, which increases the risk of broken links and makes the implementation more cumbersome.
Regarding the practice of foaf to avoid using human uris, we’re ready with tim berners-lee’s advice: “go ahead, create your own uri. You deserve it!”
The names of sites in the semantic web must satisfy two requirements: first of all, the description of the identified resource must be really for dating using standard web technologies. The second step, the naming scheme is not required to mix things and the documents that represent them.
We have described two approaches that satisfy the listed guidelines, both based on the http uri scheme and protocol. One is to use the http 303 status code to redirect from the site id to the description document. Treat the gaming community is to use a “hash-uri” to identify resources, using the fact that the hash-uri is extracted by discarding the part after the hash and extracting the other part.
The requirement to distinguish between resources which descriptions increase the need for coordination between many uris. Some useful techniques include embedding redirects to rdf data in html documents, using rdf operators to describe relationships between uris, and using content negotiation to redirect to the appropriate resource description.
A big thanks to tim berners-lee who spent a lot of time helping us understand the tag solution by responding to chat requests and sending many emails with clarifications and detailed reviews of this piece of paper. Special thanks to stuart williams, norman walsh and all other tag members who reviewed a similar document for june 2007. And september 2007. Provided important comments about some of the wording that (accidentally) contradicted the point of view of tag. Special thanks also go to semantic web deployment group members michael hausenblas, wit nowacek, and ed summers for their reviews and their review summary sent in october 2007. Grimnes, harry halpin, xiaoshu wang, henry s. Thompson, jonathan rees, and christoph paper. Susie stevens reviewed the document, guided the sweo, and kept us on track. Ivan herman did a lot to check w3c compliance and posted a note.