[SCL] Approach to a concrete syntax

[Tanel Tammet]

Murray Altheim wrote:

> I see absolutely no reason to believe that there's any difference
> whatsoever in XML vs. RDF/RDFS in avoiding these issues. The same
> issues for RDF/RDFS exist, and in fact are complicated by the fact
> that RDF/RDFS brings with it its own set of semantics which are not
> the same as SCL.

The basic approach to semantics in Pat's RDF semantics paper is the same
as in the SCL draft.

Considering the RDF-friendliness: it seems that usability in some
combination with RDF/RDFS is crucial in THIS project. Otherwise
there simply wouldn't be this project. We have had FOL for ages, no
need to invent new syntaxes for FOL (ie anybody can invent new syntaxes
for FOL in their spare time as a hobby, but this is not an interesting
activity for a serious group of people). When I wrote the XML-in-SCL
draft I did consciously avoid thinking about the RDF issues, considering
it just too EARLY, not unimportant. Wanted to have some discussion
as we have had. Just that this discussion has run its course and has become
less interesting than it initially was.

Considering the complications you refer to: I'd rather not try to solve
all the possible complications there are and may appear in the future.

I'd rather try to look at the simple and clear parts and avoid solving
the complexities. Potential users won't understand complexities.
Only simple things are OK for widespread usage. Any unnecessary
terminology should be avoided. Etc. Just look at HTML: it became
popular since it (a) was trivial (b) did not try to solve the complexities
people had attempted to solve before (in Xanadu or SGML) (c) there
were REAL, FREE APPLICATIONS implementing the stuff.
Similarly, look at CORBA. Tries to solve a lot. Hugely complex. Hardly 
usable
in mainstream. XML-RPC or SOAP, while solving a lot less, are
realistically usable in everyday apps.

IMHO all these three things are crucial. Just let us avoid overextending
our scope in a groupwork (fine to overextend in private, though :-).

Regards,
          Tanel Tammet

PS: privately I think that RDF, while simple, is still a bit too complex
(NOT because of the XML syntax option: XML itself is nicely simple)
Would have been nice if people had manage to suppress the urge
to extend the basic core in various ways. But one can survive by avoiding
some parts of it. If you do not believe me, try teaching RDF in one hour
to newbies (of course most of the people on the SCL group have taught
it a LOT to both newbies and specialists). What happens with newbies is 
that you do
manage to explain the core but do not manage to explain all the bells 
and whistles.
The newbie context is critical, not the specialist context.