The State of the Art in Language Workbenches. Conclusions from the Language Workbench Challenge

Language workbenches are tools that provide high-level mechanisms for the implementation of (domain-specific) languages. Language workbenches are an active area of research that also receives many contributions from industry. To compare and discuss existing language workbenches, the annual Language Workbench Challenge was launched in 2011. Each year, participants are challenged to realize a given domain-specific language with their workbenches as a basis for discussion and comparison. In this paper, we describe the state of the art of language workbenches as observed in the previous editions of the Language Workbench Challenge. In particular, we capture the design space of language workbenches in a feature model and show where in this design space the participants of the 2013 Language Workbench Challenge reside. We compare these workbenches based on a DSL for questionnaires that was realized in all workbenches

Polyglot software development

The languages we choose to design solutions influence the way we think about the problem, the words we use in discussing it with colleagues, the processes we adopt in developing the software which should solve that problem. Therefore we should strive to use the best language possible for depicting each facet of the system. To do that we have to solve two challenges: i) first of all to understand merits and issues brought by the languages we could adopt and their long reaching effects on the organizations, ii) combine them wisely, trying to reduce the overhead due to their assembling. In the first part of this dissertation we study the adoption of modeling and domain specific languages. On the basis of an industrial survey we individuate a list of benefits attainable through these languages, how frequently they can be reached and which techniques permit to improve the chances to obtain a particular benefit. In the same way we study also the common problems which either prevent or hinder the adoption of these languages. We then analyze the processes through which these languages are employed, studying the relative frequency of the usage of the different techniques and the factors influencing it. Finally we present two case-studies performed in a small and in a very large company, with the intent of presenting the peculiarities of the adoption in different contexts. As consequence of adopting specialized languages, many of them have to be employed to represent the complete solution. Therefore in the second part of the thesis we focus on the integration of these languages. Being this topic really new we performed preliminary studies to first understand the phenomenon, studying the different ways through which languages interact and their effects on defectivity. Later we present some prototypal solutions for i) the automatic spotting of cross-language relations, ii) the design of language integration tool support in language workbenches through the exploitation of common meta-metamodeling. This thesis wants to offer a contribution towards the productive adoption of multiple, specific languages in the same software development project, hence polyglot software development. From this approach we should be able to reduce the complexity due to misrepresentation of solutions, offer a better facilities to think about problems and, finally to be able to solve more difficult problems with our limited brain resources. Our results consists in a better understanding of MDD and DSLs adoption in companies. From that we can derive guidelines for practitioners, lesson learned for deploying in companies, depending on the size of the company, and implications for other actors involved in the process: company management and universities. Regarding cross-language relations our contribution is an initial definition of the problem, supported by some empirical evidence to sustain its importance. The solutions we propose are not yet mature but we believe that from them future work can stem

Aligned and collaborative language-driven engineering

Today's software development is increasingly performed with the help of low- and no-code platforms that follow model-driven principles and use domain-specific languages (DSLs). DSLs support the different aspects of the development and the user's mindset by a tailored and intuitive language. By combining specific languages with real-time collaboration, development environments can be provided whose users no longer need to be programmers. This way, domain experts can develop their solution independently without the need for a programmer's translation and the associated semantic gap. However, the development and distribution of collaborative mindset-supporting IDEs (mIDEs) is enormously costly. Besides the basic challenge of language development, a specialized IDE has to be provided, which should work equally well on all common platforms and individual heterogeneous system setups. This dissertation describes the conception and realization of the web-based, unified environment CINCO Cloud, in which DSLs can be collaboratively developed, used, transformed and executed. By providing full support at all steps, the philosophy of language-driven engineering is enabled and realized for the first time. As a foundation for the unified environment, the infrastructure of cloud development IDEs is analyzed and extended so that new languages can be distributed on-the-fly. Subsequently, concepts for language specialization, refinement and concretization are developed and described to realize the language-driven engineering approach, in a dynamic cluster-based environments. In addition, synchronization mechanisms and authorization structures are designed to enable collaboration between the users of the environment. Finally, the central aligned processes within the CINCO Cloud for developing, using, transforming and executing a DSL are illustrated to clarify how the dynamic system behaves

Development of a System for Analysing Method Names in Java Source Code

Naming code can seem like a simple task, however finding a good name can be rather challenging. Entity names should be consistent and brief yet comprehensive when representing the information each entity hold. What is considered a good name can be highly debatable, although it usually involves descriptive names that can contribute to readability and comprehensibility of source code. Bad code names can cause uncertainty, potential future bugs and be misleading. For this reason, the task of naming code is vital, hence there is a need of a system to improve and maintain it. To develop such a system, there are requirements required to be specified to define the expected implementation for certain entity names. These requirements are encoded into software in a domain-specific language, granting executable code to be generated from the expressed requirements. As a result, this name analysis tool provides programmers to perform code analysis on Java source code checking if the entities act in accordance with the requirements of their names. Additionally, the result shows insights of how contributions from linguistics can be valuable for software development and can be used to analyse software languages, such as entity names.Masteroppgave i informatikkINF399MAMN-PROGMAMN-IN

Model Driven Software Engineering Meta-Workbenches: An XTools Approach

Model Driven Software Engineering aims to provide a quality assured process for designing and generating software. Modelling frameworks that offer technologies for domain specific language and associated tool construction are called language workbenches. Since modelling is itself a domain, there are benefits to applying a workbenchbased approach to the construction of modelling languages and tools. Such a framework is a meta-modelling tool and those that can generate themselves are reflective metatools. This article reviews the current state of the art for modelling tools and proposes a set of reflective meta-modelling tool requirements. The XTools framework has been designed as a reflective meta-tool and is used as a benchmark

Gentleman : a lightweight web-based projectional editor

Lors de la conception et la manipulation de logiciel par modélisation, il est avantageux de bénéficier d’un grand degré de liberté au niveau de la présentation afin de comprendre l’information et prendre une action en exerçant peu d’effort cognitif et physique. Cette caractéristique doit aussi s’étendre aux outils que nous employons afin que ceux-ci augmentent nos capacités, plutôt que les restreindre. En génie logiciel, nous travaillons présentement à rehausser encore le niveau d’abstraction afin de réduire le rôle central du code décrit avec un langage de programmation à usage général. Ceci permettrait d’inclure les experts non techniques dans les activités de développement de logiciel. Cette approche, centralisée sur le domaine et l’expert, s’inscrit dans l’ingénierie dirigée par les modèles (IDM), où un modèle est produit et manipulé par divers experts et utilisateurs. Le modèle est alors décrit avec un langage créé spécifiquement pour un domaine d’application ou une tache, appelé langage dédié (DSL). Une technique utilisée pour créer ces modèles et leurs DSL est le projectional editing, qui permet d’utiliser des notations diverses interchangeables et d’étendre et composer facilement un langage. Toutefois, les solutions actuelles sont lourdes, spécifiques à une plateforme, et manquent considérablement d’utilisabilité, limitant ainsi l’usage et l’exploitation de cette approche. Pour mieux refléter les avantages du paradigme IDM avec le style projectionnel, nous introduisons dans cette thèse Gentleman, un éditeur projectionnel léger sur le web. Avec Gentleman, le développeur crée un modèle en combinant des concepts utilisés pour définir la structure du modèle et des projections pour les manipuler dans l’éditeur. Nous avons évalué Gentleman à travers une étude basée sur un groupe d’utilisateur. L’étude a confirmé sa capacité à créer et manipuler des modèles efficacement. Les participants ont noté qu’il est facile de prendre en main Gentleman et que l’interface est très intuitive comparativement aux éditeurs existants. Nous avons aussi intégré Gentleman avec succès à une plateforme web, démontrant ainsi ses capacités d’interopérabilité et l’avantage d’une solution web.In software activities and, more specifically, when modeling, the modeler should benefit from as much freedom as possible to understand the presented information and take action with minimal cognitive and mechanical effort. This characteristic should also apply to the tools used in the process so that they extend our capabilities rather than limit them. In the field of software engineering, current work aims to push the level of abstraction past general-purpose programming language into domain-specific modeling. This enables domain experts with various backgrounds to participate in software development activities. This vision is central to model-driven engineering (MDE) where, instead of code, various experts and users produce and manipulate domain-specific language (DSL). In recent years, projectional editing has proven to be a valid approach to creating and manipulating DSLs, as it supports various easily interchangeable notations and enables language extension and composition. However, current solutions are heavyweight, platform-specific, and suffer from poor usability. To better support this paradigm and minimize the risk of accidental complexity in terms of expressiveness, in this thesis, we introduce Gentleman, a lightweight web-based projectional editor. With Gentleman, a developer creates a model by combining concepts used to define its structure and projections to interact and manipulate them in the editor. We have evaluated Gentleman through a user study. The evaluation confirmed its capacity to create and manipulate models effectively. Most participants noted that the editor is very user-friendly and intuitive compared to existing editors. We have also successfully integrated Gentleman into a web application, demonstrating its interoperability and the benefit of a web solution

Ambiguity Detection: Scaling to Scannerless

Static ambiguity detection would be an important aspect of language workbenches for textual software languages. However, the challenge is that automatic ambiguity detection in context-free grammars is undecidable in general. Sophisticated approximations and optimizations do exist, but these do not scale to grammars for so-called ``scannerless parsers'', as of yet. We extend previous work on ambiguity detection for context-free grammars to cover disambiguation techniques that are typical for scannerless parsing, such as longest match and reserved keywords. This paper contributes a new algorithm for ambiguity detection in character-level grammars, a prototype implementation of this algorithm and validation on several real grammars. The total run-time of ambiguity detection for character-level grammars for languages such as C and Java is significantly reduced, without loss of precision. The result is that efficient ambiguity detection in realistic grammars is possible and may therefore become a tool in language workbenches