Check out the new USENIX Web site. next up previous
Next: The Nickle Implementation Up: Nickle: Language Principles and Previous: Omitted Features


Nickle began life around 1985 at Reed College as ec, a compiler written by Packard for translating arbitrary-precision arithmetic into high-performance interpreted byte code. In addition, around that time, both authors were experimenting with the design and implementation of Kalypso, an interpreter (and later a compiler) for a purely functional dialect of LISP. Inevitably, the desire for LISP-like numerical expressions with C-like syntax led to the construction of ic, an ``interpreted C'' which also incorporated concepts borrowed from earlier work by Packard and others at Tektronix, Inc. on incremental C and Pascal compilation.

The original ic was a pure tree-walking interpreter with arbitrary-precision integer and rational datatypes allocated and destroyed statically. This allowed the memory management issues to be finessed. Incremental compilation was one of the first enhancements, and was accompanied by new datatypes which necessitated a reference-counted memory management scheme with a custom storage allocator.

By about 1993, accumulated incremental changes prompted a complete reworking of the ic implementation. The reference-counted storage management was replaced by a tracing mark-sweep collector (borrowed from another of the authors' projects, a functional LISP subset implementation known as Kalypso), first-class functions were added, and the syntax and semantics of the language were revised somewhat. The resulting language was known as Nick. Later additions included first-class continuations, threads, and, by about 1996, namespaces.

In the last 6 months, the static type system has finally been implemented, the platform-native floating point representation has been supplanted by a platform-independent arbitrary-precision implementation,4 many builtins have been added, the disjoint union type has been added, the user interface has been improved (including support for GNU readline), the documentation has been largely completed, the examples have been collected and regularized, a multitude of bugs and misfeatures have been repaired, and other improvements too numerous to list have been made. The result is Nickle as it exists today.

A few months before the public source release, only minor changes were planned, except for the implementation of polymorphic type inference. As the release was finalized, it became clear that the polymorphic type inference system would have to wait: the features described in the previous paragraph became clear priorities and absorbed all of the available time of both authors. The lesson here is clear and, in retrospect, obvious: the first 90% of Nickle development took 15 years, and the remaining 90% took the last three months. The result appears, so far, to be worth the work: Nickle has never been faster, more stable, or more pleasant to use.

The first public source release of Nickle was in mid-April of 2001. As of the first week since it was announced on, about 100 copies have been downloaded. So far, there have been no bug reports, and contributions have already been made to the project by users who helped with creating alternative binary packages for the distribution.

Nickle was designed to be highly portable within the UNIX environment: so far, that goal appears to have been met. Prerelease, it was compiled on a variety of UNIXes with no problems. GNU autoconf was invaluable here: while difficult to use, it does its intended job admirably.

next up previous
Next: The Nickle Implementation Up: Nickle: Language Principles and Previous: Omitted Features
Bart Massey 2001-04-19