Subject: It's about Reading -- not Writing...

From: "Bob Wyman" <[email-masked]>
Date: Wed, 18 Aug 2004 11:20:37 -0400

If a message is written but never read, was anything communicated?
If a tree falls in a forest...
	Atom and syndication are about communication - the authors of
entries have rhetorical intent. Thus, the standard and formal rules of
rhetoric apply. Speakers, or writers, are responsible for understanding the
warrants (i.e. prior knowledge, etc) of their audience -- and they are
responsible for speaking or writing in a language that their audience can
understand. Speakers are *constrained* by their audiences to limit their
speech to that which can be understood. If the speaker doesn't accept the
constraints, then communication doesn't occur. If there is a failure to
communicate, it is the responsibility of the speaker -- not the audience.
	RDF may contribute, as Dan Brickley says, "a strategy for
decentralizing vocabulary design." However, the goal of the Atom effort is
to contribute a "strategy and means for communicating information." The
problems of designing vocabulary and of employing vocabulary (communicating)
are distinct.
	The RDF camp seems enthralled by the glory of being able to easily
*express* a vast range of ideas with what is, at its core, a very simple set
of rules. However, we've learned over and over that RDF is more often
written then read. Non-RDF XML is the language of readers -- not RDF. The
reason is simple... RDF gives so much freedom to the writer that that reader
has little hope of understanding what is written. What one can understand
about something written in RDF is often no more meaningful then the examples
that Danny Ayers provides elsewhere. (e.g. Some unknown thing is said to
have a property which has unknown, but named, properties and that something
is said to have some undefined relationship to some other unknown thing...
How is this useful?)
	If one is communicating in a small group it is reasonable to utilize
private vocabularies -- to produce "jargon" as it were. Small groups do this
constantly -- with our without RDF. But, if you wish to communicate to a
large group then, in order to *communicate*, you must express yourself with
a broadly understood and more rigorous language. The opportunity for variety
and creativity in message construction is reduced as the size the audience
increases.
	The key challenge of Atom is, I believe, to enable speaking to large
audiences. Thus, Atom should focus first on the problem of providing a well
and rigorously defined vocabulary that can be shared efficiently by a large
audience. Atom should be optimized for communications. I believe that this
means that Atom should rely on rigorously defined XML -- complete with
schemas, etc. 
	RDF is certainly a useful tool for "vocabulary design" and can be
very effective in small, closely-coupled groups -- thus, RDF can be useful
to those who are experimenting with and designing early vocabularies that
might later be formalized for broad use. In some small groups, the focus of
communications is so limited that such formalization may not ever be
justified or even necessary. Given this, I think Atom should provide a means
to encapsulate RDF within its XML -- to enable experimentation and
communication within fringe groups. 
	However, once a vocabulary has been "designed" as a result of small
group RDF use, it simply doesn't make sense to continue using RDF. Once the
vocabulary, or its core, has become fixed and well understood, the
flexibility of RDF becomes both a burden (because of bulk, parsing
difficulties, etc.) as well as unnecessary to communicate those things that
have been formalized. Thus, *formal* extensions to Atom, intended to be used
by the broad market, should be defined rigorously in as non-RDF XML.
	Insisting on XML as the format for broad audience communication does
nothing to limit the RDF people. As shown by GRDDL[1], you can convert
easily between XML and RDF. The RDF-folk can view the whole world as RDF if
they want... On the other hand, insisting on well and rigorously defined XML
for Atom will make it much more likely that the users of Atom will be able
to accomplish their communications goals -- because they will have agreed
upon common vocabularies with some sense that their audience, *the readers*
of Atom files, will understand.
	The Atom extensibility mechanisms should address at least two
concerns:
	1. Adding additional "standard" elements that are expected to be
understood by *all* or a large number of Atom readers.
	2. Providing the flexibility needed by vocabulary designers, small
groups, and others who require or desire non-standard vocabularies.
	The mechanisms which are most appropriate to handle the first
concern are probably not the same as those which are most appropriate for
the second.
	Please remember: It's about reading -- not writing...

		bob wyman

---

From: Henry Story <[email-masked]>
Date: Wed, 18 Aug 2004 20:50:29 +0200

I added the RSS1.0 feed Dan Brickley mentioned earlier [1] to JNN, my 
news reader and it read it very well.

If you use Protégé it can read any OWL file and even create forms to 
help people fill them out, even though it is only a machine, and has 
nothing more to go on than a bunch of rules.

If people mix vocabularies that are not of interest to many people then 
they will soon find out.  The best vocabularies will win in a process 
of natural selection. Atom gains by being able to work on the core of 
what it is good at, without having to solve every other problem out 
there too.

It does not matter if Atom does not use RDF in the end. It is easy to 
do: so someone will. Atom itself evolves in a world of standards which 
go though a process of natural selection.

The question was: what does atom bring to the table that RSS did not 
(other than a better name of course)? If Atom wants to be something big 
then it should work with the rest of the world, in a distributed 
manner. Then it will leverage the best thinkers around the world. 
Otherwise it is just a slightly better Arse feed.  And though it might 
be a standard on paper, people may well wonder what the big deal about 
it was.

Henry

[1]  http://www.nature.com/naturejobs/jobs/biologicalsciences.rdf

On 18 Aug 2004, at 17:20, Bob Wyman wrote:

> [...]

---

From: Danny Ayers <[email-masked]>
Date: Thu, 19 Aug 2004 15:09:38 +0200

> problems of designing vocabulary and of employing vocabulary (communicating)

True, but one is dependent on the other.

> has little hope of understanding what is written. 

RDF is a versatile model in which information can be expressed, when
passed from place to place communication can take place. But RDF/XML
is more tightly constrained than XML in general.

What one can understand
> is said to have some undefined relationship to some other unknown thing...

You can make comparisons between things without knowing everything
about them. You can make simple inferences to fill in the gaps, making
maximal use of whatever information is available. An approach such as
RDF inference may not be any more useful in a particular situation
than not using partial information, but discarding information can
never more useful than extracting what you do understand.

Do you know how you would get from your house to mine? Probably not,
but you know how to figure it out from the available information.

> a broadly understood and more rigorous language. 

I agree with the point in the context of machine languages, but it's a
stretch to say English (for example) is rigorous.

The opportunity for variety
> means that Atom should rely on rigorously defined XML -- complete with

I agree. The problem is that if extensions are required, then there
needs to be some kind of commonality (rigour) beyond what
XML+namespaces alone offers.

> justified or even necessary. 

This seems a strange way of looking at it - RDF can be just as useful
for working on web scales too.

Given this, I think Atom should provide a means
> by the broad market, should be defined rigorously in as non-RDF XML.

So you are in effect proposing one single, growing, megalanguage (with
RDF as a kind of prototyping system). I'm not optimistic about that
approach to scaling.

> of Atom files, will understand.

I don't really disagree, having core Atom as non-RDF XML isn't really
much of an issue.

> concern are probably not the same as those which are most appropriate for

Couldn't a scalable, modular mechanism cover both? 

>         Please remember: It's about reading -- not writing...

There has to be something to read, surely..?

Cheers,
Danny.