NewLISP

Infobox programming language
name = Newlisp

paradigm = Multi-paradigm
year = 1991
designer = Lutz Mueller
developer = Lutz Mueller of Nuevatec
latest_release_version = 9.4
latest_release_date = July 1, 2008
typing =
implementations =
dialects =
influenced_by =
influenced =
operating_system = Cross-platform
license = GNU General Public License
website = [http://www.newlisp.org www.newlisp.org]

Newlisp (trade mark newLISP) is an open source scripting language in the Lisp family of programming languages developed by Lutz Mueller and released under the GNU General Public License.

History

Newlisp has its origin back in 1991 and was originally developed on a Sun-4 workstation, then moved to Windows 3.0, where version 1.3 was released on CompuServe around 1993. Newlisp was then available as a Windows GUI graphics capable application and a DOS console application (both 16bit). In 1995, with the release of Windows 95, Newlisp moved to 32-bit.

In April 1999, Newlisp was ported to Linux, some of the core algorithms were rewritten, and all Windows-specific code eliminated. 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. 64-bit precision was introduced for integer arithmetic and for some operations on files in version 9.0 in 2006.

Since the release of 6.5 in mid 2002 development has been very active: many new features have been added, and a community of users has grown.

Since 2003, four or more major versions have been released each year. The current version 9.3 was released in February 2008.

Philosophy

The aim of Newlisp is to provide a fast, powerful, cross-platform, full-featured scripting version of the Lisp programming language which uses only a modest amount of system resources such as disk space and memory.

Newlisp runs on the BSDs, GNU/Linux, Mac OS X, Solaris, and Windows operating systems.

Newlisp provides essential Lisp features such as lists, functions, symbol processing, recursion, function mapping, anonymous functions (lambda expressions), s-expressions (excluding improper lists), and macros.

Newlisp also provides all the functions expected of a modern scripting language, including support for regular expressions, XML, Unicode (UTF-8), TCP/IP and UDP networking, matrix and array processing, advanced math, statistics and Bayesian statistical analysis, financial mathematics, and distributed computing support.

The Newlisp installation provides support for MYSQL, SQLite and ODBC database access, CGI, SMTP, POP3, FTP and XML-RPC. Newlisp can also run as a daemon (server mode).

Newlisp aims for conservative memory requirements: on Linux a Newlisp process uses about 600KB of memory. The binary executable file occupies about 200KB of disk space on Linux.

With this combination of extensive built-in libraries and its modest use of resources, Newlisp is suitable for quick prototyping, system customization, server-side CGI scripting, and for use as an embedded scripting language.

The language aims to provide a simple, consistent, streamlined, Lisp environment that minimizes the learning curve and maximizes programmer productivity and pleasure.

For more information, refer to the [http://newlisp.org/index.cgi?FAQ newLISP FAQ] and the newLISP documentation referenced below.

The language

Contexts

Newlisp supports namespaces called "contexts". They can be assigned to variables and passed to functions, but they are associated with globally unique symbols, which limits their usage as first-class objects. A prototype-based OO style of programming is possible in Newlisp, using contexts as prototypes for construction of objects. Variables inside contexts do not interfere with variables of the same name in other contexts, but inside a context variables behave according to the rules of dynamic scoping.

coping

Newlisp uses dynamic scoping. Which means, when a function is called, it can see all variables of its caller and its caller's caller, and so on, within the same context or name space. Newlisp supports explicitly and implicitly defined local dynamic variables that shadow variables with the same name from the outer environment, so accidental use or change of the variables from caller environment - that can occure as a problem in simpler dynamic scoping systems like Common Lisp - is prevented. Parameter variables of the called function automatically shadow (overwrite) the callers variable environment. Globally, variables can be grouped in separate namespaces, named "context."

Memory management

Newlisp uses a method of automatic memory management different from traditional garbage collection schemes called "One Reference Only (ORO) Memory Management" (see [http://newlisp.org/MemoryManagement.html Automatic Memory Management in Newlisp] ).

Each variable is referenced only by its context, and each context is referenced globally.

Newlisp does not support sharing of subobjects among objects, cyclic structures, nor multiple variables pointing to the same object. Objects are (physically) copied when stored in data structures or passed to functions, except passing to particular builtin functions. The exceptions are symbols and contexts, which are not implicitly copied but shared, and thus they can be used for indirection. Symbols and contexts are globally named and are deleted explicitly; deleting a symbol or context scans all other objects to replace references to it with nil.

GUI options

The Tcl/Tk version of Newlisp provides a graphical interface, using Tcl/Tk. So if using Newlisp for GUI programming, a working knowledge of Tk is assumed. It can also work with the GTK-server.

tand-alone binaries

It is possible to construct executable files for deployment using any version of Newlisp. These files are self-contained and require no installation.

Interaction with shared libraries

Newlisp has an import function, which allows importing function from DLLs (Dynamic Link Libraries) on Win32 or shared libraries on Linux/UNIX (see [http://www.newlisp.org/CodePatterns.html#extending Code Patterns in Newlisp] ).

External links

* [http://www.newlisp.org newLISP Home Page]
* [http://newlisp.org/index.cgi?Documentation newLISP Documentation]
* [http://newlisp.org/MemoryManagement.html Automatic Memory Management in newLISP]
* [http://newlisp.org/index.cgi?page=Differences_to_Other_LISPs Differences to other LISPs]
* [http://alh.net/newlisp/ NewLISP Fan Club]