Nix is a purely functional build system: it builds immutable artifacts from a description in a simple purely functional DSL. It is used on its own and as the basis for NixOS, a Linux distribution with a declarative configuration model. In this talk I’ll reflect on the successes and failures of the Nix DSL: why it makes sense to use a DSL over a general-purpose language, but also why a sufficiently powerful DSL turns out to be both a blessing and a curse.

Applicative functors and monads have conquered the world of functional programming by providing general and powerful ways of describing effectful computations using pure functions. Applicative functors provide a way to compose independent effects that cannot depend on values produced by earlier computations, and all of which are declared statically. Monads extend the applicative interface by making it possible to compose dependent effects, where the value computed by one effect determines all subsequent effects, dynamically.

Compilation time is an important factor in the adaptability of a software project. Fast (incremental) recompilation enables cheap experimentation with changes to a project, as those changes can be tested quickly. Despite the benefits of an incremental compiler, such compilers are usually not the default. Published research on incremental compilation often shows how to build an incremental compiler from the ground up, based on a programming language that is well-suited for such a compilation scheme. We have found in our own work that when the first compiler for a language is not incremental, and language features are not developed with that incremental compiler in mind, it can be hard to develop such a compiler at a later time. We address this problem by developing a compiler design approach that reuses parts of an existing non-incremental compiler to lower the cost of building an incremental compiler. The key idea on which we build our incremental compiler is that we use an incremental build system internally to wire together the components we extract from the original compiler. We demonstrate our design approach on the Stratego programming language.

Continuation marks enable dynamic binding and context inspection in a language with proper handling of tail calls and first-class continuations. The simplest and most direct use of continuation marks is to implement dynamically scoped variables, such as the current output stream or the current exception handler. By exposing continuation marks to users of a programming language, more kinds of language extensions can be implemented as libraries without further changes to the compiler. Our new implementation of continuation marks for Chez Scheme (in support of Racket) makes dynamic binding and lookup constant-time and fast and preserves the performance of Chez Scheme’s first-class continuations.

Part of the Symposium on Build Systems

All computers run software, such as operating systems, web browsers, and video games, which are used by billions of people around the world. Therefore, it is important to develop high-quality software, which is only possible through interactive programming systems that involve programmers in the exchange of correct and responsive feedback. Fortunately, for many general-purpose programming languages, integrated development environments provide interactive programming systems through code editors and editor services.