SBCL: A Sanely-Bootstrappable Common Lisp

  title={SBCL: A Sanely-Bootstrappable Common Lisp},
  author={Christophe Rhodes},
  booktitle={Self-Sustaining Systems},
  • Christophe Rhodes
  • Published in Self-Sustaining Systems 15 May 2008
  • Computer Science, Economics
This paper describes the development of an implementation of Common Lisp with the peculiarity that it is bootstrappable neither solely from itself, nor from some other language, but rather from a variety of other Common Lisp implementations. We explain the motivation for this bootstrap strategy, discuss some of the technical details involved in achieving it, and attempt to assess the technical and social effects that it has had on the development of the implementation and on its user and… 

Bootstrapping reflective systems: The case of Pharo

Resolving Metastability Issues During Bootstrapping

Satiation is described, a technique by which metastability issues can be turned into bootstrapping issues, thereby simplifying them and keeping the code elegant.

Preface Message from the Programme Chair

The technical details of the process of porting SBCL (Steel Bank Common Lisp) to IBM Blue Gene/P, making it the first Lisp implementation to run on a modern peta-scale supercomputing platform, are described.

A Portable, Simple, Embeddable Type System

A simple type system inspired by that of Common Lisp is presented, intended to be embedded into a host language and accepts certain fundamental types from that language as axiomatically given.

A bootstrapping infrastructure to build and extend Pharo-like languages

This paper presents a novel bootstrapping infrastructure for Pharo-like languages that allows us to easily extend and modify such languages and shows how it can bootstrap with minimal effort two other languages with similar execution semantics but different object models.

Experience Report: debootstrapping the OCaml compiler

    Computer Science
  • 2021
A naive interpreter that can interpret the OCaml compiler, and a naive compiler that can compile the authors' interpreter are built, able to prove the absence of trusting trust attack in the existing O Caml bootstrap.

Generalizers: New Metaobjects for Generalized Dispatch

A new metaobject is introduced, the generalizer, which complements the existing specializer metaobject, and this metaobject allows for the efficient implementation of complex non-class-based dispatch within the framework of existing metaobject protocols.

Factor: a dynamic stack-based programming language

The Factor language has a simple execution model and is based on the manipulation of data on a stack and an advanced metaprogramming system provides means for easily extending the language.

Virtual Smalltalk Images: Model and Applications

Oz is presented, a virtual image solution that solves the edge cases of reflective architectures by adding a third participant, and thus, removing the selfmodification and self-observation constraints.

A comparison of implementations of basic evolutionary algorithm operations in different languages

This paper has tested three basic evolutionary algorithm operations over binary chromosomes: bitflip mutation, crossover and the OneMax fitness function and the results confirm that compiled languages scale and perform better, but also in some cases have a behaviour that is independent of the size of the chromosome.

User-extensible sequences in common Lisp

The notion of user-extensible sequences is introduced, describing a protocol which implementations of such classes should follow, and the issues observed in providing support for this protocol in a Common Lisp, including ensuring that there is no performance impact from its inclusion.

Custom Specializers in Object-Oriented Lisp

The implementation and use of custom specializers in two current dialects of Lisp: Skill and Common Lisp are described, motivating the need for such specializers by appealing to clarity of expression, referring to experience in existing industrial applications.

The art of the Metaobject Protocol

A new approach to programming language design is presented, which resolves fundamental tensions between elegance and efficiency, and a metaobject protocol is presented that gives users the ability to incrementally modify the language's behavior and implementation.

Design of an optimizing, dynamically retargetable compiler for common Lisp

The components of a retargetable cross-compiler for the Common Lisp language are outlined, and a breakdown is shown of the compiler itself into various machine-independent and machine-dependent modules.

CMUCL User's Manual

CMUCL is a free, high-performance implementation of the Common Lisp programming language, which runs on most major Unix platforms and features a sophisticated native-code compiler, a foreign function interface, a graphical source-level debugger, an interface to the X11 Window System, and an Emacs-like editor.

The GCL ANSI Common Lisp Test Suite

The conformance test suite for ANSI Common Lisp distributed as part of GNU Common Lisp (GCL) includes more than 20,000 individual tests, as well as random test generators for exercising specific parts of Common Lisp implementations.

Revised4 report on the algorithmic language scheme

The report gives a defining description of the programming language Scheme. Scheme is a statically scoped and properly tail-recursive dialect of the Lisp programming language invented by Guy Lewis

CommonLoops: merging Lisp and object-oriented programming

It is argued that CommonLoops' small kernel is powerful enough to implement the major object-oriented systems in use today, and its extensive use of meta-objects make practical both efficient implementation and experimentation with new ideas for object- oriented programming.

Back to the future: the story of Squeak, a practical Smalltalk written in itself

Squeak is an open, highly-portable Smalltalk implementation whose virtual machine is written entirely in Smalltalk, making it easy to. debug, analyze, and change. To achieve practical performance, a

Composable and compilable macros:: you want it when?

MzScheme---the language of the PLT Scheme tool suite---addresses the problem of mingling through a macro system that separates compilation without sacrificing the expressiveness of macros.