The Vanilla project was an experiment in language design, intended to test two hypotheses:
- To what extent are programming languages composed of independent sub-features that can themselves be independently described and composed?, and,
- If this is so to a large extent, is it possible to build effective language tools (specifically interpreters) from such independently-compiled features?
The answer to the first question is a qualified “yes”: a programming
language is, to a large extent, composed of features that are either
independent of other features or interact with them in modular
ways. An if statement, for example, depends on there being a
type in the language, but is independent of the types and expressions
that appear in its two arms. This suggests that we should be able to
define the typing and semantic rules of if statements independently of
almost all other language features.
In developing Vanilla we developed a modular, composable type-checking and interpretation framework within which to define language features and their associated rules. We then developed a large range of language features within the framework, including most of the machinery needed to build imperative, object-oriented and (strict) functional languages.
The main disadvantage of Vanilla is that it uses Java, both as a run-time host language and for expressing the rules and structures. The code that designers have to write is extremely stylised and repetitive. It would be better to have a more powerful language for describing languages, and also to allow rule-based expressions.
Paddy Nixon, Vinny Wade, Simon Dobson, John Fuller, and Sotirios Terzis. Designing components for a virtual organisation: a case study. In Proceedings of Objects, Components and the Virtual Enterprise. 1998. URL: https://simondobson.org/softcopy/virtues-ocve-1998.pdf.
Simon Dobson and Paddy Nixon. (Free) radical programming languages. In Proceedings of the 5th CaberNet Radicals workshop. 1998.
Linda Farragher and Simon Dobson. Java Decaffeinated: experiences building a programming language from components. Technical Report TCD-CS-2000-22, Department of Computer Science, Trinity College Dublin, 2000. URL: https://simondobson.org/softcopy/TCD-CS-2000-22.pdf.
Simon Dobson. The O2 programming language. Technical Report, Department of Computer Science, Trinity College Dublin, 1998. Reference manual for the Vanilla implementation of Abadí and Cardelli's O2 language.
Simon Dobson. A first taste of Vanilla. Technical Report TCD-CS-1998-20, Department of Computer Science, Trinity College Dublin, 1998. URL: https://simondobson.org/softcopy/TCD-CS-1998-20.ps.
Simon Dobson. Modular parsers. Technical Report TCD-CS-1998-19, Department of Computer Science, Trinity College Dublin, 1998. URL: https://simondobson.org/softcopy/TCD-CS-1998-19.ps.
Simon Dobson. Building programming languages from components. Invited talk to the Microsoft Research Institute, 2000. URL: https://simondobson.org/softcopy/vanilla-microsoft-2000.ppt.
Simon Dobson. Fragmenting languages. Invited talk to the Department of Computer Science, California Institute of Technology, 1998. URL: https://simondobson.org/softcopy/vanilla-caltech-1998.ppt.