Re: [Axiom-developer] Axisp news

[Stephen Wilson]

Hello Martin,

Martin Rubey <address@hidden> writes:

> Dear Stephen,
> 
> Just to make sure: I hope Ralf and myself have not discouraged you from your
> work on SPAD. 

Oh no, not at all.  I _greatly_ appreciate the input from both of you.
In no way have I taken anything as being even remotely discouraging.

> However, I think it would be more promising to try to make SPAD
> converge towards the Aldor language:
> 
> * Aldor (the language) is relatively well understood - thanks for recalling 
> the
>   article by Poll and Thompson, by the way
> 
> * Aldor (the language!) proved useful (even if not fully implemented) and
>   sufficiently stable

I wrote the parser to be mostly-compatible with Spad for two main
reasons.  First, the building of the parser itself gives me detailed
insight into how Axiom represents the source input as an AST.  This is
critical for understanding the rest of the compiler.  And finally, the
the grammatical variations between Spad and Aldor are quite small.
Pile mode and the use of `(' and ')' as opposed to `{' and `}' to
delimit code sequences are the primary differences.  Most Aldor
constructs, but not all, are `backwards compatible' with Spad.

So, the syntax is not so important.  The parser is a tool for hacking
the compiler at the moment.  I can modify it easily to accept `Aldor'.

> Maybe it is not as "sexy" to try to implement a language specification, but I
> assure you, it would help a lot if you made some progress here.  Personally I
> made the experience that I do not have the talent to design a new language, 
> but
> using Aldor, I sometimes see how one could go on.  (To make this more precise:
> I really want to work with Tuples as first class citizens, for example.  Also,
> I would like to be able to check -- some sort of -- equality of domains at
> times, even if impossible in general.)

The basic list of items I will incorporating are:

   1) Dependent types.  This may not be 100% compatible with Aldor.
      But when I get the the point of needing to make some decisions I
      will most certainly be asking for everyones feedback.

   2) Anonymous functions, e.g. +-> in aldor.

   3) Exceptions.

   4) Generators.

> Maybe I can propose some projects:
  [...]
> Maybe one of these projects is for you,

The stated goal of the Axisp branch is to rewrite the compiler and
interpreter in Lisp.  So its not so much a question if _one_ of those
projects are for me.  They _all_ are.

Clearly this is ambitious, but it even extends beyond just language
features.  For example:

    * I want the design to be modular and extensible.  In particular,
      I want to ensure that interfaces exist so that one can use and
      change the behavior of various components.  The notion of the
      `crystal', a more ambitious undertaking then what I am working
      on, will primarily drive the requirements in this respect.

    * Related to the last point, I am looking at ways to define
      domains/categories in a natural way at the lisp level.  This
      would give a canonical representation which is immediately
      available to the programmer without having to go through
      Spad. In other words, I want to ensure the notion of domain and
      category is throughly decoupled from a source code
      representation, and ensure they can be handled gracefully as any
      other kind of Lisp code/data.

    * One of the next sub-projects is to implement a testing framework
      based on one of the many unit-testing tools available to Lisp. I
      want to ensure that all aspects of the system are checked.

    * Literate documentation.  Going through the existing code and
      documenting it fully in an artful way would be almost as great a
      challenge as the task I am taking on.  My hope is that we get
      literate code almost `for free' as a consequence of the
      rewrite.

So, I am really advocating a vision for Axiom as a whole.  But the
means by which I am going to advance these notions is by writing the
code, by making it happen.

As far as I can predict, when this work has reached a usable state, I
have no doubt that the compiler will accept a language very similar to
Aldor.

Martin, Ralf, many thanks for your input and thoughts.  They are
terrifically important to me and greatly appreciated!


Sincerely,
Steve