Re: Why distinguish entity vs. resource was: Re: [URI vs. URIViews] draft-frags-borden-00.txt

>  >
>>  I think there are still some serious issues to sort out in this area,
>>  both within RDF and more generally.
>>
>>  Pat
>>
>
>Agreed. It is important that we keep these terms straight because without a
>proper _shared_ meaning for resource, entity etc, RDF is like defining math
>without a common agreement for which symbols represent the first, second and
>third integers.
>
>It is not immediately obvious why the distinction is made between a resource
>and the network entity that represents.
>
>Imagine the resource that represents "Pat Haye's resume",

Stop. What do you mean, *represents* a string of 18 characters ? What 
I would give the URI to would *be* my resume, it wouldn't *represent* 
it. That is, my resume is a document, written in HTML, located at 
that network address.

>you give it a URI:

Its a URL, let us not mince words. I have never given anything a URI 
that wasn't a URL, myself.

>
>http://pat.hayes.org/resume/
>
>Now suppose the Web had existed throught your early career. The actual
>document returned by referencing the URI would change from time to time as
>additions are made to the resume.

True. Now we have at least a three-way distinction to make.

1. The enduring 'thing' that is identified by the URL (I choose the 
'L' deliberately)
2. The particular document(s) that might be obtained by HTTP GETting 
that URL at particular time(s)
3. The entities - resources, things, whatever one wishes to call them 
- which are identified by/described by/ denoted by/ named by/ 
whatever the symbols in the retrieved document.

  RFC 2396 slurs these all together:

"A resource can be anything that has identity.  Familiar
          examples include an electronic document, an image, a service
          (e.g., "today's weather report for Los Angeles"), and a
          collection of other resources.  Not all resources are network
          "retrievable"; e.g., human beings, corporations, and bound
          books in a library can also be considered resources.

          The resource is the conceptual mapping to an entity or set of
          entities, not necessarily the entity which corresponds to that
          mapping at any particular instance in time.  Thus, a resource
          can remain constant even when its content---the entities to
          which it currently corresponds---changes over time, provided
          that the conceptual mapping is not changed in the process.

It seems to be using 'resource' in at least all three senses at once. 
Which in turn means that it isn't in fact saying anything at all. 
(BTW, that has got to be one of the worst-written definitions in a 
technical document anywhere on the web.)

My own judgement is that the first of these is in fact not really a 
coherent idea. There are no 'resources' in this sense; such things 
would be like the 'soul of a true name' in Earthsea, but they don't 
exist in the actual world. The fact is, some referring expressions 
change their referents from time to time, like "the President of the 
USA" .  URLs, and file names more generally, do.  We just have to 
face up to this, and stop pretending that it isn't really true by 
inventing spurious things called 'resources' that never change. There 
is *nothing* that is guaranteed to stay constant when the document 
retrieved by a URL changes, other than the URL itself.

BTW, this fantasy that URLs have been subsumed by things called URIs 
that are really not like old-fashioned global file addresses, but 
nowadays are elevated to a new status of being cosmically global 
IDENTIFIERS, is I think largely responsible for so much of the 
confusion. This is complete B.S., guys. There is no way, short of 
prayer, to guarantee the global coherence of any kind of general 
'identifying' scheme. There never has been and there never will be. 
URLs make sense and URNs make sense, and if we just say that 'URI' is 
a handy abbreviation for 'URL or URN or maybe some other thing that 
will be defined later', then fine. But then cut back on the rhetoric, 
please. What, for example, does RFC 2396 mean by a 'conceptual 
mapping' ? How would I recognize one if I met it?

>The document returned by HTTP GET is termed an _entity_, this is said to
>represent a resource. Certainly if I donwload this document, and edit it, I
>am not editing _your resume_, rather I am editing a _representation of your
>resume_.
>
>It is for this reason that the level of indirection between a resource and
>an entity is made.

I understand the motivation and the example. Unfortunately however 
the language used in all the available documentation is incoherent 
and really does little more than wave at the issue and pretend it is 
somehow thereby solved. There are some very big problems in making 
sense of this idea of a single thing existing through time and 
changing its properties. As far as I can see, URLs do not, in 
general, refer to continuants, and if URNs do, its only by virtue of 
the existence of a kind of identity-police system for URN 
registration.  There are no magical guarantees. Its time to face up 
to that, and stop pretending that they do.

>Another example might be the current stock price of Intel:
>http://nasdaq.com/ticker=INTC
>
>You see that the Web started out with resources that were classed as vaious
>types of documents,

That WERE (and still are, and always will be) documents. It wasn't 
just a matter of classification, it is inherent in the very nature of 
computing hardware and software. Computers do things to 
representations, and that is ALL they do. Even if you make a robot, 
what makes it move are its wheels, not its on-board computer.

>e.g. "resume" "home page" etc, The desire is to use
>resources things not directly connected to the Web, nor easily serializable,
>such as a "person" or a concept such as "Unicorn", such resources are termed
>"abstract resources".

What does 'use' mean in that sentence? If it means 'do something 
with', then wake up and stop smoking. If it means 'refer to', then 
fine: but then be careful not to confuse use and mention when talking 
about documents and things. Some of the resources refer to other 
resources, but only the former can actually be ON the web. Calling a 
unicorn a 'resource' doesn't make them suddenly computable; it just 
makes a semiotic claim to be able to talk about them. Which is 
*completely irrelevant* to the web, because all the web does is move 
representations around, in ways that have got *nothing whatever to do 
with* what those representations represent (except in the very 
special case where the representations are about other 
representations, like URLs.) The web is an inherently syntactic 
device.

>While an abstract resource is not connected to the Web, a _representation_
>of such a resource easily may be, e.g. a picture of you is available at a
>given URI, or a picture of a Unicorn is available at
>http://example.org/Unicorn.

Agreed. But now you have to be careful. Who or what decides what 
exactly some representation is 'of'? As far as any piece of software 
is concerned -  be it HTML or OWL - the best that can be done is that 
certain *kinds* of representation - text, XML/RDF, TIFF files, 
whatever - can be recognized and delivered to some engine that is 
able to use them appropriately. That is ALL it can possibly do. The 
engine must decide what to do with the representation (display it, 
color it green, process it in some way, draw conclusions from it, 
answer queries using it, whatever), and all that any kind of transfer 
protocol is able or required to do, is to deliver these 
representational packages on time and undamaged, as far as possible. 
The Web - http or semantic - is just a representation-delivery 
service. All the rest - including anything at all to do with meanings 
or intended referents - is either the business of some specialized 
engine, or the business of some human mind. RDF is no different from 
any other web medium in this regard.

>So again, the HTTP GET returns the
>representation i.e. the entity, not the resource.

Right, exactly. So the entire activity of the web is concerned with 
representations, not with resources. Let us get that carved in stone 
somewhere. Now, to return to RDF and fragIds for a second, and 
bearing the above in mind, the (non)issue seems to be that RDF claims 
to be able to use names to refer to anything, but the 
transfer-protocol web world says that fragIds can only be used after 
the absolute URI has been used to retrieve a document. Fine; a 
non-issue. The former is an off-Web matter private to RDF inference 
engines. The latter is on on-Web matter, and there RDF acts just like 
HTTP, so there is no problem.

>Does this make any sense?

Well, the last part did :-)

Pat
-- 
---------------------------------------------------------------------
IHMC					(850)434 8903   home
40 South Alcaniz St.			(850)202 4416   office
Pensacola,  FL 32501			(850)202 4440   fax
phayes@ai.uwf.edu 
http://www.coginst.uwf.edu/~phayes

Received on Sunday, 24 February 2002 20:10:26 UTC