Re: About ticle

-----Original Message-----
From: Joe Geldart
To: [email protected]
Sent: 15.12.2003 07:03
Subject: [Collective-ticle] Re: About ticle

>Hi,
Hi,

Since this is a long posting and a long comment and a long answer
to the comment... you'll get an abstract. So not everyone has to read
everything.


ABSTRACT: 
* Ticle _is_ not RDF. 
* To make ticle do something with RDF or be compliant or compatible or
  whatever - there has to be done a lot of work yet.
* There is a similaritiy/resemblance between RDF and ticle: both have
  to do with triples.

---- skip this if you are not interested in "history" and "personal" stuff ---

Since I have not introduced myself: My name is Sebastian Wiemer, I
am german and I work in a small company in Germany which integrates 
software for web-portals and content management systems.

We've done a few projects using plone. In one project we designed a
link-manager, which is quite what we have with ticle now. (Though ticle
is a little evolved - think of it as a "version 2" of the link manager.)

Simon has done a greate job reimplementing everything for ticle! Thanks Simon!
We've had never come so far without you.

The underlying concepts of using triples were indeed inspired by RDF, but
(Joe..) that's the whole story about ticle and RDF. 

Markus, Tobias an me have supported and in a way guided Simon with all 
the knowledge we had. It was very "quarrelsome", because we wanted it to
be a very clean and well-defined engine. We did not want to include features
to make it fit a specific purpose. It was my idea to attach any features
either through "pluggable modules" or - more preferably in my eyes - through
modeling as much as possible into triples and write as little as possible 
modules to interpret those triples. Ideally we would have only one module 
(called the "semantics manager" or so) capable of interpreting specific
triples. See my proposal for further infos about this... 

---- skipped... ----

And here my answer, if you are still interested... ;-)



>
>Following this post, I have some quite urgent questions to the group. I
>hope you can answer them quickly and precisely. Please note that I am
>biased towards RDF as it is my area of research.
>
>On Mon, 08 Dec 2003 19:58:35 +0100, Sebastian Wiemer wrote:
>
>
>
>> 1. The relation between RDF and ticle
>> 
>> RDF and ticle share the concept of triples - though ticle is more
>> abstract than RDF. (E.g.: In RDF the spec differentiates between the
>> nature of the subject, the predicate and the object:
>> (http://www.w3.org/TR/2003/WD-rdf-concepts-20031010/#dfn-rdf-triple)
>> whereas ticle does not.) Ticle says: triples consist of four UIDs: the
>> UID for the triple (needed for reification) and the UIDs for subject,
>> predicate and object. As a matter of fact there is not even any clear
>> binding to the ideas of subject, predicate and object in ticle. Though,
>> since a triple is a triple there is no syntactic difference between RDF
>> and ticle and it helps some people to understand when calling the first
>> triple item "object", the second "predicate" and the third "object".
>> 
>> 
>
>So, how do you encode relationships that aren't commutative without a
>definite binding of subject,predicate,object?

With "not even any clear binding to the ideas of subject, predicate and 
object" 
I wanted to say, that ticle does not have a any specific semantics "build in".
That means: there are no words: like "predicate", "subject" or "object" 
defined yet - that is why these words do not have any meaning in the "world
of ticle" and that is why we have yet to define
that semantics of ticle. I am working on this and appreciate all help I
can get.

[ Off topic: In my opinion there is no semantics without interpretation. So 
what we had up
to this point is only "natural" semantics. (That is the meaning of a word
we understand in natural language in contrast to defined symbols/strings... 
in a computer) 

If I tell a person to consider the first triple item as subject, the second as
predicate and the third as object that person is able to interpret triples and
thus "creating" the semantics. If that person knows RDF, the person is likely
to create a different semantic than a person not knowing RDF. It is possible,
that the terms "object", "subject" and "predicate" will be mixed up with the
homonymous words in RDF.]

We could start introducing triple items being axioms with a human 
understandable and mathematically expressable and computable semantics.

That will be something like "Atom", "isA", "hasProperty" or "subject", 
"predicate", "object" and so on. Since I'm not a mathematical genious
I'd like to keep this simple - or let this do somebody more capable...

Of course these (Atom, isA, ...) will be only UIDs. I have talked to Simon
about this. I was thinking of storing the very basic axioms in some sort of
dictionary.  So any application that wants to express something using these
axioms can retrieve the UIDs from the dictionary accessibly from outside.


> You may complain that 'RDF
>isn't general enough' but all logic and semantics is about structure.
>You
>can only understand the idea of representation in terms of the structure
>of the encoding. Removing all structure is tantamount to removing all
>meaning. The developers of RDF spent a long time ensuring that it had
>just
>enough structure to encode an easily processable subset of FOPL.
>

I did not intend to complain about RDF. As a matter of fact I'm not aware of
complaining about anything ;-) I think RDF serves it's purpose. (Though I
might not understand all of RDF's purposes...) I think there was a clear goal
in designing RDF: Describing resources. Ticle is not that specific. In my view
ticle is not up to anything particular by now, it's just an engine to manage
(storing, retrieving, ...)  triples.

But you _are_ right about too little structure. Removing all structure will
not make it possible to define meaning. That is why there is a great deal of
work to do: defining a semantic for ticle. I think the best way is - as I
tried to say already - by modeling meaning through a small set of axioms
(triples) and creating modules interpreting (=being capable of processing)
these triples.

I can only speculate - but I think you'd like to encode the "subject",
"predicate" thing directly into the engine. I don't like this approach,
because it makes seperating the layers of the engine more difficult - and it
is just something different than what we already have. Ticle works with UIDs
not URIs (and so on).



>> Ticle is NOT RDF. Nor does ticle support any out-of-the-box features
>for
>> RDF.
>> 
>> 
>
>This raises the question of 'what is a feature for RDF?' As far as I'm
>concerned RDF itself is just the model that uses triples of URIs.
>

Hmmm. Maybe not "features" but let's say goals, presumptions ...
As I stated: the triples in ticle do not "mean" anything. Especially
(that is what I meant with "features"... )
Things like URIs or the goal of describing URIs or differing between 
certain object types. (See below.)

So it's not really "features" you are right. It's that it is made for 
a specific purpose, which ticle is not.


>
>
>> a) RDF aims in producing a specification (in XML and graphical) to
>model
>> information -- ticle aims to produce a running system to connect
>objects
>> together (e.g. in plone)
>> 
>> 
>
>RDF's goals are therefore compatible with information modelling in the
>wider world, rather than just objects stored on one server. Why is this
>restriction made? What is wrong with RDF as a model? Is there a specific
>reason for focusing on a subset of power for greater time expense?

I see at least two reasons:
1. assuring referential integrity
2. beauty of design ;-)  ticle is only about reified triples
   no URIs, no literals, no distinction between
   triple-items and reified triples

1.) Up to now ticle has a feature called "referential integrity".
For what it was designed in the first place this was considered a 
very important feature itself.

It was needed by the "constraint manager" which remaines (mainly due
to my inactivity for at least two months) unfinished for ticle.

It was a piece of software that could tell wether a link could be added
or deleted. It knew about relation types like: "1:1, 1:n, n:m and n:1".
Without referential integrity this is impossible to realize.

BTW: I did a complete "redesign" modelling constraints in triples. 
I had to introduce the concepts of filters and atoms and many more
things. But since this is not worked out yet, ... 

You may have a look on a test thing I wrote to play with triples.
http://guest:[email protected]
I've tried to implement a "constraints" and "filters" as well, 
but it is very buggy. (I'm no not a programmer after all...)


2.) reification is a very important thing to ticle, that will come
clearer when semantic models are attached.
I'm sorry that I don't go deeper into detail here. That topic is difficult
(for me!) and I want to be clear about everything before I start to confuse 
others with unfinished thoughts in my head.


>
>[N.b. XML is only one serialisation of RDF. Recent research by Tim
>Berners-Lee has produced the Notation3 and NTriples serialisations for
>human readability.]
>

Interesting. Thank you.

>> b) RDF comes with a predefined set of types and metadata -- ticles
>> metadata concept (though a work in progress) is based on the same
>> triples that are used to model the content. Thus enabling to change
>the
>> metadata structure in a running system. (See my ideas on the
>constraint
>> manager...)
>> 
>> 
>
>I'm confused here. What 'standard types' are you talking about? RDF says
>very little about anything at all. RDF Schema (an RDF ontology) includes
>predicates to
>describe ontology in RDF, and this is extended by OWL but RDF itself has
>no standard types. It is open and extensible. Standard metadata makes no
>sense to me either.


Hmm. Sorry, I'm no expert about RDF. I copied the part I must have
misunderstood:

---------------- snip ------------

The basic data model consists of three object types:

Resources 

All things being described by RDF expressions are called resources. A
resource may be an entire Web page; such as the HTML document
"http://www.w3.org/Overview.html" for example. A resource may be a
part of a Web page; e.g. a specific HTML or XML element within the
document source. A resource may also be a whole collection of pages;
e.g. an entire Web site. A resource may also be an object that is not
directly accessible via the Web; e.g. a printed book. Resources are
always named by URIs plus optional anchor ids (see [URI]). Anything
can have a URI; the extensibility of URIs allows the introduction of
identifiers for any entity imaginable.

Properties 

A property is a specific aspect, characteristic, attribute, or
relation used to describe a resource. Each property has a specific
meaning, defines its permitted values, the types of resources it can
describe, and its relationship with other properties. This document
does not address how the characteristics of properties are expressed;
for such information, refer to the RDF Schema specification).

Statements   

A specific resource together with a named property plus the value of
that property for that resource is an RDF statement. These three
individual parts of a statement are called, respectively, the subject,
the predicate, and the object. The object of a statement (i.e., the
property value) can be another resource or it can be a literal; i.e.,
a resource (specified by a URI) or a simple string or other primitive
datatype defined by XML. In RDF terms, a literal may have content that
is XML markup but is not further evaluated by the RDF processor. There
are some syntactic restrictions on how markup in literals may be
expressed; see Section 2.2.1.



------------------- snap ------------------


I've understood some things here, including:
1. There are three object types (resources, properties and statements)
2. Subjects (=resources) are always URIs
3. Predicates (=properties) are metadata about a resource
   --> the "how" is defined somewhere in the rdf schema spec...
4. Objects (=property value) may be a URI or a string or other primitive
5. There are primitives, there are strings, there are URIs 
6. subject, predicate and object form a statement

My statement about "metadata" is inaccurate. You are right:
metadata and types are defined in rdf schema (or elsewhere). 
But I was not talking about metadata about "data". I was concerned 
about something different:

In RDF there is a "vocabulary" to formulate statments. In ticle there is not.
The vocabulary  e.g. "<Description>" has a predefined or "standard" semantic.  

It's metadata about triples/triple-items.

>> c) RDF is designed to be embedded in XML documents. Ticle is not.
>> 
>
>Wrong, RDF/XML is designed to be embedded in XML. RDF is just a labelled
>directed graph. XML is actually a very poor medium for this.

I agree RDF/XML would have been correct. I am not used to work with any other
representation. In fact (due to my limited dealings with RDF?) I've never come 
across any other representation other than RDF/XML apart from arcs and 
bubbles.

I do not agree RDF/XML being a very poor medium. XML has it's advantages.
There is a hughe infrastructure available. Many XML parsers, XSLT processors,
proper handling of encodings, interoperability with SVG, MathML, SMIL, ...

Though RDF/XML is not efficient for graphs - if they don't "accidently" happen
to be trees.

Maybe ticle will be more efficient. If you take some time and give ticle a
closer look, you might see a possibility to implement RDF in ticle, being an
expert in RDF after all.

>> d) RDF uses URIs for referencing - ticle uses referential integral
>UIDs
>> (as a consequence, URIs are accessible directly throug e.g. HTTP
>whereas
>> UIDs must be resolved by ticle.
>> 
>
>This shows some great confusion as to what a URI is. A URI is NOT a URL.
>All a URI is, is a globally unique way of addressing anything on the
>planet that has a unique means of addressing. This includes books (via
>ISBNs), loaves of bread (via UPC), telephones (by their number) and much
>else besides. This are a globally stable means of doing this too. What
>one
>person labels a book won't change when another person looks at the
>triple.
>This allows easy sharing of graphs and true placeless content. By
>contrast, GUIDs by their nature, have a risk of clashing. This may cause
>some problems when sharing relations between zope installations and
>other
>information systems (a key requirement for many information systems
>buyers.)
>


Again you are right! :-)
This shows you are a true expert in reading W3C specs.

But I can not see why URIs are a unique way of addressing anything...

One book (exactly the same content) may have more than one ISBN. (Though this
does only happen a few times.)
Many different URLs may lead to the same information.
The same URL may lead to different information.

Please explain your view in more detail. 

>
>> 
>> 2. XTM/ISO TopicMaps and ticle (and RDF)
>> 
>> TopicMaps (in each flavour) are used to model semantics like RDF. The
>> big difference is, that RDF looks upon the world thinking: "Everything
>> is a resource." Wheras XTM looks upon the world thinking: "Everything
>is
>> a topic." Ticle on the other hand thinks: "Everything is a triple."
>> 
>
>No, RDF doesn't claim 'everything is a resource'. It models the world as
>a
>directed labelled graph. The labels are URIs (or in the case of object,
>can be a literal.) This is the minimum structure needed to attach some
>decent meaning.
>

You are right again! :-) RDF does not claim or "think" as I stated. I was
trying to put XTM, RDF and ticle in "contrast" without writing a book. To
show, what I think is the difference in the overall approach.

RDF, you have to admit, aims for describing resources, thus it puts
resources into the focus of interest.

XTM on the other hand aims for describing topics (ideas), which are not
necessarily related to any resource at all.

Ticle does not aim for anythingm, right now. It's just triples meaning
nothing. It is just an engine.


>
>> * You have to fully understand what you want to model. Sounds obvious,
>> but
>>   seems to be one of the big pitfalls. You must understand that there
>is
>>   more than one view of the world. In fact, the idea of one world is
>>   absurd! There are many worlds - accept it.
>>
>
>RDF already has standard mechanisms for negotiating amongst ontology by
>using OWL and RDF Schema inferencing.

I'm sure RDF has, but the problem I was refering to is probably not to be
solved by software. In fact I doubt it has anything to do with it.

I was referring to some of the underlying philosophical problems. 

1. An ontology may not share epistemical adequacy between different
persons, because different persons have different views of the world.

2. Different ontologies (I wonder if not necessarily ALL ontologies!) might
involve a problem Thomas Kuhn and Paul Feyerabend described as
"incommensurability". Thus making an automatical negotiation between
ontologies "unlikely" to work.



>> * You must understand the nature of semantics. Labels do not have
>>   semantics. Just because you name a topic or resource "table" it does
>>   not carry any semantics and it certainly has nothing to do with what
>>   we know a table is unless you provide relations and interpretations.
>> 
>
>Uh... semantics is JUST labelling and arcs. How the label is interpreted
>is often called pragmatics (I generally don't brook pragmatics as it is
>too often used as an excuse for intentionalism. Semantics is just a data
>structure that can be worked upon by simple algorithms.)

Hmmm... It looks as if this could be some language or definition problem.
I thought semantics is some sort of synonym for meaning.

The way I used 'semantics' here is the relation of an identifying string like
"table" to the thing it relates to. Or put it this way: the "meaning" of
_words_. In contrast to "meaning" in general, covering non-language related
meaning.

BTW: In my view pragmatics is the relation of a "speaker" to the utterance.
So often pragmatics also involves the situation and the intention of the
speaker.

If semantics were JUST labelling and arcs (= a data structure): 

1. A random construct of labels and arcs - taken from a dictionary, to make it
   more fun discussing it - that can be worked on by a simple algorithm has,
   in your view, meaning?

2. How about information and gaining cognition? Is a data structure telling
   you a thousand times that "dog" equals "dog" and being processed by an
   algorithm stating everything is true - carrying semantics?

3. How about epistemic adequacy? Does it make sense to build ontologies not
   beeing adequat to at least one person?


+++
stuff deleted
+++

Sebastian



-------------------------------------------------------
This SF.net email is sponsored by: IBM Linux Tutorials.
Become an expert in LINUX or just sharpen your skills.  Sign up for IBM's
Free Linux Tutorials.  Learn everything from the bash shell to sys admin.
Click now! http://ads.osdn.com/?ad_id=1278&alloc_id=3371&op=click