SBCL: A Sanely-Bootstrappable Common Lisp

  title={SBCL: A Sanely-Bootstrappable Common Lisp},
  author={Christophe Rhodes},
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… Expand
Bootstrapping reflective systems: The case of Pharo
A definition of bootstrap for object-oriented reflective systems is proposed, the architecture and components it should contain and the challenges it has to overcome are described, and a reference bootstrap process for a reflective system is presented. Expand
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. Expand
Preface Message from the Programme Chair
This paper describes 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 (circa 2010)Expand
A Portable, Simple, Embeddable Type System
We present a simple type system inspired by that of Common Lisp. The type system is intended to be embedded into a host language and accepts certain fundamental types from that language asExpand
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. Expand
Experience Report: debootstrapping the OCaml compiler
  • 2021
It is common for programming languages that their reference implementation is implemented in the language itself. This requires a “bootstrap”: a copy of a previous version of the implementation isExpand
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. Expand
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. Expand
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. Expand
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. Expand


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. Expand
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. Expand
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. Expand
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. Expand
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. Expand
The GCL ANSI Common Lisp Test Suite
I describe the conformance test suite for ANSI Common Lisp distributed as part of GNU Common Lisp (GCL). The test suite includes more than 20,000 individual tests, as well as random test generatorsExpand
Revised5 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 LewisExpand
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. Expand
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, aExpand
Revised6 Report on the Algorithmic Language Scheme
Scheme demonstrates that a very small number of rules for forming expressions, with no restrictions on how they are composed, suffice to form a practical and efficient programming language that is flexible enough to support most of the major programming paradigms in use today. Expand