Sam Davis
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 which will have the abstraction
capabilities of LISP in a more modern language setting.

	Languages based on the LISP model can abstract to a degree beyond other
languages, however LISP was originally developed in 1958 (published in 1960) and, 
as can be expected, has become outdated since. Sigma will be a modern version 
suitable for making applications. In this context, the word modern, can be taken 
to mean developments made in Python, Java, and C (more specifically the C model
of language): case-sensitivity, OS neutrality, and print formatting Obviously 
the research needed for the creation of a full-featured programming language 
extends into nearly every computer science field and beyond the capabilities of 
a two-person one-year project.. However, many of these topics can be compartmentalized 
into libraries that are not requisite to the core language. Essentially, the 
language created under this project will be a capable shell that can be added 
to as time and necessity dictate. Therefore, this project will only entail 
research into basic text parsing, variable and scope management, and garbage 
collection. Time permitting, other topics could include graphics, threading, and 
Internet applications.
	
	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 creation of Sigma will be in the following order: basic data structures,
a parser, variable and scope management, an evaluation function, garbage collection,
and Libraries. such as arrays, hashes, and numeric types. These stages of development 
will be divided equally between myself and my partner, Nick Alexander.
First, Mr. Alexander will write basic data structures (explained in more detail
in his paper) while I write the parser. The parser takes text and parses it into 
the appropriate Sigma Lisp S-expression. Following the completion of these 
sub-projects functionality tests will be run to ensure the data structures and 
parser work effectively. These tests will cover basic numerical manipulation, 
string manipulation, and mapping. The hailstone numbers problem, alphabetization
of single words, and one-to-one word translation tests will be used for this 
purpose. Obviously these tests will be evaluated on a pass-fail basis. 	
	However, at this stage the tests will be written in C, merely making 
use of the data structures and parser, because the actual language syntax will 
not yet exist. Building upon the first stage will be the implementation of variables and the 
evaluation function: the function that takes S-expressions and executes them. 
At this point the language will be a true language; capable of evaluating non-resource 
intensive programs written in Sigma LISP. The same tests as mentioned above will
be preformed again to ensure functionality, but this time written in Sigma LISP.
	
	The final portion of the project will be garbage collection, resource 
management, and libraries. Garbage collection will be necessary because dynamic
variable management is not feasible in LISP. Finally, upon completion of these 
tasks Sigma LISP will be ready to run a full-featured application, the details of
which have yet to be determined.
	
	This project will result in a dialect of LISP which should retain the 
benefits of LISP while modernizing the language to be more powerful and expressive. 
Hopefully this will add a powerful development tool to the serious programmer's 
toolkit allowing easier coding of more powerful applications. For example, Yahoo! 
Store was created originally in LISP and could be quickly modified and hosted 
on a website (a new idea at the time). Using Sigma LISP this kind of application
could be programmed more easily and cleanly.