Re: S-expression I/O in Ada

["Yannick Duchêne (Hibou57)" <yannick_duchene@yahoo.fr>]

Le Sat, 07 Aug 2010 09:23:01 +0200, Natacha Kerensikova  
<lithiumcat@gmail.com> a écrit:
> I think text-based format is very useful when the file has to be dealt
> with by both humans and programs. The typical example would be
> configuration files: read and written by humans, and used by the
> program. And that's where I believe XML is really poor, because it's
> too heavy for human use.
I use XML near to every day, I use to write in the raw text editor named  
PSPad, without any troubles. A lot of people write HTML (which like XML is  
a kind of SGML), for years some people wrote in Docbook document modal,  
which again come from SGML. XML can be as simple as S-Expressions are,  
providing you avoid using attributes (if you really feel you do not need  
such a thing). 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. These all miss  
 from S-Expression (do you know what LISP was named after by the way ? ;) )

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-like-xml/

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.

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).


-- 
There is even better than a pragma Assert: a SPARK --# check.
--# check C and WhoKnowWhat and YouKnowWho;
--# assert Ada;
--  i.e. forget about previous premises which leads to conclusion
--  and start with new conclusion as premise.