Tim Daly <d...@axiom-developer.org> writes:
>
>Antony Blakey wrote:
>> The essence of the PLT model is the language integration that
>> allows symbol resolution by reusing the language mechanism for the
>> documentation.
> 
> "Language integration" is a false goal. It is technically possible
> to call functions in any language from latex but unnecessary in
> general.

Language integration is a very concrete goal.  If you look at the PLT
(which I'll refer to as Racket blow) documentation, you'll see the
result of this integration wherever code appears, bindings are
rendered as links to the place where they're defined.  This is not
something that you can easily do, more so when you have an environment
like Racket where certain names are bound by several modules.  In
Scribble, this integration means that the *same* facility that is used
to resolve module names and link bindings is also used in the
documentation system.  In other words, when you use `foo' in a piece
of text, you import its definition in the same way that you do so in
code -- and the system makes sure that it is rendered accurately.


> It is technically possible to generate latex from any language.

(That's trivially true for any language that can print text.)


> Symbol resolution is also rarely an issue in literate programs.

That's very much understating the benefit of how Scribble deals with
bindings.  Take for example a page from a page that was rendered by
the scribble literate programming tool:

  http://docs.racket-lang.org/games/Breadth-first_Search.html

Reading such code where every identifier is linked to its
documentation makes this a much more effective document.

Note also that the Scribble literate programming library is not the
main focus of the system (or the main focus of the paper).  Unlike
dealing with bindings, which is one of the key aspects of Scribble, in
all forms.


> Your prose is intended to explain "why" a code chunks exists, not
> "how" a code chunk works. If you explain the problem you are trying
> to solve and the issues of various approaches you considered then I
> can usually understand the solution.

(Coincidentally, I dislike literate programming as a paradigm exactly
because it creates a strong focus on the "how" part.  The fact that
the code should all be in the document means that I'm forced to talk
about all kinds of below-the-api technicalities that are irrelevant
for most users of my code.)


> Choosing the right approach matters. It is technically possible to
> write clojure code in Microsoft word but utterly painful since MSWord
> does not have a programming focus. It is possible to write a book in
> PLT Scheme but painful for the same reason.

I've read your followup, but this really makes me think that you
didn't read the paper.  Writing a book in Racket using Scribble is
extremely close to writing one in latex...

> If your intention is to write a literate program, which as Knuth
> defined it, to be a piece of literature, use a tool designed for
> literature.

...and more to the point: the default mode of writing in Scribble
(again, whether you're using the literate programming library or not)
is writing marked-up text.  It is very much a tool that is designed
for literature.

-- 
          ((lambda (x) (x x)) (lambda (x) (x x)))          Eli Barzilay:
                    http://barzilay.org/                   Maze is Life!

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Reply via email to