Re: S-expression I/O in Ada

[Natacha Kerensikova <lithiumcat@gmail.com>]

On Aug 14, 3:02 am, Yannick Duchêne (Hibou57)
<yannick_duch...@yahoo.fr> wrote:
> If you feel XML is too much heavy because it requires close  
> tag, then just think about it as the Ada's “end if”, “end case”, “end  
> loop” and so on. These closes tags enforce human readability and help  
> reliability in the sence that one always know what is starting and ending,  
> and a close-tag missmatch help to detect an error was done.

Well, I don't have strong opinions about closing tags. They do clobber
the screen, which is a negative point for readability, but in some
situation knowing what is being closed does help readability. So in
general I won't dare judging whether closing tags are helpful or
harmful. And in some very specific cases, the answer is clear: for a
20-character content without sub-objects, the closing tag doesn't
really add much value, while for a 1000-line unindented complex object
its help surely vastly overpowers its cost.

Now on the ease-of-implementation side, remembering the tag stack and
checking closing-tag match is surely much more complex than matching
any closing parenthesis. Adding a recovery mechanism makes
implementation even more complex (and violate XML standard, which is
the main reason behind my (irrational) hate of XML). This triggers the
question whether the indubitable benefits outweigh the complexity cost
(and back when I chose S-expressions the answer was clearly "no", but
I'm fully aware of how the answer can be different on large and
complex projects unlike mine).

> I you still feel XML is too much heavy, then just read this :http://quoderat.megginson.com/2007/01/03/all-markup-ends-up-looking-l...
>
> This demonstrate that as things goes, none of XML, LISP expressions or  
> JSon, none is more simple than the other, and LISP expressions or JSon  
> serializations just looks simple on very simple cases. When thing goes,  
> this is another story.

Surprisingly, my first reaction to the article you linked was more
along the line "wow, they managed to make S-expression as unreadable
as XML." rather than improving my view of XML.

However with a little reformatting (more line breaks and indentation)
the S-expressions from the article can look much more readable (at
least to my eyes). While I can't do the same thing with his XML, it
doesn't mean it's impossible. Moreover it's probable most XML I've
seen was not designed to be extremely human readable, while S-
expression I've seen are almost all mine, designed to be me-readable.
I guess it goes a long way into making to prejudice that XML is
unreadable.

> Did not wanted to make you change your mind (this idea is far from my  
> though), rather wanted to make you see there is no way to assert XML is  
> too much heavy of LISP expressions are more human readable (I have never  
> seen a readable LISP program by the way... I feel this is maid to be read  
> by machines, not human).

I agree I don't know anymore which is more human readable between XML
and S-expression. Still, XML is heavier to use in programs than S-
expressions, and I still take it for a fact.


Thanks for opening my eyes,
Natacha