Hot Topic: Language Workbenches

In a new online article Martin Fowler, a well-known author of the software development scene, addresses domain-specific languages (DSL) and code generators. It has to be emphasized that several vendors are developing tools related to this one independent from each other. These tools are representing the same concepts: An exotic fringe area of software development becomes mainstream. However, how are the concepts analyzed by Fowler to be reviewed? Where in this context can a technology like HyperSenses be ranked – a generator system that also focuses on domain orientation? The answer is very simple: In the middle of the crowd. Read more about this in the following.

In his article "Language Workbenches: The Killer-App for Domain-Specific Languages" Fowler outlines several types of DSLs, which differ in their implementation and in their abstraction level. He uses the term "Language Oriented Programming" for all concrete DSL implementations. Starting from the observation that this way of programming is quite usual for a long time, he motivates a range of concepts for a new kind of tools: "Language Workbenches".

Fowler mainly criticizes the usage of standard DSLs (e.g. XML, Ruby on Rails). He regards the application of specialized DSLs as indispensable, if also lay programmers (though they are specialists in their area) are to work with DSLs. A profitable usage of the DSLs hence necessitates an appropriate tool. He also amplifies that the workings at Intentional Software, the Meta-Programming System (MPS) from JetBrains as well as Microsoft's Software Factories can be regarded as examples for development activities aiming at this issue.

"One of the strongest qualities of language workbenches is that they alter the relationship between editing and compiling the program. Essentially they shift from editing text files to editing the abstract representation of the program."
(M. Fowler in "Language Workbenches: The Killer-App for Domain-Specific Languages")

The foresaid citation reflects the main property of Language Workbenches. Fowler speaks about an abstract representation of the properties expressed via a DSL. This abstraction serves as a data pool for several projections and is edited within these projections. The mapping to an implementation is performed by a generation process, which receives the data abstraction as its input. The core property is that program texts are no longer edited directly; this is to be processed for a projection of the abstract data.

Fowler derives three subtasks for the definition of a new DSL from these concepts. He emphasizes that a schema for the abstract representation, an editor for the projections as well as a generator for the production of source code are necessary. These concepts well and truly correspond to the idea of HyperSenses: In this context the schema is the meta model, the abstract representation accords to the model, the projections correspond to the configuration renderings, the editor is synonymous to the tool HyperSenses Active Intent™, while the generator consists of production renderings. HyperSenses is a true Language Workbench.

Interestingly, Fowler complains about the absence of standards for the definition of the trio consisting of schema, editor and generator. This is not true: An abstract representation together with a schema for it may rightly be referred to as model and meta model. The appropriate standard is the Meta Object Facility (MOF) of the Object Management Group (OMG). Indeed, this standard generally applies to any model-meta model abstractions and can therefore not be considered as a special standard for Language Workbenches. Nevertheless, it can be applied to them – according to its intention: HyperSenses, for example, is based on MOF.

Altogether it can be stated that more and more development environments are evolving towards Language Workbenches, although many products are not fully mature yet. Certainly this is an area on the way to mainstream. From our point of view, it will be exciting to see to what extent model-based approaches based on open standards like MOF will become widely accepted, compared to proprietary implementations.

The article of Martin Fowler:
"Language Workbenches: The Killer-App for Domain-Specific Languages"