Programming Language Projects
newLISP - a LISP Scripting Language
The newLISP Philosophy
newLISP intends to revive the LISP (LISt Processing) language invented by John McCarthy as mathematical notation for computer programs and implemented first as a programming language by Steve Russel in 1958 at MIT (Massachusetts Institute of Technology). LISP strived during the 60's and 70's in the fields of AI (Artificial Intelligence) and Computer Science. Many dialects and flavors where created during that time.After the AI Winter starting in the late 70's and subsequent standardization efforts (ANSI Common Lisp and SCHEME) the usage of LISP has steadily declined because of changes coming about through the invention of micro computers and the Internet.
Programming as an engineering craft has changed in its nature mainly because of the invention and common accessibility of the Microcomputer in the 80's and the popularization of the Internet since the 90's. Interpreted, easy to learn languages like BASIC gained enormous popularity during the early days of the microcomputer. Scripting languages invented in the UNIX world like PERL and PYTHON gained enormous popularity in the world of the Internet and related software.
newLISP delivers the dynamic nature of modern and easy to learn scripting languages combined with a modern API (Applications Programmer Interface), which is relevant for todays Internet related software applications. At the same time it retains classic core attributes and the aeshetic nature of LISP.newLISP can distribute computing tasks on multiple computers using just one function to control communications and collect results. newLISP interfaces with other software systems via shared software libraries and software pipes. It communicates with other computer nodes via TCP/IP and UDP network protocols using a high level API.
On modern multi-core CPUs newLISP offers a Cilk like API.
newLISP interfaces and cooperates with standards like XML for data representation and HTTP for network communications in distributed applications, instead of fighting them.
newLISP recognizes that programming has matured to be an industrial activity performed by engineers with average education and not an activity performed by a well educated elite.
newLISP relies on a minimum of theoretical concepts. It does not implement many of the paradigms and principles described by Computers Science and used in other esoteric computer languages. The LISP list is the basic paradigm for data and program structure; is enough to capture, represent and process the highest degree of complexity.
newLISP is very small and has built-in most of the technologies needed in today's networked and distributed applications. Tomorrows software systems are not contstituted by big monolithic system but small agile agents running and cooperating on distributed architectures. newLISP is small enough to run on embedded systems or distributed server farms built from thousands of small simple computer nodes.
newLISP recognizes the changing nature of progressing technology and constantly tries to adapt to it. Over the years the functionality found in newLISP has undergone many changes adapting to what is necessary at the time.
newLISP History
The origins of newLISP go back to 1991, when it was originally developed on a Sun4 workstation, then moved to Windows v.3.0. Version 1.3 of newLISP was released on Compuserve around 1993. At that time newLISP was available as a Windows 3.1 GUI graphics capable application and a DOS console application, both 16-bit). In 1995 with the release of Windows 95 newLISP moved to 32-bit.
In April 1999 newLISP was ported to LINUX rewriting some of the core algorithms and eliminating all Windows specific code. In 1999 newLISP was released as an Open Source project licensed under the GPL and development stopped on Windows after version 6.0.25. During the first half of 2001 newLISP was ported back to Windows again on to the CYGWIN platform and without graphics capabilities. A multi platform Tcl/Tk frontend named newLISP-tk was released around version 6.3.0, during the second half of 2001. In 2006 64-bit processing was introduced for integer math operations and some operations on files.
Beginning 2007 the first full 64-bit capable development version 9.0.14 was released, supporting the LP64 memory model and compilable on Linux X86, Tru64 UNIX and Solaris on Sparc.
Since the release of 6.5 in mid 2002 development has been very active, adding many new features and building a community of users. Since 2003 each year four or more major versions have been released. The current version 9.1 was released in February 2007.
newLISP contains many ideas contributed by its users and also some code from other Open Source projects. See the CREDITS file in the source distribution for details.
Timeline of Major Milestones in newLISP Development
| Version | Year | Changes and Additions |
| 1.0 | 1991 | First version running on Sun4 with SunOS/BSD 4.1 |
| 1.3 | 1993 | Windows 3.0 Win16 version released on Compuserve |
| 2.11 | 1994 | Windows 3.0 Win16 |
| 3.0 | 1995 | Windows 95 Win32 version |
| 6.0 | 1999 | Open Source UNIX multi platform, licensed GPL |
| 6.3 | 2001 | newLISP-tk Tcl/Tk IDE |
| 6.5.8 | 2002 | PCRE regular expressions |
| 7.1-4 | 2003 | Mac OS X and Solaris support. PDF manual, catch and throw, context variables, Win32 DLL |
| 8.0-3 | 2004 | Arrays, UTF-8 support, forked processes, semaphores, shared memory, default function |
| 8.4-7 | 2005 | Implicit indexing, comma locales, signals and timers, net-eval distributed computing |
| 8.8-9 | 2006 | Prolog-like unify, macro-like variable expansion, more implicit indexing support |
| 9.0 | 2006 | 64-bit arithmetic and file support, more array functions, HTTP server mode |
| 9.1 | 2007 | Full 64-bit compile flavor, HTTP/CGI server mode, functors in ref, ref-all, find, replace |
| 9.2 | 2007 | newLISP-GS a Java based GUI library for writing platform independent user interfaces in newLISP |
| 9.3 | 2008 | FOOP – Functional Object Oriented Programming |
| 9.4 | 2008 | Cilk - multiprocessing API implemented in newLISP |
| 10.0 | 2009 | General API cleanup, reference passing, new unified destructive API with setf |
| 10.1 | 2009 | Actor messaging API on Mac OS X, Linux and other UNIX |
| 10.2 | 2010 | FOOP redone with Mutable Objects |
| 10.3 | 2011 | Switchable Internet Protocol between IPv4 and IPv6 |
| 10.4 | 2012 | Rewritten message queue interface and extended import API using libffi |
| 10.5 | 2013 | Unlimited precision, integer arithmetic |
| 10.5.2 | 2013 | KMEANS cluster analysis |
| 10.5.7 | 2014 | newLISP in a web browser compiled to JavaScript with good performance |
| 10.6.0 | 2014 | native expansion macro function |
| 10.6.2 | 2015 | minor new functionality |
| 10.7.0 | 2016 | minor new functionality |
| 10.7.1 | 2017 | minor new functionality |
| 10.7.5 | 2019 | minor new functionality |
Since open sourcing newLISP in 2000, many users have contributed with ideas for new features. A big part of funtionality added since 2000 was prompted by users. See newlisp.org.
Other Mayor Language Projects
D.O. - Disk Oriented Language
D.O. was an interpreted language written first in 6502 Assembly for Ohio Scientific Micro Computers in 1980 then ported to the IBM-PC 8088 processor in 1982/83. Disk Oriented because subroutines could reside on disk in their own file and loaded or un-loaded on demand.
The language explored early versions of garbage collection free automatic memory management. The string-type was the major data type in this language. The language also featured arbitrary precision BCD arithmetik, leveraging BCD (Binary Coded Decimal) mode in the x86 family of microcontrollers.
The language was used to write an accounting system used by a few dozen companies in El Salvador. About 150 installations took place in the early 80's. The language had some similarities to LISP, SNOBOL and today's Tcl/Tk and was running on the early 1980's PCs, mostly floppy disk only.
The following manual text file is a partly corrupted WordStar file: http://newlisp.org/Projects/DOmanual.txt. Source: DO.ASM.
RuleTalk - A Rule Based Language
Was an interpreted language for Windows 3.0 with a Smalltalk like Windows hosted GUI/IDE and released in 1991. The language was reviewed in:
PC AI Magazine Volume 6.3, 1992 May/Jun page 52:
'RuleTalk, a rule-based OOP windows development'
Review by Ernest Tello
Another PC-AI article talks about RuleTalk's making:
PC AI Magazine Volume 6.5, 1992 Sept/Oct page 31:
Vendor's Forum: Interdata's Lutz Mueller:
'The development of RuleTalk, a high-level language'
RuleTalk understood formulas, in LISP like prefix, infix and RPN notation for arithmetik expressions, all at the same time. The language featured built-in multi tasking and used a precursor to newLISP's ORO automatic memory management. RuleTalk also had a drag and drop GUI builder and GUI object inspector modelled after Smalltalk. RuleTalk also featured name spaces similar to todays contexts in newLISP. The language was advertised in PC-AI but was not successfull beyond a few dozen packages sold.
Nomar - A JavaScript like Simulation and Internet Language
Nomar is an interpreted language written in Java 1999-2000 for Lumina Decision Systems, Inc., as an alternative implementation of Lumina's Analytica simulation software package. Nomar is JavaScript (ECMA script) compatible with extensions for array abstraction and Monte Carlo simulation. Array abstraction allows arithmetic and functional expressions to be left unchanged when scalar values in these expressions are replaced with arrays.
The language was initially named Goku Script. Keith Woolner from Lumina Systems came up with the name to Nomar (reverse of the Red Sox Baseball player Ramon, the language was demoed to simulate the outcome of baseball games using historical Baseball statistics collected by Keith) the name GokuScript was re-used in a later FORTH-language project.
Nomar features a built-in webserver and support for distributed computing. http://newlisp.org/Projects/Nomar-Reference.html. Nomar was built on an interesting Java based OO architecture: every function was an object with parse-, eval- and print methods for itself. Although I am not using Java anymore, I think it is the best language to teach object oriented programming.
GokuScript - A 32Bit FORTH Language
GokuScript is a FORTH language compiler written 1998 for a 6800 emulator/debugger running on the IBM-PC then ported to the 80386 in 1998/99. Two versions exist, a graphics enabled Windows version based on 'C' and TASM (Borland Turbo Assembler) and a LINUX version based on NASM (an open source ASM version). The following link is the manual for the LINUX version. This project was never released in public: http://newlisp.org/Projects/Gokumanual.html. Source: goku.asm.
GokuScript came with a standard library, could run a graphical version of Hanoi on Windows and was running very fast at about compiled 'C' speed. Development did not continue as FORTH syntax was perceived to hard to work with in the long run. Appart from the hard to read syntax this is one of my favourite languages, because of it's speed and small size.
The idea for the name GokuScript came from the 90's popular Japanese Cartoon series Dragon BAll Z. Goku was the main character in this series.
Other Minor Language Projects
- PC-Modem, communications program, language and configurable BBS system for the IBM PC in 1985 witten in 'C'.
- Hardware Script, a hardware control and test scripting language for debugging Video equipment circuit boards (AMPEX Corp. 1990/91)
- An unfinished Smalltalk Image in 8088/ASM Asembly 1990.
- An unfinished classic Prolog 1989/90 in 'C', this was a precursor to RuleTalk.
- Omega, an unfinished brain simulation language based on only word associations, 2004. This project will be picked up again, some time in the future, probably prototyped or integrated in newLISP.