"Summer: Symbolics greets the idea of a 'standardizing' with much support. Noftsker in particular deems it desirable to have a common dialect on the Vax through which potential LispMachine customers can be exposed to Lisp. Moon pushes for a name, which by default seems to be heading for CommonLisp. GLS produces the 'Swiss Cheese' edition of the Spice Lisp manual." [Jon L White: Roots of "Yu-Shiang Lisp", 24 August 1982]
See also: Spice Lisp User's Guide. 9 November 1983.
See also: Spice Lisp User's Guide. August 28, 1984.
The published version of the Common Lisp Reference manual. The title page notes "with contributions from Scott E. Fahlman, Richard P. Gabriel, David A. Moon, and Daniel L. Weinreb."
"In a fit of optimism that usually does not characterize him, Gabriel approached the Xerox Interlisp group, and received a warmer welcome than he did in Berkeley, but he left with only an indication that someone, probably Bill VanMelle, would attend the meetings, mostly as an observer." [Steele and Gabriel 1993]
"The last ten years have seen both a boom and and bust for the Lisp language. From its inception in 1958 until its commercialization in 1980, Lisp was content to live a life of academic obscurity, servicing the needs of Artificial Intelligence, theorem proving and symbolic algebra researchers. In this role, Lisp could explore many new ideas and quickly absorb new ideas from the programming language 'mainstream'. However, when AI became a business, Lisp was drawn to the money like a moth to the flame. Lisp quickly sought to become 'industrial strength', and ANSI Common Lisp was the result. Unfortunately, 'industrial' quickly became 'rust belt', as the newly standardized Common Lisp could not quickly grow and adapt to the new, more "open" environment.
In Lisp's quest for industrial respect, it abandoned its traditional customers. Symbolic algebra developers (e.g., Maple, Mathematica) forsook Lisp for the more portable and efficient C. Logicians gave up Lisp for Prolog and ML. Vision researchers, seeking the highest performance from parallel computers, dropped Lisp in favor of C, Fortran (!) and various fringe parallel languages. AI companies were forced to move their expert systems into C, C++, Ada and Cobol (!) because of the large size, poor performance and poor integration of Common Lisp systems. Academicians teaching undergraduates chose Scheme and ML for their small size, portability and clean semantics."
"Most of the work [designing Common Lisp] was carried out by E-mail discussion. These discussions were captured in file archives. One research at the Sloan School at MIT has used these archives to study computer-mail-based decision-making and interaction. [Steele and Gabriel 1993]
"CLtL1 was the output of a hastily united group of MacLisp successors, who felt InterLisp group was stronger than they were. They did not dream of international matters or even of commercial interests. Most of them thought it is just a US academic research matter: most of them did not know how to make international standards, or even American national standards."
"There has been a new wave of interest in Common Lisp over the last few years. This paper is a November, 2007 (updated February, 2010) survey of Common Lisp implementations that are currently being actively maintained. It also provides references to writings about why Lisp is interesting and important, Lisp textbooks, and useful Lisp resources including repositories of available libraries."
See also:
CMU Common Lisp (CMUCL)"CMUCL was developed at the Computer Science Department of Carnegie Mellon University. The work was a small autonomous part within the Mach microkernel-based operating system project, and started more as a tool development effort than a research project. The project started out as Spice Lisp, which provided a modern Lisp implementation for use in the CMU community. CMUCL has been under continual development since the early 1980's (concurrent with the Common Lisp standardization effort). Most of the CMU Common Lisp implementors went on to work on the Gwydion environment for Dylan. The CMU team was lead by Scott E. Fahlman, the Python compiler was written by Robert MacLachlan." [CMUCL credits]
"Companion to Common Lisp: The Language"
"Steel Bank CL (SBCL) forked from CMU CL in December, 1999. The fork was initiated by William Newman. The system is named after the industries where Andrew Carnegie and Andrew Mellon, respectively, made fortunes.
The original goal of the fork was to produce a version of CMU CL that was easier to build and to maintain. After the fork, SBCL diverged from CMU CL, and as can be seen in this survey there are significant differences between their feature sets these days. While SBCL and CMU CL still share a lot of common code, few changes to one system are ported over to the other. Due to this and the different development philosophies, it can be expected that the implementations will continue to diverge.
The CLOS implementation is based on PCL, but has been substantially modified. The compiler generates reasonably good machine code: good for low-level number crunching as well." [Weinreb 2010]
Source codeCharles L. Hedrick and J. Storrs (Josh) Hall developed a Common Lisp for the DECSYSTEM-20 running TOPS-20 at Rutgers University during 1983-1985. This system was based on Carnegie-Mellon's Spice Lisp, but used an assembly language kernel whose "interior design is sort of a cross between the Spice machine and Elisp, the Rutgers extended-addressing version of UCI Lisp" [Hedrick 1985]. The Spice system code, which is the portion of the runtime written in Lisp, was used with only minor modifications to deal with representation dependencies. The Spice compiler was modified to generate code for the DECSYSTEM-20.
The version of the kernel and Lisp code exhibited here contains bug fixes and improvements by Björn Victor, Per-Erik Martin and others at Uppsala University, Sweden, and also by Peter Samson at Systems Concepts, San Francisco, California.
The Flavors code was adapted for Common Lisp from Spice Lisp Flavors by Torbjörn Åhs and Björn Victor at Uppsala University. Spice Lisp Flavors was adapted by Steven Handerson from Symbolics Flavors. Symbolics Flavors was designed by Howard Cannon and David Moon.
clisp.tps.gz was processed by uncompressing it with gzip, then running
split_tap < clisp.tps, which produced three output files, and finally runningread20 -C -f out02.dat -xto process the actual TOPS-20 saveset.
"This document is adapted from text written primarily by David Moon and Daniel Weinreb which appeared in the Lisp Machine Manual, fourth edition, chapter 20, copyrighted by the Massachusetts Institute of Technology."
Stoyan includes a document with these authors and title as Spice Document S226, 1983.
"In 1984, Coral Software began the development of a Common Lisp for the Macintosh, called Coral Common Lisp (CCL). Three years later, CCL 1.0 was released. It ran on a 1 MB Macintosh Plus.
Subsequently, Coral entered into a marketing relationship with Franz, under which CCL was renamed to Macintosh Allegro Common Lisp (MACL). That didn't last long, and in late 1988, Coral was acquired by Apple, who released the Lisp under the name Macintosh Common Lisp (MCL).
In 1994, in the midst of switching from the 68K to the PowerPC CPU for its Macintosh line, Apple transferred MCL to Digitool. Digitool completed the PowerPC port and released a PowerPC version of MCL around 1995.
Erann Gat (now known as Ron Garret) of JPL wanted to develop a small-footprint Lisp for use on PowerPC-based robots and flight systems. A source license for MCL was acquired from Digitool, and in 1998, Gary Byers ported a version of the MCL compiler and runtime to VxWorks and LinuxPPC. In 2001, Digitool agreed to open source the work that had been done at JPL, and OpenMCL was born.
In 2007, Alice Hartley of Digitool announced that the code for the original MCL would be released under an open source license. Largely in order to avoid confusion with this newly open sourced version of MCL, OpenMCL was renamed to Clozure CL. As a bonus, this makes the name of the primary implementation package and the default installation directory name ("ccl") meaningful again.” [Clozure CL History]
"Open source version of the Macintosh Common Lisp development environment. Works on Intel and PPC computers with MacOSX 10.4 and up, including MacOSX 10.6 'Snow Leopard'.
...
Thanks to Digitool for releasing MCL as open source and to Clozure for updating it to work on Intel and Snow Leopard." [Project home page]
See history of
Clozure Common Lispabove.
Kyoto Common Lisp (KCL)"A new player from Japan – Kyoto Common Lisp (KCL) – provided a bit of a spoiler: KCL has a compiler that compiles to C, which is compiled by the C compiler. This Lisp was licensed essentially for free, and the Common Lisp companies suddenly had a surprising competitor." [Steele and Gabriel 1993]
"Kyoto Common Lisp (KCL) is a highly portable and implementation of Common Lisp originally developed at Kyoto University in Japan. KCL conforms to CLtL1."
ECoLisp / ECL / ECL-Spain / ECL / Embeddable Common Lisp (Università di Pisa)"Austin Kyoto Common Lisp (AKCL) is a collection of ports, bug fixes and improvements to KCL written by Bill Schelter. {A}KCL generates C code which it compiles with the local C compiler."
"To build AKCL, one must also have in place the sources for KCL. At the time one builds AKCL, one automatically merges AKCL changes with the KCL sources, which are left unmodified, in accordance with the KCL license."
"ECL (Embeddable Common-Lisp) is an interpreter of the Common-Lisp language as described in the X3J13 Ansi specification, featuring CLOS (Common-Lisp Object System), conditions, loops, etc, plus a translator to C, which can produce standalone executables.” [https://common-lisp.net/project/ecl/main.html]
"Embeddable Common Lisp, a member of the KCL Family, is a Common Lisp implementation initially developed by Giuseppe Attardi, maintained for many years by Juan Jose Garcia-Ripoll and currently maintained by Daniel Kochmański. ECL is the successor to EcoLisp.” [https://www.cliki.net/ECL]
The long and complex history of ECL is described in this section of the manual.
Source code"ManKai Common Lisp is a member of the KCL Family through its ECL branch. MKCL is a quite complete ANSI Common Lisp implementation, mainly developed by Jean-Claude Beaudoin at the moment.
MKCL features, in its permanent configuration, a number of significant extensions like multi-threading, FFI and Unicode support, along with a good set of prepackaged libraries: CFFI, Babel, alexandria, FiveAM, Bordeaux-Threads, ASDF, SLIME and more." [MKCL at CLiki]
"GCL is the product of many hands over many years. The original effort was known as the Kyoto Common Lisp system, written by Taiichi Yuasa and Masami Hagiya in 1984. In 1987 new work was begun by William Schelter, and that version of the system was called AKCL (Austin Kyoto Common Lisp). In 1994 AKCL was released as GCL (GNU Common Lisp) under the GNU public library license. The primary purpose of GCL during that phase of its existence was to support the Maxima computer algebra system, also maintained by Dr. Schelter. It existed largely as a subproject of Maxima.
After the passing of Dr. Schelter in 2001, it was decided that GCL should be actively maintained and improved. GCL is currently maintained by a team of 12 developers across the world coordinated via the gcl-devel mailing list." [GCL History]
"CLISP is a Common Lisp implementation by Bruno Haible, then of Karlsruhe University, and Michael Stoll, then of Munich University, both in Germany. It supports the Lisp described in the ANSI Common Lisp standard plus many extensions.
CMUCL's CLOS implementation is derived from the PCL reference implementation written at Xerox PARC. Its implementation of the LOOP macro was derived from code from Symbolics, which was derived from code written at MIT. The CLX code is copyrighted by Texas Instruments Incorporated. " [CLISP Common Lisp Summary]
See Butterfly Lisp in Parallel Lisps section.
SPUR LispSee
SPUR Lisp, which was a Common Lisp derived from
Spice Lispand extended with features to support concurrency on the SPUR multiprocessor workstation at the University of California at Berkeley.
Corman Common LispCorman Common Lisp was originally a commercial product, but Roger Corman stopped developing it and released under an open source MIT license in 2015. He had previously released the source for his Macintosh product, PowerLisp.
"Corman Lisp is particularly focused on Windows on the Intel archicture. It features a native code compiler for Intel processors, 80x86 assembler and disassembler, incremental linker and multi-window text editor. It is fully integrated with the Win32 API, and all the Windows API functions are readily available from Lisp.
Corman CL was designed and implemented by Corman Technologies, since 1995. Previously they developed PowerLisp for the Mac, but Corman CL was a complete rewrite for Windows. (PowerLisp is no longer developed or supported). They have developed and maintained Corman CL continuously, with new major releases approximately every 18 months (and minor updates more often). The CLOS implementation was originally from Art of the Metaobject Protocol Closette, and then extensively rewritten to add missing Common Lisp features and to improve performance." [Weinreb 2010]
"PowerLisp 2.02 is being released with complete source code (the entire product, including editor, can be built from scratch). This product is free for personal use. For commercial use, please contact us at admin@cormanlisp.com. A more complete license is being developed and will be posted here when available."
Source code"Poplog is an integrated toolkit providing a highly extendable collection of languages and tools for teaching, research and development. It is described on Wikipedia here. By default it includes incremental compilers for three powerful AI programming languages which can be used interactively both when learning to program and when developing software:
- Pop-11--the core language -- used to implement itself and the others;
- Common Lisp; and
- Prolog;
as well as
[What is Poplog?]
- Standard ML, a widely used functional language."
From the APPLY project, which also participated in EuLisp.
"CLiCC is a Common Lisp to C Compiler. It generates C-executables or modules from Common Lisp application programs. CLiCC is intended to be used as an addon to existing Common Lisp systems for generating portable applications. CLiCC supports a strict and very large subset CL0 (Common Lisp0) of Common Lisp + CLOS.
CLiCC is not a Common Lisp system. The generated C code, although human readable, is not primarily intended to be maintainable in C, hence, CLiCC is not a translator. The target language is a subset of C. CLiCC is adaptable to generate ANSI- or K&R-C. A standard C compiler, e.g. the GNU gcc, can be used on the target machine to generate stand alone executables or linkable modules.
CLiCC itself is a Lisp application. It has been developed using Franz Allegro Common Lisp 4.1. However, it does not require Allegro to run. Other Lisp systems including CLISP, GCL (AKCL) or CMU Common Lisp will do. The forthcoming release 0.6.5 will run under Allegro 4.3 as well. Moreover, CLiCC should compile itself to C. Unfortunately, this is impossible at present. As this bug is not yet fixed, release 0.6.2 has to be used in order to produce a stand alone compiler. " [Project page via archive.org]
By Jim Allard at Gensym, later released as open source.
"ThinLisp is an open source Lisp to C translator for delivering commercial quality, Lisp-based applications. It implements a subset of Common Lisp with extensions. ThinLisp itself is written in Common Lisp, and so must run on top of an underlying Common Lisp implementation such as Allegro, MCL, or CMU Lisp. The C code resulting from a translation can then be independently compiled to produce a small, efficient executable image."
ThinLisp is not a typical Lisp implementation in that it does not implement a garbage collector or many of the other run-time development features of other Lisps. ThinLisp is designed for producing high quality deliverable C libraries and executables from Lisp sources. Originally designed for real-time control applications, ThinLisp stresses run-time performance at the expense of some development time conveniences. This is exactly the opposite design philosophy from many Lisps, but that's what makes this one thin!
ThinLisp is the current generation (4th) of a series of Lisp to C translators used to deploy a large Lisp system (1 million lines) built starting around 1990." [README]
"Originally started to be a scripting language for the J editor, it now supports JSR-223 (Java scripting API): it can be a scripting engine in any Java application. Additionally, it can be used to implement (parts of) the application using Java to Lisp integration APIs.” [Project home page]
"ABCL was originally the extension language for the J editor, which was started in 1998 by Peter Graves. Sometime in 2003, a whole lot of code that had previously not been released publically was suddenly committed that enabled ABCL to be plausibly termed an emergent ANSI CommonLisp implementation candidate.
From 2006 to 2008, Peter manned the development lists, incorporating patches as made sense. After a suitable search, Peter nominated Erik Hülsmann to take over the project.
In 2008, the implementation was transferred to the current maintainers, who have strived toimprove its usability as a contemporary Common Lisp implementation." [User Manual]
Peter Graves.
"XCL is a new native-code implementation of Common Lisp. It features a kernel written in C++ and an optimizing compiler written in Lisp with backends for x86 and x86-64.
XCL runs on Linux, FreeBSD (tested only on x86, but it might work on x86-64 too), and 32-bit Windows." [README]
Control Data Corporation Common Lisp"Allegro Common Lisp was originally called Extended Common Lisp, first released in 1985. It is written in itself, and we used Franz Lisp (another dialect of Lisp that Franz used to sell in the 80's) to bootstrap the new implementation.
The compiler and runtime system were written from scratch, but some of the interpreter came from CMU's Spice Lisp. Our CLOS implementation was originally based on Xerox PCL. The interpreter and CLOS implementations were rewritten over the first few years of the product's life. An extensive history of Franz, Inc. can be found at http://franz.com/about/company.history.lhtml. The principal founders of Franz were Fritz Kunze, John Foderero, and Richard Fateman. John Foderero, the original primary architect at Franz, is still there as Chief Scientist." [Weinreb 2010]
"Following CDC ALISP lineage for a moment, ALISP [at University of Massachusetts Amherst] was eventually replaced with work on a native Common Lisp that was headed by Richard Hudson." [Dan Corkill, personal communication, September 4, 2010]
"The Lisp/VE team was led by Richard L. Hudson and consisted of David M. Hart, Susan E. Lander, Andy Podgurski, Mali Anand, and Joanne Pommers. the compiler and runtime was written by the Lisp/VE team primarily in Lisp and a language called Cybil (Cyber Implementation Language). It leveraged a lot of the CMU Spice Lisp code to implement many of the Common Lisp functions and libraries. It faithfully implements the Common Lisp dialect and was available commercially as part of CDC's Cyber 180, the last machine CDC built." [Richard L. Hudson, personal communication, September 10, 2012]
"I think it was also the first full implementation of Pitman's condition system (I recall Susan exchanging a lot of question/clarification emails with Kent during that time.)" [Dan Corkill, personal communication, September 10, 2012]
"Implementation Strategy
In order to bring up a Common Lisp system quickly, a small, internal Lisp system was used to import much of the code from the Spice project at CMU. While a good deal of the code was used as it was, some important sections were changed significantly. For example:
- a third pass was added to the compiler, and all code gen- eration is delayed until then,
- a LAP (Lisp Assembly Program) language was designed that was more appropriate for the MV machines than the Spice byte-codes originally emitted by the compiler,
- the source-to-source transformation capabilities of the compiler were enhanced,
- arrays, numbers, and I/O, among other things, were reimplemented." [Oldman 1985, page 76]
"This documentation is based on COMMON LISP: The Language, written by Guy L. Steele, Jr., and published by Digital Press (copyright 1984 by Digital Equipment Corporation), 30 North Avenue, Burlington, MA 01803. The original work constitutes the sole specification for COMMON LISP and any departures from that standard are the sole responsibility of Data General Corporation."
"Subject: Public Domain VAX LISP
Return-Path: <FAHLMAN@C.CS.CMU.EDU>What we could give you is Spice Lisp, developed here for the Perq computers and in the public domain. This is essentially Common Lisp written in Common Lisp and a Common Lisp compiler, written in Common Lisp, that produces a special Lisp-oriented byte code that is executed by custom microcode on the Perq. We also have an Emacs-like text editor written in Common Lisp, and some assorted utilities and demos. There's a design document describing the internal organization and defining the byte codes.
What various manufacturers, including DEC, have done is to take our sources and modify the code generation modules of the compiler to produce native code for their machine. Most of the byte codes turn into a few native-code instructions on something like a Vax. The more complex ones turn into quick jumps to hand-coded subroutines, probably written in assembler: bignum arithmetic, building and taking apart stack frames, GC, lowest-level operating system interfaces, and so on.
To build a system, you then run the modified compiler on some system that already has a Common Lisp, compile our whole body of Lisp code, link in the hand-coded stuff, and if you've done it all right the Lisp comes up in its full glory, ready to go. It is possible to get a reasonably fast implementation by this route, though it takes a good deal of thought and tuning to get the data formats and calling conventions just right.
Veterans of our implementation effort have done this port to a new architecture in as little as six man-months ... under optimal conditions. A more realistic time scale for someone starting from scratch on this would be two good wizards working six months to get something turning over, and another six months or a year to get the thing up to full speed and product quality. That's for a straightforward port ... All of the sources add up to 3 or 4 megabytes...
Since you ask about Vaxlisp, it is the result of the same process described above, and the work was done here at CMU by DEC employees and by me as a consultant to DEC. The result is owned by DEC and we can't give it to anyone.
-- Scott" [Scott Fahlman via AIList Digest, Volume 4, Issue 117, 9 May 1986]
"The VAX LISP language is an extended implementation of the COMMON LISP language defined in COMMON LISP: The Language. In addition to the features supported by COMMON LISP, VAX LISP provides the following extensions:
[User's Guide, Chapter 1]
- DCL (DIGITAL Command Language) LISP command
- Extensible editor
- Error handler
- Debugging facilities
- Extensible pretty printer
- Facility for calling out to external routines
- Facility for defining non-LISP data structures (alien structures)
- Facility for defining interrupt functions (that is, functions that execute asynchronously)
- Window and graphics support for the VAXstation II workstation"
The manuals in this section are a gift of Beryl Nelson to CHM.
Lucid Common Lisp (now Liquid Common Lisp)"LispWorks is produced by LispWorks Ltd.
Development began in Cambridge, England in 1987 and continues there today. The various owners have been: 1987-2000 Harlequin, 2000-2004 Xanalys, and 2005-present LispWorks Ltd.
The CLOS implementation started out as a branch of PCL (Portable Common Loops)." [Weinreb 2010]
Scieneer Common Lisp (SCL)"I founded Chestnut and produced the first version of the Lisp-to-C translator, which covered a small subset of Common Lisp, for in-house use in 1989. Chestnut was working on A.I.-flavored applications, particularly a natural-language engine, that we wanted to code in Lisp -- but had to deliver in C, mostly for memory compactness. Since the C code would at some point be maintained, and there were Lisp-agnostic C programmers on the project, we wanted the code to be as clean and clear as possible. Soon after, we discovered that there was a significant demand for the translator itself. The company's encounter with the market, beginning in 1990, was quite a shock: We assumed that customers would adapt their Lisp code to use our Common Lisp subset, to explicitly garbage-collect, etc. We wound up implementing all of CLtL2, including CLOS, and created several translation modes, one of which was fully automatic; local variables were saved on a stack so that they could be recognized as roots for garbage collection. A good number of large Lisp projects were coming to fruition at about the same time, and had to deliver in C for various reasons: portability; to work with multilingual teams; performance and memory footprint; and general fears about Lisp as a language. Many of them became Chestnut customers.
The project benefited greatly from the work of a small group of Lisp internals experts, including several members of the ANSI Lisp (X3J13) standards committee, which had codified Common Lisp only recently. Kim Barrett wrote all of the CLOS translator; Sandra Loosemore designed the translation engine and optimization framework; Jonathan Rees wrote much of the runtime library; he and James O'Toole, both MIT grad students, wrote several very fast garbage collectors, did a good deal of optimizing, and worked on portability; Andy Latto, Dmitry Nizhegorodov, Jeff Brodie, and Rick Harris made major contributions. Jim Allard, then with Gensym Corp., had built a translator for Gensym's use that Chestnut eventually replaced, and already had a lot of good engineering ideas that were incorporated into the product.
The translator was a pricey product: the company provided customers a good deal of support, and for customers who wanted readable C code that was also fast, compact, and portable, didn't really have any competitors. Our customers' best alternative was usually to spend several million dollars, and a year or two, reimplementing their applications in C. So Chestnut was able to find a niche, which grew as the company expanded its marketing efforts and as the amount of pre-sale engineering work it needed to perform for each customer drastically fell.
The company went out of business in 1995, several years after I left. ...
Its technology was sold to Oracle for use on a single development project. It's possible that an approach by the Lisp community would persuade Oracle to release the software as open source. Or Gensym, now based in Texas, might consent to its release. It would take some legwork and luck. In its favor are the passage of time and the re-emergence of Lisp as a platform.
The closest heir to Chestnut's technology seems to be Thinlisp, about which more above. Led by Jim Allard and Ben Hyde, it starts with some of the same design philosophy as Chestnut and focuses on the engineering virtues that, in the developers' experience, were most critical to a successful "develop in Lisp, deploy in C" engine." [Bill Brodie, comp.lang.lisp, 28 January 2009]
"Scieneer CL is produced by Scieneer Pty Ltd of Australia. The current version is 1.3.7. There is one primary developer.
It is a fork from CMU CL, with improvements focusing primary on high-performance scientific computing.
Scieneer Pty Ltd was formed in March 2000 to develop and support a professional Common Lisp implementation for Symmetrical Multi-Processor (SMP) systems which is a key requirement for many high performance computing and enterprise applications.
The company was founded by Douglas Crosher, who was a developer of CMU Common Lisp. He was responsible for the x86 port, the generational garbage collector, the multi-processing support, and other enhancements." [Weinreb 2010]
The Scieneer web site became unresponsive sometime after September 2017.
See also:
http://linuxfinances.info/info/commonlisp.html via archive.org Applications Computer algebra"Axiom has been in development since 1971. At that time, it was called Scratchpad. Scratchpad was a large, general purpose computer algebra system that was originally developed by IBM under the direction of Richard Jenks. The project started in 1971 and evolved slowly. Barry Trager was key to the technical direction of the project. Scratchpad developed over a 20 year stretch and was basically considered as a research platform for developing new ideas in computational mathematics. In the 1990s, as IBM's fortunes slid, the Scratchpad project was renamed to Axiom, sold to the Numerical Algorithms Group (NAG) in England and became a commercial system. As part of the Scratchpad project at IBM in Yorktown Tim Daly worked on all aspects of the system and eventually helped transfer the product to NAG. For a variety of reasons it never became a financial success and NAG withdrew it from the market in October, 2001.
NAG agreed to release Axiom as free software. The basic motivation was that Axiom represents something different from other programs in a lot of ways. Primarily because of its foundation in mathematics the Axiom system will potentially be useful 30 years from now. In its current state it represents about 30 years and 300 man-years of research work. To strive to keep such a large collection of knowledge alive seems a worthwhile goal."
"Maxima is a descendant of DOE Macsyma, which had its origins in the late 1960s at MIT. It is the only system based on that effort still publicly available and with an active user community, thanks to its open source nature. Macsyma was the first of a new breed of computer algebra systems, leading the way for programs such as Maple and Mathematica. This particular variant of Macsyma was maintained by William Schelter from 1982 until he passed away in 2001. In 1998 he obtained permission to release the source code under GPL. It was his efforts and skill which have made the survival of Maxima possible, and we are very grateful to him for volunteering his time and skill to keep the original Macsyma code alive and well. Since his passing a group of users and developers has formed to keep Maxima alive and kicking. Maxima itself is reasonably feature complete at this stage, with abilities such as symbolic integration, 3D plotting, and an ODE solver, but there is a lot of work yet to be done in terms of bug fixing, cleanup, and documentation. This is not to say there will be no new features, but there is much work to be done before that stage will be reached, and for now new features are not likely to be our focus." [About Maxima]
The Boyer-Moore theorem prover pioneered the approach (also used by ACL2) of using "home-grown dialect of Pure Lisp" as a logic language, and also uses a regular Lisp as an implementation language.
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4