Software Language Engineering Research Articles

A personal retrospective on language workbenches

Model-driven software engineering and specifically domain-specific languages have contributed to improve the quality of software and the efficiency in the development of software. However, the design and implementation of domain-specific languages requires still an enormous investment. Language workbenches are the most important tools in the field of software language engineering. The introduction of language workbenches has alleviated partly the development effort, but there are still a few major challenges that need to be tackled. This paper presents a personal perspective on the development of tools for language engineering and language workbenches in particular and future challenges to be tackled.

IDFML: A Meta Language for Heterogeneous DSMLs Coordination

The popularization of both Software Language Engineering (SLE) and Model Driven Engineering (MDE) as well as the increasing complexity of systems induce new implementation practices. Indeed, many teams of experts collaborate to implement a same system. Every team uses her own domain specific modeling language (DSML) to represent her concerns. Consequently, by the end of the modelling phase, we get many heterogeneous models elaborated using different DSMLs. These models need to be composed to get a whole view of systems, to be able to validate and simulate behaviors. However, many recent researches choose to compose modelling languages rather than models themselves, but until now there are no standard or generic techniques for that. Although, MDE and SLE provide tools and concepts for modeling, customizing and processing business concepts as single activities, in contrast they provide little support for coordinating between these activities. In this paper, authors propose an interface-based approach to coordinate DSMLS in order to compose and coordinate their respective models. They began by giving generic guidelines of DSMLs specification and composition aspects. Then, they introduce IDFML a Meta language for defining both DSMLs interfaces and coordination. Actually, the proposed Meta language gives a metamodeling background to coordination which enables to benefit from MDE tools and techniques. They finally demonstrate the applicability of the approach using a Connected Indoor Transport Service System to conclude by summarizing benefits of the proposed Methodology.

The Software Language Extension Problem

The problem of software language extension and composition drives much of the research in Software Language Engineering (SLE). Although various solutions have already been proposed, there is still little understanding of the specific ins and outs of this problem, which hinders the comparison and evaluation of existing solutionsIn this SoSyM Expert Voice, we introduce the Language Extension Problem as a way to better qualify the scope of the challenges related to language extension and compositionThe formulation of the problem is similar to the seminal Expression Problem introduced by Wadler in the late 1990s and lifts it from the extensibility of single constructs to the extensibility of groups of constructs, i.e., software languages. We provide a comprehensive definition of the actual constraints when considering language extension and believe the Language Extension Problem will drive future research in SLE, the same way the original Expression Problem helped to understand the strengths and weaknesses of programming languages and drove much research in programming languages.

Systematic composition of independent language features

Systematic reuse is crucial to efficiently engineer and deploy software languages to software experts and domain experts alike. But “software languages are software too”, and hence their engineering, customization, and reuse are subject to similar challenges. To this effect, we propose an approach for composing independent, grammar-based language syntax modules in a structured way that realizes a separation of concerns among the participants in the life cycle of the languages. We present a refined concept of systematic and controlled syntactic variability of extensible software language product lines through identification of syntax variation points and derivation of variants from independently developed features. This facilitates reuse of software languages and reduces the efforts of engineering and customizing languages for specific domains. We realized our concept with the MontiCore language workbench and assessed it through a case study on architecture description languages. Ultimately, systematic and controlled software language reuse reduces the effort of software language engineering and fosters the applicability of software languages.

Software language engineering in the large: towards composing and deriving languages

Suitable software languages are crucial to tackling the ever-increasing complexity of software engineering processes and software products. They model, specify, and test products, describe processes and interactions with services and serve many other purposes. Meanwhile, engineering suitable modeling languages with useful tooling also has become a challenging endeavor - and far too often, new languages are developed from scratch. We shed light on the advances of modeling language engineering that facilitate reuse, modularity, compositionality, and derivation of new languages based on language components. To this end, we discuss ways to design, combine, and derive modeling languages in all their relevant aspects. We illustrate the application of advanced language engineering throughout the paper, which culminates in the example of deriving complete domain-specific transformations language from existing language components.

A Brief History of Cloud Application Architectures

This paper presents a review of cloud application architectures and its evolution. It reports observations being made during a research project that tackled the problem to transfer cloud applications between different cloud infrastructures. As a side effect, we learned a lot about commonalities and differences from plenty of different cloud applications which might be of value for cloud software engineers and architects. Throughout the research project, we analyzed industrial cloud standards, performed systematic mapping studies of cloud-native application-related research papers, did action research activities in cloud engineering projects, modeled a cloud application reference model, and performed software and domain-specific language engineering activities. Two primary (and sometimes overlooked) trends can be identified. First, cloud computing and its related application architecture evolution can be seen as a steady process to optimize resource utilization in cloud computing. Second, these resource utilization improvements resulted over time in an architectural evolution of how cloud applications are being built and deployed. A shift from monolithic service-oriented architectures (SOA), via independently deployable microservices towards so-called serverless architectures, is observable. In particular, serverless architectures are more decentralized and distributed, and make more intentional use of separately provided services. In other words, a decentralizing trend in cloud application architectures is observable that emphasizes decentralized architectures known from former peer-to-peer based approaches. This is astonishing because, with the rise of cloud computing (and its centralized service provisioning concept), the research interest in peer-to-peer based approaches (and its decentralizing philosophy) decreased. However, this seems to change. Cloud computing could head into the future of more decentralized and more meshed services.

Automatic production of end user documentation for DSLs

Domain-specific languages (DSL) are developed for answering specific problems by leveraging the expertise of domain stakeholders. The development of DSLs requires a significant software engineering effort: editors, code generators, etc, must be developed to make a DSL usable. Documenting a DSL is also a major and time-consuming task required to promote it and address its learning curve. Recent research work in software language engineering focus on easing the development of DSLs. This work focuses on easing the production of documentation of textual DSLs. The API documentation domain identified challenges we adapted to DSL documentation. Based on these challenges we propose a model-driven approach that relies on DSL artifacts to extract information required to build documentation. Our implementation, called Docywood, targets two platforms: Markdown documentation for static web sites and Xtext code fragments for live documentation while modeling. We used Docywood on two DSLs, namely ThingML and Target Platform Definition. Feedback from end users and language designers exhibits qualitative benefits of the proposal with regard to the DSL documentation challenges. End user experiments conducted on ThingML and Target Platform Definition show benefits on the correctness of the created models when using Docywood on ThingML.

Concern-oriented language development (COLD): Fostering reuse in language engineering

Domain-Specific Languages (DSLs) bridge the gap between the problem space, in which stakeholders work, and the solution space, i.e., the concrete artifacts defining the target system. They are usually small and intuitive languages whose concepts and expressiveness fit a particular domain. DSLs recently found their application in an increasingly broad range of domains, e.g., cyber-physical systems, computational sciences and high performance computing. Despite recent advances, the development of DSLs is error-prone and requires substantial engineering efforts. Techniques to reuse from one DSL to another and to support customization to meet new requirements are thus particularly welcomed. Over the last decade, the Software Language Engineering (SLE) community has proposed various reuse techniques. However, all these techniques remain disparate and complicate the development of real-world DSLs involving different reuse scenarios.In this paper, we introduce the Concern-Oriented Language Development (COLD) approach, a new language development model that promotes modularity and reusability of language concerns. A language concern is a reusable piece of language that consists of usual language artifacts (e.g., abstract syntax, concrete syntax, semantics) and exhibits three specific interfaces that support (1) variability management, (2) customization to a specific context, and (3) proper usage of the reused artifact. The approach is supported by a conceptual model which introduces the required concepts to implement COLD. We also present concrete examples of some language concerns and the current state of their realization with metamodel-based and grammar-based language workbenches. We expect this work to provide insights into how to foster reuse in language specification and implementation, and how to support it in language workbenches.

Usability driven DSL development with USE-ME

The adoption of Domain-Specific Languages (DSLs) is regarded as an approach to reduce the accidental complexity of software systems development. The availability of sophisticated language workbenches facilitates the development of DSLs making them increasingly more popular. The adoption of DSLs at large comes at the risk that a poorly designed DSL can be too hard to adopt by its domain users. As such, Usability is one of the essential characteristics to mitigate this risk as it has an important impact on the productivity achieved by DSL users.The current state of practice in Software Language Engineering (SLE) neglects the Usability of DSLs. A pertinent research question in SLE is how to engineer Usability into DSLs systematically. We argue that a timely systematic approach based on User Interface experimental evaluation techniques should be used to assess the impact of DSLs during their development process, while the cost of fixing the usability problems is relatively small, when compared to fixing them at the end of the development process.For that purpose, we introduce a conceptual framework, called USE-ME, which supports the iterative incremental development process of DSLs concerning the issue of their Usability evaluation. We illustrate the feasibility of the approach on a case study of the development of a DSL meant for children to program robots.

GitHub, Technical Debt, Code Formatting, and More

This issue's column reports on papers from the 19th International Conference on Model Driven Engineering Languages and Systems, the 2016 ACM SIGPLAN International Conference on Software Language Engineering, the 12th International ACM SIGSOFT Conference on the Quality of Software Architectures, and the 13th Working IEEE/IFIP Conference on Software Architecture. Topics discussed include GitHub and open source, technical debt in model-driven engineering, a universal code formatter, assuring architectural quality, and continuous architecting.

Leveraging Software Product Lines Engineering in the development of external DSLs: A systematic literature review

The use of domain-specific languages (DSLs) has become a successful technique in the development of complex systems. Consequently, nowadays we can find a large variety of DSLs for diverse purposes. However, not all these DSLs are completely different; many of them share certain commonalities coming from similar modeling patterns – such as state machines or petri nets – used for several purposes. In this scenario, the challenge for language designers is to take advantage of the commonalities existing among similar DSLs by reusing, as much as possible, formerly defined language constructs. The objective is to leverage previous engineering efforts to minimize implementation from scratch. To this end, recent research in software language engineering proposes the use of product line engineering, thus introducing the notion of language product lines. Nowadays, there are several approaches that result useful in the construction of language product lines. In this article, we report on an effort for organizing the literature on language product line engineering. More precisely, we propose a definition for the life-cycle of language product lines, and we use it to analyze the capabilities of current approaches. In addition, we provide a mapping between each approach and the technological space it supports.

CMFDM: A methodology to guide the design of a conceptual model of farmers' decision-making processes

The agricultural research community offers languages and approaches to model farmers' decision-making processes but does not often clearly detail the steps necessary to build an agent model underlying farmers' decision-making processes. We propose an original and readily applicable methodology for modelers to guide data acquisition and analysis, incorporate expert knowledge, and conceptualize decision-making processes in farming systems using a software engineering language to support the development of the model. We propose a step-by-step approach that combines decision-making analysis with a modeling approach inspired by cognitive sciences and software-development methods. The methodology starts with case-based analysis to study and determine the complexity of decision-making processes and provide tools to obtain a generic and conceptual model of the decisional agent in the studied farming system. A generic farm representation and decision diagrams are obtained from cross-case analysis and are modeled with Unified Modeling Language. We applied the methodology to a research question on water management in an emerging country (India). Our methodology bridges the gap between field observations and the design of the decision model. It is a useful tool to guide modelers in building decision model in farming system.

Open and Original Problems in Software Language Engineering 2015 Workshop Report

OOPSLE is a workshop co-located with a re-engineering conference and serving as a venue for software language engineers to meet outside the SLE conference to discuss either long-standing problems that remain unresolved for years or decades, or oftavoided problems that everyone is so used to work around that they stop noticing them at all. In 2015, it ran for the third time. The list of topics discussed at the workshop, included transformation in the presence of Boolean grammars, natural language software interfaces, formally supported model management, community-aware language design, domain-specific language design choices and uncertainty-aware development. A report such as this one was requested by the participants, but more condensed and general information can be found on our official webpage at http://oopsle.github.io

XPL: A language for modular homogeneous language embedding

Languages that are used for Software Language Engineering (SLE) offer a range of features that support the construction and deployment of new languages. SLE languages offer features for constructing and processing syntax and defining the semantics of language features. New languages may be embedded within an existing language (internal) or may be stand-alone (external). Modularity is a desirable SLE property for which there is no generally agreed approach. This article analyses the current tools for SLE and identifies the key features that are common. It then proposes a language called XPL that supports these features. XPL is higher-order and allows languages to be constructed and manipulated as first-class elements and therefore can be used to represent a range of approaches to modular language definition. This is validated by using XPL to define the notion of a language module that supports modular language construction and language transformation.

Software Language Engineering by Intentional Rewriting

Grammars in a broad sense (specifications of structural commitments) are complex artefacts that define software languages. Assessing and improving their quality in an automated, non-idiosyncratic manner is an unsolved problem which we face in an especially acute form in the case of mass maintenance of hundreds of heterogeneous grammars (parser specs, ADTs, metamodels, XML schemata, etc) in the Grammar Zoo. In an attempt to apply software language engineering methods to solve a software language engineering problem, we design a language for grammar mutations capable of applying uniform intentional transformations in the scope of a big grammar or a corpus of grammars. In this paper, we describe a disciplined process of engineering such a language by systematic reuse of semantic components of another existing software language. The constructs of the reference language are analysed and classified by their intent, each category of constructs is then subjected to rewriting. This process results in a set of constructs that form the new language.

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

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.

Bridging the chasm between MDE and the world of compilation

Modeling and transforming have always been the cornerstones of software system development, albeit often investigated by different research communities. Modeling addresses how information is represented and processed, while transformation cares about what the results of processing this information are. To address the growing complexity of software systems, model-driven engineering (MDE) leverages domain-specific languages to define abstract models of systems and automated methods to process them. Meanwhile, compiler technology mostly concentrates on advanced techniques and tools for program transformation. For this, it has developed complex analyses and transformations (from lexical and syntactic to semantic analyses, down to platform-specific optimizations). These two communities appear today quite complementary and are starting to meet again in the software language engineering (SLE) field. SLE addresses all the stages of a software language lifecycle, from its definition to its tooling. In this article, we show how SLE can lean on the expertise of both MDE and compiler research communities and how each community can bring its solutions to the other one. We then draw a picture of the current state of SLE and of the challenges it has still to face.

Understanding privacy policies

Their is growing recognition that users of web-based systems want to understand, if not control, what customer's data is stored by whom, for what purpose, for what duration, and with whom it is shared. We inform current language-based privacy efforts with an empirical study of P3P--the W3C domain-specific language for privacy policies. We use methods of software language engineering to study usage profiles, correctness of policies, metrics, cloning, and language extensions. The study supports the conclusion that P3P's approach to policy validation is too weak to ensure correct use of the language. The study also discovers common, dominating policies, which may suggest a simpler approach to web privacy. Further, the study investigates a range of metrics for policies in an attempt to discover particularly interesting or complex policies. Finally, the study also attempts to discover symptoms of the need for extending the P3P language, but the found results are not conclusive here.

FAML: A Generic Metamodel for MAS Development

In some areas of software engineering research, there are several metamodels claiming to capture the main issues. Though it is profitable to have variety at the beginning of a research field, after some time, the diversity of metamodels becomes an obstacle, for instance to the sharing of results between research groups. To reach consensus and unification of existing metamodels, metamodel-driven software language engineering can be applied. This paper illustrates an application of software language engineering in the agent-oriented software engineering research domain. Here, we introduce a relatively generic agent-oriented metamodel whose suitability for supporting modeling language development is demonstrated by evaluating it with respect to several existing methodology-specific metamodels. First, the metamodel is constructed by a combination of bottom-up and top-down analysis and best practice. The concepts thus obtained and their relationships are then evaluated by mapping to two agent-oriented metamodels: TAO and Islander. We then refine the metamodel by extending the comparisons with the metamodels implicit or explicit within five more extant agent-oriented approaches: Adelfe, PASSI, Gaia, INGENIAS, and Tropos. The resultant FAML metamodel is a potential candidate for future standardization as an important component for engineering an agent modeling language.

Guest Editors' Introduction to the Special Section on Software Language Engineering

Humankind is defined by Language; Civilization is defined by Writing. Since the Stone Age and then the shift from Prehistory to History, nothing has really changed in this respect. What remains constant is that no information can be shared without languages. But, as we are entering the so-called Information Age, we are definitively facing new challenges in Information Technologies (IT). This special section considers one of these challenges, namely, the disciplined and systematic Engineering of what is coined Software Languages. Starting to address this challenge now may make a difference in the Software Century.