An object-oriented approach to language compositions for software language engineering

Highlights

• Language composition has not obtained enough attention, is still not well-understood, and associated terminology is confusing.

• OO techniques and concepts are powerful enough to implement all types of language compositions.

• Several small examples of different types of language composition are shown using easy to understand DSLs.

Abstract

In this paper, it is shown that inheritance, a core concept from object-oriented programming, is a possible solution for realizing composition of computer languages. Language composability is a property of language descriptions, which can be further classified into informal (language syntax and semantics are hard-coded in compiler/interpreter) and formal language descriptions (syntax and semantics are formally specified with one of several formal methods for language definition). However, language composition is much easier to achieve with declarative formal language descriptions into which the notion of inheritance is introduced. Multiple attribute grammar inheritance, as implemented in the language implementation system LISA, can assist in realizing all of the different types of language compositions identified in Erdweg et al. (2012). Different examples are given throughout the paper using an easy to understand domain-specific language that describes simple robot movement.

Introduction

Software Language Engineering (SLE) (Kleppe, 2008) is a young engineering discipline with the aim of establishing a systematic and rigorous approach to the development, use, and maintenance of computer languages, which comprises specification, modeling and programming languages. Although in this paper emphasis is given to grammar-based domain-specific languages (DSLs) (Hudak, 1996, van Deursen et al., 2000, Mernik et al., 2005, Fowler, 2010, Kosar et al., 2010, Mernik, 2013, Kolomvatsos et al., 2012), SLE is equally focused on metamodel-based DSLs (Gray et al., 2007, Sprinkle et al., 2009) and general-purpose languages (GPLs) (e.g., Java, Gosling et al., 1996). A special focus of SLE, which is also a topic of this paper, is that a formal description is used to design and implement a language (e.g., generating a compiler), as well as to generate various language-based tools (e.g., editor, debugger) (Henriques et al., 2005). Any language description, formal or informal, should be amenable for refinement and composition. Unfortunately, this is usually not the case, making DSLs harder to adopt to frequent changes (Mernik and Žumer, 2005). To be able to design and implement DSLs more easily, modular, extensible, and reusable language descriptions are needed. It is even possible for some of the descriptions to be inferred from DSL programs (Hrnčič et al., 2011, Hrnčič et al., 2012). A language engineer may want to include new language features incrementally as the computer language evolves. Moreover, a language engineer may like to build a computer language simply by reusing different language description modules (language components, language fragments), such as modules for expressions, declarations, as well as to reuse and extend previous language descriptions. Thus, language description composition is a high level goal that still needs much work in the area of SLE.

In the recent paper (Erdweg et al., 2012) it has been pointed out that language composition has not obtained enough attention, is still not well-understood, and associated terminology is confusing. All of these points suggest that research in this area is not yet mature. Language composability has been identified in Erdweg et al. (2012) not as a property of languages themselves, but as a property of language description (e.g., how language specifications, formal or informal, can be composed together). To enable language composition, a language description has to be reused as is; that is, any changes to a language description are not allowed, but language descriptions can be extended or additional glue code can be written. This is similar to the Open/Closed Principle in Object-Oriented Design (Meyer, 1997). The following types of language composition have been distinguished in Erdweg et al. (2012): language extension (which subsumes also language restriction), language unification, self-extension, and extension composition.

In the case of general software development, the use of object-oriented techniques and concepts (Abadi and Cardelli, 1996), such as encapsulation and inheritance, greatly improves incremental software development and reusability. Object-oriented techniques and concepts already have been integrated into language descriptions (Mernik et al., 2000, Hedin and Magnusson, 2003, Mernik and Žumer, 2005) to enable new features to be implemented. The main objective of this paper is to show that object-oriented techniques and concepts are powerful enough to implement all types of language compositions identified in Erdweg et al. (2012). For practical purposes, different types of language compositions are explained using a simple and easy to understand Robot DSL (Mernik and Žumer, 2005). In this case study, a compiler generator tool called LISA (Henriques et al., 2005, Mernik and Žumer, 2005) will be used. In addition to the Robot DSL, more complex examples can be found in Mernik and Žumer (2005) and Fister et al., 2012, Fister et al., 2013. The usefulness of object-oriented design/architecture/programming has been shown in many other engineering disciplines (e.g., Lejeune et al., 2012, Loenzo et al., 2010, Murthy et al., 2011). In this paper, the usefulness of object-oriented approach is shown as applied to SLE. As previously stated, in this paper the emphasis is on DSLs. Firstly, it is easier to show various language compositions on small DSLs rather than on GPLs, which are usually much larger than DSLs with respect to the size of syntax and semantic specifications (Črepinšek et al., 2010). Secondly, DSLs are an emerging popular area of research in the field of software engineering. For example, DSLs are one of the most important parts in Generative Programming (Czarnecki and Eisenecker, 2000), Product Lines (Clements, 2002), Software Factories (Greenfield and Short, 2004), and Model-Driven Engineering (Schmidt, 2006, Gray et al., 2007, Sprinkle et al., 2009). The common denominator of the aforementioned development methodologies is the involvement of the end-user in the development of software. DSLs provide end-users with the ability to program/model their solutions. Moreover, with the current achievements in DSL research, the vision of language-oriented software development (Ward, 1995, Dmitriev, 2004) is a step closer to realization. The idea of language-oriented software development is to first develop various DSLs and then use them together to develop an application. To achieve the vision of language-oriented software development, it is necessary to improve the ability to compose languages.

The paper is organized as follows: Section 2 briefly describes LISA – Language Implementation System using Attribute Grammars, which is used as a language description system for language composition. Various types of language compositions are explained on the simple Robot DSL, which is also introduced in this section. In Section 3, different types of language compositions are mentioned briefly and concrete examples are presented and discussed. Related work is described in Section 4, followed by the conclusions in Section 5.