Nick Alexander
Computer Systems Research
Pd 3
2005

Sigma LISP
   The goal of this project is the creation of a LISP dialect, called Sigma, 
suitable for large-scale application development.  Languages based on the LISP 
model have the ability to abstract to a degree beyond other languages, and Sigma
will be a modern version suitable for making applications.

	The research needed for the creation of a full-featured programming 
language extend into almost every computer science field.  However, most of these 
topics can be compartmentalized into libraries that do not necessarily have to 
be in the core language.  The language itself will require research into basic 
text parsing, variable and scope management, and garbage collection.  Other 
topics could include graphics, threading, and possibly web access.

	LISP was invented by John McCarthy in 1958 when he demonstrated that using 
only seven native functions (car, cdr, quote, atom, cond, eq, and cons) and a

notation for code as a tree of symbols, one could write an evaluation function 
for a language in itself.  Steve Russell, one of McCarthy's students, wrote the 
first interpreter for LISP. LISP in its current form did not appear until the 
creation of MacLISP at MIT,
with the addition of macros. Currently, there are two major dialects of LISP: 
Common LISP and Scheme. Both dialects, however, have problems stemming from the

time they were developed. Neither has case sensitivity, OS interaction, print 
formatting, or specific libraries that characterize the popular C model of 
programming language. Currently, LISP is, with a few notable exceptions, not 
used for large scale projects outside the AI realm. Most attempts at modernizing
LISP center on adding syntax, such as Paul Graham's proposed language Arc, or 
softening the infamous LISP S-expressions, such as in Dylan, however these 
approaches can make it more difficult to use macros, which is LISP's greatest 
strength.

	The first step in the creation of Sigma is the development of basic data
structures to store data.  Hashes and associative lists, as well as a unified type, 
Map, are used to map strings to objects, and are used for variable storage.  
Arrays, Cons's, and their unified type, Lists, are used to store the Sigma 
S-expressions and other data.  Long's are used to store arbitrary precision numbers, 
and Reals use two Longs to store rational numbers.  A new string format, with 
expanded characters to store Unicode and the length prefixed onto the string 
rather than indicated by null termination, thus allowing O(1) length finding, 
will be used as the native string type.

	The second step is the creation of a parser to translate code into equivalent 
Sigma S-expression for evaluation.  After this step, basic testing can begin.  
The data structures will be tested by using them to perform basic numeric computations, 
string manipulation, and mapping.  The parser will be tested by ensuring that 
it properly translates S-expressions.

	After the first round of testing, the next step in development will be 
the creation and implementation of a variable and scope managing model.  Once 
this is complete, the next step is to write a function to evaluate and execute 
S-expressions as code.  Once this is complete, Sigma will be a functioning 
language, capable of executing programs written in Sigma, as long as they are not
too resource-intensive, as their will be no way of reclaiming resources.

	Once the evaluation function is complete, another round of testing will 
begin.  Basic tests, this time in Sigma, will be used to ensure that Sigma is 
functioning properly.  The next step is the creation of a garbage collector to 
manage unreferenced resources, thus allowing larger programs.  Once this is complete, 
the final stage of Sigma development can begin with the creation of libraries,

as well as a system for loading exterior modules, written in C or Sigma.

	After this, Sigma LISP will be complete, as a final test, will be used to
write a full-featured application that demonstrates the abstraction power of 
Sigma LISP.  We have yet to decide on the nature of this application.

	The completion of this project will yield a powerful and expressive dialect
of LISP that can compete with modern languages.  This language would serve as a
powerful development tool that could bring LISP into mainstream use.  The expressive 
power of LISP already helps those who decide to use it, as demonstrated by Paul
Graham in his creation of Viaweb, which was purchased by Yahoo! for $50 million
and turned into Yahoo! Store.