RE: [Axiom-developer] latex and noweb

[Bill Page]

On May 4, 2007 10:48 AM Tim Daly wrote:
> 
> I'd suggest we think about pamphlets as a domain and think
> about what operations make sense in the domain.
> 
> I'd suggest we move up a level in the design. We need a
> couple tools with crisp definitions. This would allow us
> to decompose and recompose a pamphlet file. Then we can
> use these functions to define lisp, spad, or aldor code
> that plays with pamphlet files in the same way.

Now, in spite of how I concluded my previous email, I do
very much agree with this approach suggested by Tim! Pamphlet
files (or more generally perhaps literate programs) should
be accessible as objects in Spad and even the Axiom interpreter
even though this creates a potentially complicated bootstrap
problem. The amount of Lisp required to implement this should
be little or even none. As Axiom developers I think we should
first of all begin coding at as high a level as possible,
meaning Spad/Aldor and not always starting from the ground
up.

Keeping the noweb for now and working at this higher level
makes very good sense to me. Eventually we may get to the
situation where something like this could be implemented in
a more integrated manner.

> 
> Then we could write "algorithms" to do the various processing.
> For instance, Ralf could write a code-decoration algorithm
> that post-processes the nodes that represent code and adds
> font, color.  In general, every user could have their own
> use for pamphlets.
>

This is not so different than what is called the "document
object model (dom)" in HTML processing. Dom is what makes it
possible to use Javascript for all the neat things that people
do so easily in dynamic web pages - as Tim suggests in his
pseudo-code below.
 
> We could run who-calls on the lisp code and add that information
> as a special section.
> 
> We could write an index node that gets added to the document
> with information we preprocess. Thus we could cross-reference
> with links.
>

This makes good sense as a kind of evolution of the "database"
concept that underlies the Axiom library.
 
> We could decorate code nodes with "next code block"
> hyperlinks. Thus you could walk the nodes in "code" order.
> 
> We could hyperlink bibliographic entries to other pamphlets
> or to outside sources.
> 
> We could use these functions interactively either behind the
> scenes in a web-serving axiom or directly in user )help
> requests
>

+1 Yes.
 
> 
> 
> Pamphlets() == 
>   parse(pamphlet) -> graph
> 
>     take a pamphlet structure and generate a graph of that
>     structure. the graph would allow us to identify parts of
>     the pamphlet as nodes. each node would contain the text
>     and some start/end/type information.
>     for example, the preamble, the body, the postamble.
>     within these other nodes could be recognized as needed
>     and made reachable. this is similar to the document
>     format idea in javascript.
> ...

I like that.

Regards,
Bill Page.