XML is a real hype at the moment and even
Microsoft makes any attempt to promote it. This afternoon, I read some notice
about Microsoft XQuert Languages (or XQL for short) and went to a site dealing
about it. This languages hasn't been made into a standard yet, but it is clear
that Microsoft is promoting it. When I looked at the languages, I got the
strange feeling that something was wrong with it. The languages did not look
very clean to me, but rather as a mix of all kinds of rather arbitrary language
constructs. Somehow this also pointed the finger at some problems with XML
itself. XML itself is not very clean. It is really not what it pretends to be,
namely a way to convey self-contained structured data. One problem, I think, is
that it does not make any difference between sets and lists. Also, it only has
one basic data type, that of the string. Another problem is that it does not
explicitely specify how internal reference are made. Furthermore, it does not
have any good motivation on why attributes are needed, and when they should be
used. And as a last remark, I would like to add that the notation is rather
verbose for what it wants to express. It seems that the very old S-expression of
LISP can do the same that XML can do, but with much less characters.
To be honest, XML seems not to be a good candidate for an
international standard for exchanging structured data. I rightly admit it is
better than SGML and HTML, but I think it could have been much better yet.
(A good alternative and
Thoughts on software
enginering<.
Also read "http://www.sdmagazine.com/documents/s=740/sdm0009h/" XML in the Real
World
and "http://www.pault.com/pault/pxml/xmlalternatives.html" XML Alternatives.)
Meta-Meta
I have finally decided to make an attempt in materializing
all my ideas with respect to specification languages and implementation
languages as opposed to programming languages. I have called this project "Meta-Meta" just because I
cannot come up with a better idea. See my article "The Art of Programming" for
some of my ideas.
I haven't written out all of my ideas yet, but it seems that I do have the
following:
- A mathematical model to define types with pointers based on infinite
values.
- A type specification languages which has a simple mapping to the above
mathematical model.
- Some good ideas about adding qualifiers to this language to define an
update model.
- Some good ideas for making an "ideal" implementation for the
representation of complex values and how to perform updates on these values.
- An idea of how I could represent expression as values, and how these
expressions could be evaluated. (Very similar to old LISP.)
There are also still some unresolved issues:
- No formalisation of the update model.
- No proof that the "ideal" implementation is correct.
- Almost no ideas for an implementation languages.
- No tools.
Whenever you have a language, you need some parser. To
night, I have been thinking about how I could extend an interpreting parser that
I wrote some years ago, such that it will be able to link all the identifers and
such. It actually comes down to adding some additional information to the
resulting structures, and running a relatively simple tree walker, which will
perform all the neccesary stitching. I might have it return the representation
of expression that I talked about above. We will see!