W3C home > Mailing lists > Public > www-ws@w3.org > June 2003

Re: Meaning

From: Stanislaw Ambroszkiewicz <sambrosz@ipipan.waw.pl>
Date: Sat, 21 Jun 2003 20:45:07 +0200 (CEST)
Message-Id: <200306211845.h5LIj7r26793@ns.ipipan.waw.pl>
To: drew.mcdermott@yale.edu
Cc: www-ws@w3.org, sambrosz@ipipan.waw.pl

Although you and me have in mind the same domain 
(i.e., web services), it seems that we are talking 
about two different languages and different semantics. 

Your point of view:  
From: Drew McDermott (drew.mcdermott@yale.edu)
Date: Wed, May 21 2003  
"... 
So what is to be done?  The answer is that we formalize 
concepts like ownership as thoroughly as it is possible to do.  
We provide ontologies in which "ownership," "payment," 
"delivery," "promissory notes," and such are all related 
together in various ways.  These relationships, expressed 
as axioms, _constrain_ the meanings of the symbols being 
defined, but they can never fully specify them.  So what?
The important point is that a vocabulary provide the 
necessary lubrication for interagent discourse.  
If everyone uses it, and everyone agrees on the meanings 
of the terms, or agrees 99% of the time, then web services 
will be useful and roboust.  On occasions when uncertainty 
creeps in, the committee in charge of the ontology
gets together and edits or adds axioms to reflect a 
consensus. 
 ... "
 
I agree that it is hopeless to construct the 
explicit meaning of natural language however 
some approximations may be interesting and important. 
The language must be open, i.e., it has to evolve. 
Moreover, in my opinion, it should be of 
distributive use, i.e., anyone can introduce new 
concepts to the language. However, there is a problem 
with implementing such distributive use, if there are 
"the committees in charge of ontology" that decide how  
and what is added to "the ontology". Even if we agree 
on "the committees" there is another problem how to 
scale this solution. If the ontology is closed and 
its consistency is verified, then it seems it is OK 
even if the ontology is large. What if an ontology is 
evolving and expanding so that it contains thousands, 
... or millions of axioms? How to maintain such ontology? 
Anyway, there was a DARPA project dealing with such kind 
of problems; I wonder what the results are.  

Now, let me explain my point of view. 
Your solution conveys the concepts from natural language 
(used in human world) immediately into a language of the 
emerging world of web services (ws-world for short). 
I propose to separate the ws-world from the human world, 
and construct a language only for ws-world along with 
precise semantics. It is clear that this language must 
relate to the human world but this will be discussed 
later on. 

The ws-world (called also cyberspace) consists of 
networked (TCP/IP) applications that exchange electronic 
data and process them; that's all what can happen there. 
Humans can influence the ws-world only by user interfaces 
(e.g., browsers, ssh, email, etc. ). Usually web services 
as well as user interfaces are placed in the border between 
these two worlds; they have interfaces to the human world 
as well as to the ws-world. It may look like science 
fiction, however I am interested merely in communication 
language for the ws-world. 

Requests as well as data are sent to the ws-world 
via user interfaces. A web service processes input data, 
and then sends output data to another service; this is 
what happens on the side of ws-world. On the other side 
the service may influence the real world as the result of 
processing this input data. 

The question is where the language is needed, used, and 
what its semantics is? 
It is clear that the language is needed to express 
requests and the types of operation the services perform. 
There is straightforward interrelation between requests 
and operation types. i.e., a request is to be realized by 
(a composition of) services. Hence, there must be a 
semantic equivalence of a request and of the types of 
operations that may realize this request. However, 
this semantics is always in the human world, i.e., 
on the side of users and the side of service providers; 
they must know what they want to realize, and what 
their services perform. 

The key point is to determine what the language must 
describe, i.e., what is going on in the ws-world. 
It seems that nothing but data of some types are 
processed by operations implemented by services into 
some other data. How to describe this in the language? 
The description should abstract from specific data 
and specific operations. In order to do so, names 
for data types and names for operation types are needed.  
The operation type is intended to have the generic 
meaning, i.e., to be represented by pair of formulas: 
precondition and effect (postcondition). 
These conditions should describe operation interface 
as well as what this operation does perform; a generic
way to do so is by using names that denote abstract 
functions as in mathematics. 

We can introduce names for new types and names 
for new functions to our language, so it would be nice 
to introducing also names for new primitive relations. 
The critical point of our approach is that this is not 
necessary. Relations describe some (local) situations 
in the ws-world. What happens in ws-world is, 
roughly speaking, only sending and processing data, so  
this can be described in terms of data types and 
operation types. Hence, the relations can also be 
defined in terms of data types and functions. 
A relation can be defined as a class of situations 
that take place if data of some types were processed 
by (composition of) functions, and then the result 
was sent to some place. A small number of primitive 
relations is needed to express equality, the fact that 
a data is in some place, etc..  

The resulting language is extremely simple; it is a 
version of the language of first order logic with types, 
and without quantifiers. It seems that explicit negation 
is not needed. The important requirement is that all 
names must be URIs. The language is open; it means that 
names for new primitive data types and functions can be 
introduced to the language. New complex functions and 
relations can be defined in the very similar way as it is 
done in mathematics, i.e., using definiens, definiendum, etc.. 

Since the axioms were not even mentioned, the question is 
about the meaning of the language. How do the names get 
the meaning in this language? The answer is extremely 
simple. A name gets its meaning by pointing into the 
place where it was originally defined either as primitive 
concept or as a complex concept. This very name contains the 
pointer to this original place. If it denotes a complex concept, 
then its meaning is defined in the definiendum. If it denotes a 
primitive concept, then the definition consists only of 
definiens. Since the name of this primitive concept 
is unique and points to the very place where it was originally 
defined (only by definiens), the meaning of this concept is fixed. 
Anyone who uses this name refers to this very place where 
it was originally defined. Informal meaning of this concept 
may be described in a natural language also in this place.  
You may say that it is a trick, nothing new, and no  
(machine readable) semantics at all. However, it works. 
The critical point is to grasp who can create formulas and 
who (rather what) processes them. 
In fact, the semantics, or language understanding is always on 
the side of humans, i.e., users and service providers. 
Only they can create formulas, so that they must understand 
what the formulas mean. Inside the ws-world the formulas are only 
processed in the very similar way as data are. 

It seems that the idea is extremely simple. However, it took 
three years for me to understand that it is so simple. 
More details at http://www.ipipan.waw.pl/mas/enTish/
 
-- Stanislaw Ambroszkiewicz
Received on Saturday, 21 June 2003 14:45:13 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Tuesday, 3 July 2007 12:25:43 GMT