Plan of work

It is very important that we plan a series of prototyping manouvers that can be carried out by a core of prototypers who have not committed time to the project yet.

If the prototypes are successful, then I expect that someone on the team will be willing to start real development of gnudl.

Here is a tentative list of prototyping actions that should be performed to gain some momentum on gnudl.

1. Get familiar with using guile as an extension language. [done, Mark Galassi, June 1995]
   • Writing a simple C or C++ program which sits in a read-eval loop, accepts expressions, checks if they are well-formed. Compare them to a list of built-in commands, and if they are built-in, execute them. Otherwise, pass them on to guile. [done, Mark Galassi, June 1995]
   • Extend the previous program to install some C builtin functions that can be called by scheme. [done, Mark Galassi, June 1995]
   • Write an elementary plotting package in native guile (probably via Gwish). [maybe not necessary any more]
   • Write an elementary plotting package in C or C++ using guile calls to use the Tk toolkit.
   • Write a C or C++ program which invokes a guile read-eval loop, and provides an interface to postscript which can be called by both C and scheme. [done, Mark Galassi, July 1995]
   • Take the previous prototype (which allows both scheme programming and postscript rendering) and write a set of routines in scheme to allow the basic operations (functions and operators operating on vectors, 2-D plotting, making it all work together smoothly...). [done, Mark Galassi, July 1995]
2. Try prototype implementations of the various subsystems.
   • Take the aforementioned elementary plotting package and make it store plots in postscript, and render them to the screen (either with calls to ghostscript or in some other way if that does not work).
   • Start implementing array operations: develop syntax so that an integer array can be used as an index into any other array. Also develop syntax so that scalar operations and functions can be applied to arbitrary arrays, element by element. The array library in slib seems like a good way of doing this, but the operations should be available from both C/C++ and scheme because some fast matrix operations might need to be implemented in C/C++.