Re: XML and Lout already work well

[Valeriy E. Ushakov]

On Wed, Sep 19, 2001 at 17:52:04 +0100, address@hidden wrote:

> > This insane desire of many people to have everything look the same
> > is very dangerous and insidious.
> 
> Everything looking the same is what communication is about.

Communication is about mutual comprehension.


> Why do you use the roman alphabet when you could create your own
> letter shapes?

(with-generic-you

What about people that use other languages and non-latin alphabets for
their languages.  If *you* need to communicate with them, will you
refuse to learn their language and insists on them learning yours?
Or will you learn their tongue or hire an translator?

)



> A disadvantage of Lout is that it allows macros which allow 
> sloppy markup.

Lout definitely gives you enough rope to shoot yourself in the foot.
But then, any non-trivial system does.  Lout or LaTeX are not markup
langauges in the sense of SGML/XML, they are markup-like so that
structure is emphasized, but that's the standard packages that arrange
for this, not the core language.  Lout was not *designed* to be a
markup language, so it's not quite fair to make direct comparison.


> Eg it's common in Lout to do:
> 
> @PP A quick brown fox      (1)
> jumps over the lazy
> fox.
> 
> Where the role of @PP is confusing.
> 
> Of course, Lout could also allow:
> 
> @P {A quick brown fox      (2)
> jumps over the lazy 
> fox.}

BTW, it's macros that let you write:

    @ID {
    A quick brown fox
    jumps over the lazy dog.
    }


> XML requires you to do it the nice way, so if you like formal 
> things XML is very slightly better. BTW, I've always been puzzled 
> by Jeff's assertions in the doc that form (1) is better than (2).
> To me (2) is much clearer and pleasant than irrational (1) which 
> breaks the nice functional nature of the markup, but then 
> I'm the kind of person to always end my HTML paragraphs with </p>
> even when they're not required. Is it just me who thinks (2) is 
> better than (1)?

Human mind can deal with ambiguity and context-dependency pretty well.
Since paragraphs of text are, usually, the "meat" of your document, I
have no problem recognizing pargraphs without the {} around them.
Sort of default comprehension mode, and the {} would probably send me
strong signal that something unusual is going on that requires the
explicit grouping and hence my attention.

OTOH, for other elements I prefer to use {} even when it's not
necessary by the syntax, e.g. I prefer to write: @Heading { Hello }


> Uniform syntax allows you to use tools that understand that uniform
> syntax. Many tools whose semantics is language independent can be
> factorised thanks to a uniform syntax. It's not particularly world
> shattering but it's a real benefit. 

Basicly this boils down to "I don't have to write parsers over and
over again".  This is fine for, say, automatically generated
configuration files or interprogram exchange.  But humans often don't
need so much redudancy that XML provides.


> All the silly hype does not mean that the moderate benefits are not
> there.

All the moderate benefits that are there doesn't mean that I should be
exposed to all the silly hype :) (for any value of "there", be it XML,
OOP or java or whatever).


> Of course, there are some cases where that particular uniform syntax
> is not well suited.

Absolutely.  I'm not an anti-XML bigot, but what ticks me off is
universally quantified statements from "when all you have is a hammer"
department.

    "It would be nice to convert Lout to use XML syntax"
    "No, it wouldn't"
    "Oh, I see, you hate XML"

    "Shall I add some strawberry jam to your french fries?"
    "No, thank you"
    "Oh, I see, you hate strawberry jam"


> For Lout, it would probably be adequate for large parts of it.

Devil is in the details.

BTW, I'm *really* curious (no sarcasm) how you would wrap up in XML
this exmaple from the lout docs:

          USA        |0.2i Australia
    /0.1i Washington |     Canberra


> On the other hand, it's current syntax is perfectly appropriate for
> converting from XML. I markup my documents in XML and use XSLT to
> convert to Lout and this raises no significant problems.

QED.


> If you'd design a new typesetting system today, you'd probably 
> use XML at least for some markup,

Will you?  I mean, you'd probably design a typesetting systems that is
not intended for end-users and so any syntactic sugar can be safely
dropped and you can probably use XML throughout.  I could probably
quote another RISC assembler example (yes, you guessed right, I've
been doing quite a lot of asm programming recently :), but I think
it's rather obvious.



> but retrofitting it into Lout does not seem worth the effort

Not only that, but currently there are absolutely no resources to do
this anyway.  There are more urgent projects that I think are
important for Lout future (e.g. real i18n) and there's absolutely
no-one to work on it.  Even in the current low-profile mode Lout is
and will continue to be very useful to many people which proves that
Jeff did a superb job at it, but no significant progress is going to
happen unless there are engineering resources to do it.  Of course,
hacking PDF backend is probably much less fun then polishing some KDE
glitz, and for many people lout is just another tool down the pipe
(the shell one ;) that they can deploy and forget about (when was the
last time you hacked e.g. on your boot-loader or C compiler).

(Yes, I'm writing this with an unconcealed cynical desire to guilt
someone into actually contributing code, so that I can benefit from it
as well ;).

SY, Uwe
-- 
address@hidden                         |       Zu Grunde kommen
http://www.ptc.spbu.ru/~uwe/            |       Ist zu Grunde gehen