Vanilla: An open language framework

S Dobson, Patrick Nixon, V Wade, S Terzis, J Fuller

Research output: Chapter in Book/Report/Conference proceedingChapter

1 Citation (Scopus)

Abstract

A trend in current research is towards component-based systems, where applications are built by combining re-usable fragments or components. In this paper we argue the case for building programming languages from components. We describe Vanilla, a component-based architecture for language tools. The core of Vanilla is a set of components, each implementing the type checking and behaviour of a single language feature, which are integrated within a well-structured framework to provide a programming language interpreter. Features may be extensively re-used across a variety of languages, allowing rapid prototyping and simplifying the exploration of new constructs. We describe the design and implementation of the system, and draw some general conclusions from the experience of building with components.
LanguageEnglish
Title of host publicationGenerative and component-based software engineering
Place of PublicationBerlin
Pages91-104
DOIs
Publication statusPublished - 2000

Fingerprint

Computer programming languages
Program interpreters
Rapid prototyping

Keywords

  • n/a

Cite this

Dobson, S., Nixon, P., Wade, V., Terzis, S., & Fuller, J. (2000). Vanilla: An open language framework. In Generative and component-based software engineering (pp. 91-104). Berlin. https://doi.org/10.1007/3-540-40048-6_8
Dobson, S ; Nixon, Patrick ; Wade, V ; Terzis, S ; Fuller, J. / Vanilla: An open language framework. Generative and component-based software engineering. Berlin, 2000. pp. 91-104
@inbook{d9cfe919525e43c09045b1a302833686,
title = "Vanilla: An open language framework",
abstract = "A trend in current research is towards component-based systems, where applications are built by combining re-usable fragments or components. In this paper we argue the case for building programming languages from components. We describe Vanilla, a component-based architecture for language tools. The core of Vanilla is a set of components, each implementing the type checking and behaviour of a single language feature, which are integrated within a well-structured framework to provide a programming language interpreter. Features may be extensively re-used across a variety of languages, allowing rapid prototyping and simplifying the exploration of new constructs. We describe the design and implementation of the system, and draw some general conclusions from the experience of building with components.",
keywords = "n/a",
author = "S Dobson and Patrick Nixon and V Wade and S Terzis and J Fuller",
year = "2000",
doi = "10.1007/3-540-40048-6_8",
language = "English",
isbn = "3-540-41172-0",
pages = "91--104",
booktitle = "Generative and component-based software engineering",

}

Dobson, S, Nixon, P, Wade, V, Terzis, S & Fuller, J 2000, Vanilla: An open language framework. in Generative and component-based software engineering. Berlin, pp. 91-104. https://doi.org/10.1007/3-540-40048-6_8

Vanilla: An open language framework. / Dobson, S; Nixon, Patrick; Wade, V; Terzis, S; Fuller, J.

Generative and component-based software engineering. Berlin, 2000. p. 91-104.

Research output: Chapter in Book/Report/Conference proceedingChapter

TY - CHAP

T1 - Vanilla: An open language framework

AU - Dobson, S

AU - Nixon, Patrick

AU - Wade, V

AU - Terzis, S

AU - Fuller, J

PY - 2000

Y1 - 2000

N2 - A trend in current research is towards component-based systems, where applications are built by combining re-usable fragments or components. In this paper we argue the case for building programming languages from components. We describe Vanilla, a component-based architecture for language tools. The core of Vanilla is a set of components, each implementing the type checking and behaviour of a single language feature, which are integrated within a well-structured framework to provide a programming language interpreter. Features may be extensively re-used across a variety of languages, allowing rapid prototyping and simplifying the exploration of new constructs. We describe the design and implementation of the system, and draw some general conclusions from the experience of building with components.

AB - A trend in current research is towards component-based systems, where applications are built by combining re-usable fragments or components. In this paper we argue the case for building programming languages from components. We describe Vanilla, a component-based architecture for language tools. The core of Vanilla is a set of components, each implementing the type checking and behaviour of a single language feature, which are integrated within a well-structured framework to provide a programming language interpreter. Features may be extensively re-used across a variety of languages, allowing rapid prototyping and simplifying the exploration of new constructs. We describe the design and implementation of the system, and draw some general conclusions from the experience of building with components.

KW - n/a

U2 - 10.1007/3-540-40048-6_8

DO - 10.1007/3-540-40048-6_8

M3 - Chapter

SN - 3-540-41172-0

SP - 91

EP - 104

BT - Generative and component-based software engineering

CY - Berlin

ER -

Dobson S, Nixon P, Wade V, Terzis S, Fuller J. Vanilla: An open language framework. In Generative and component-based software engineering. Berlin. 2000. p. 91-104 https://doi.org/10.1007/3-540-40048-6_8