Software language engineering can be considered the art of creating software languages. Although most computer scientists are just language users, the popularity of some development techniques, such as model-driven software development, has spurred the interest of language engineers, moving into their territory the creation of software languages. In the broadest sense, they include both modeling languages and programming languages; hence, the scope of software language engineering goes well beyond compiler construction.

This relatively short book started out as Kleppe’s doctoral thesis. However, you should not expect a formal dissertation on programming language design. In fact, Kleppe makes a very pertinent criticism of “worm-like” scientists and the divide between industry and academia. Instead of prescribing what language engineers should do in terms of a rigid methodology, Kleppe advocates for a more pragmatic approach by “show[ing] what the ingredients of a language specification are and how each of these can be best expressed, thus providing the language engineers with maximum flexibility.”

The first chapters contain introductory material. Kleppe sets the stage by drawing ideas from natural languages, compiler technology, and visual languages. Since software languages include more than just conventional programming languages, she prefers to use the term “mogram” rather than the more common “program,” to refer to the products written in a software language, be it models, programs, or any other artifact created with the help of a software language. While language users employ integrated development environments (IDEs), language engineers rely on language workbenches [1] to create languages. Justification for this never-ending quest for a higher level of abstraction comes from F.P. Brooks’ observation that a software developer’s productivity is constant, in terms of the number of statements produced per time unit [2].

Once the rationale for language engineering is exposed, Kleppe jumps into her view of language specification, the theoretical background of languages. In her framework, a language specification includes an abstract syntax model (ASM), probably several concrete syntax models (CSMs), one or more syntax mappings (from the ASM to each CSM), an optional semantic model, an optional set of required language interfaces, and an optional set of offered language interfaces. These six elements are explored in order, and their detailed descriptions constitute the core of the book.

Metamodeling--using a model to specify a language--is chosen as the preferred formalism to define ASMs. Alternatives are considered, but are discarded as less practical: context-free grammars fall short; attribute grammars obscure mogram structure; graph grammar results are too complex; and unified modeling language (UML) profiles impose unnecessary restrictions. The ASM metamodel describes, in UML-like models, the domain model for a given domain in a business-oriented vertical domain-specific languages (DSLs), while it embodies the common patterns in the applications of the DSL targets in a technically oriented horizontal DSL.

Both textual and graphical CSMs let us represent mograms. The author addresses how the concrete form of a mogram can be transformed into its abstract form, and also describes how a textual concrete syntax can be generated from an ASM. This process can be partially automated with the help of such tools as Kleppe’s Grasland generator [3].

Semantic models, as descriptions intended for human consumption, specify part of the meaning of programs. Kleppe departs from the typical description of formal models, and instead proposes the use of graphs to describe the operational semantics of a program. A separate chapter introduces code generators as providers of “a translational form of semantics” (obviously, in terms of the target language). Faithful to Kleppe’s pragmatism, this chapter also discusses alternative code generation approaches, common patterns, and the importance of extension points for handwritten code.

Finally, language interfaces are necessary for combining multiple languages, a common situation in practice. The open challenge is how to generate a suitable IDE, based on the specification of several languages that must cooperate to support language users in actual software development projects.

This interesting book is comprised by relatively standalone chapters, with some cross-references that cover the topics in uneven depth. Although the chosen examples are not particularly insightful, since they sometimes provide just partial discussions of important implementation details, the book still provides a good overview of Kleppe’s perspective on software language creation. This limitation might be caused by the fact that many chapters are, to a great extent, based on conference papers published by the author and her collaborators. However, some two-column sidebars provide the background necessary for understanding, making the book largely self-contained; furthermore, it is not necessary to refer to the bibliography to understand Kleppe’s points.

This is a practical book for anyone interested in model-driven software development. It is a must read for language engineers creating their own domain-specific languages.