W3C home > Mailing lists > Public > w3c-wai-er-ig@w3.org > July 2001

Re: EARL 1.0

From: Charles McCathieNevile <charles@w3.org>
Date: Sat, 14 Jul 2001 16:39:00 -0400 (EDT)
To: "Sean B. Palmer" <sean@mysterylights.com>
cc: <w3c-wai-er-ig@w3.org>
Message-ID: <Pine.LNX.4.30.0107141622110.6786-100000@tux.w3.org>
Hang on a second...

On Sat, 14 Jul 2001, Sean B. Palmer wrote:
  One of the most important steps was defining it in RDF. Although
  misunderstood by so many, RDF had the potential to let us create a
  model however we wanted, and also a syntax in which people could
  express the model. When N3 came along, it helped tenfold for people to
  express what was going on. But is RDF really the answer? Tools like
  CWM have shown that general Semantic Web processing tools can get the
  EARL jobs done... but CWM is it. It's the only Semantic Web tools
  available that's worth anything, and it's demonstration code.
Err, are you sure?
  So what alternatives are there? There's straight XML. We already know
  that that is just XML with a layer of abstraction that will make it
  practically impossible for us to agree on anything. Meta *models* are
  more important than meta syntaxes. Syntax is a pain, but it's not
  important in the design phase. The model is everything.
The model is most of it. A syntax that is portable, easily handled, widely
recognised does make a difference. That was the reason for promoting XML RDF
syntax as the primary syntax.
  UML is one suggestion. This would allow the OOP programmers amongst us
  to come up with class bases and code to enable people to process EARL.
  It would also still link in with RDF. However, I don't really know the
  first thing about implementing UML and what that entails (which should
  not stop ERT from pursuing it).
If the ERT group is going to implement it, then it might be worth pursuing.
But if it is just another model that we could use, or another syntax that we
could use for our model, then it seems like a waste of time.
  ... But did we stop to question if the context => { content result
  criteria } is the most efficient way of going about it? Of course not, we
  just stuck with it and ended up with 0.95.
Actually, we have questioned the model as well. And we have questioned the
way that context is applied (I still hold that it is an open issue). And the
expression above is not what we had in earl 0.9 as a method of expressing
things, where there was an extra layer of indirection everywhere.
[long snip]
  For example, in EARL 0.95 we said:-

  :Sean :asserts { :MyPage :passes :MyTest } .

  Using this strawman (which should not be referred to as EARL 1.0 -
  this is an intermediary state), it would be more like:-

     :Sean :asserts :x .
     :x :s :MyPage; :p :passes; :o :MyTest .
So the differnce here is that in N3 you have made the first statement
explicitly an "anonymous node" (i.e. one without a URI), and have implied
that the second one is not (there is no proof here either way). I agree that
the assertions should not be anonymous nodes, and using XML syntax they
aren't - they can be identified by Xpointers.
  Actually, that brings me back to the status of EARL. I've always
  wondered just what on earth EARL is? Is it just some experiment by the
  ERT WG? Then again, it's nice that the process doesn't matter. I feel
  quite free to say anything, experiment anyhow, and contribute as much
  or as little as I want without process getting in the way. I can say
  things which would be considered quite bizarre in other circles, and
  yet they're often paid serious attention, attention that is thankfully
  deserved in many cases.
The goal of working on a model and a vocabulary was that there are a number
of developers who are doing the same, to put into real tools. The scenarios
to support are important to people in the real world. or example, the
authring process, where it is useful not to have to check the same thing 8
times just because there is no way of recording the results of a test, or
because it was done using teh XML format particular to some other kind of
tool that was used by the previous author/editor of a page.

I think it is clear that we need to play with implementations before we
freeze EARL 1.0, and unfortunately these take some time to generate. That is
what I understand is a major part of the work, along with documenting in
language that normal people can understand (like a few simple pictures) what
this thing is.

Received on Saturday, 14 July 2001 16:39:02 UTC

This archive was generated by hypermail 2.3.1 : Tuesday, 6 January 2015 21:01:32 UTC