Specifying Software Languages: Grammars, Projectional Editors, and Unconventional Approaches

We discuss several approaches for defining software languages, together with Integrated Development Environments for them. Theoretical foundation is grammar-based models: they can be used where proven correctness of specifications is required. From a practical point of view, we discuss how language specification can be made more accessible by focusing on language workbenches and projectional editing, and discuss how it can be formalized. We also give a brief overview of unconventional ideas to language definition, and outline three open problems connected to the approaches we discuss

Engineering Language-Parametric End-User Programming Environments for DSLs

Human-computer communication can be achieved through different interfaces such as Graphical User Interfaces (GUIs), Tangible User Interfaces (TUIs), command-line interfaces, and programming languages. In this thesis, we used some of these inter- faces; however, we focused on programming languages which are artificial languages consisting of instructions written by humans and executed by computers. In order to create these programs, humans use specialized tools called programming environments that offer a set of utilities that ease human-computer communication. When creating programs, users must learn the language’s syntax and get acquainted with the pro- gramming environment. Unfortunately, programming languages usually offer a single user interface or syntax, which is not ideal considering different types of users with varied backgrounds and expertise will use it. Given the increasing number of people performing any kind of programming activity, it is important to offer different inter- faces depending on the programming task and the background of the users. However, from the language engineering point of view, offering multiple user interfaces for the same language is expensive, and if we specifically consider Domain-Specific Languages (DSLs), it is even more expensive given their audience and development teams’ size. Therefore, we study how to engineer different user interfaces for DSLs in a practical way.This thesis presents different mechanisms to engineer different language-parametric programming environments for end-users. These mechanisms rely heavily on reusing existing language components for existing languages or helping language engineers define these interfaces for new languages. We mainly studied four technological spaces, namely, Grammarware, Computational Notebooks, Block-based environments, and Projec- tional editors. We present three different language-parametric interfaces for interacting with DSLs, namely computational notebooks, projectional editors, and block-based editors. These interfaces offer different user experiences and rely upon different technological spaces. Different notations are associated with different technological spaces; for in- stance, grammarware is associated with text files, while block-based environments are associated with Blockly and JavaScript files. Therefore, to provide different notations for their languages, we have to "space travel" so that language engineers can select the most appropriate technological space and interface for their target audience. To support this, we defined grammarware as a common starting point to allow traveling to different technological spaces (e.g., computational notebooks space, projectional editors space, or block-based space). Based on this idea, we developed three tools that allowed language engineers to generate different interfaces for their DSLs based on a grammar definition of the language. Our results show that it is possible to generate these different user interfaces and decrease the effort required to create these. However, additional research is required to improve the usability of the generated interfaces and make the generation of these interfaces more flexible so that users’ data can be used as part of the generated interfaces

Incrementalizing Lattice-Based Program Analyses in Datalog

Program analyses detect errors in code, but when code changes frequently as in an IDE, repeated re-analysis from-scratch is unnecessary: It leads to poor performance unless we give up on precision and recall. Incremental program analysis promises to deliver fast feedback without giving up on precision or recall by deriving a new analysis result from the previous one. However, Datalog and other existing frameworks for incremental program analysis are limited in expressive power: They only support the powerset lattice as representation of analysis results, whereas many practically relevant analyses require custom lattices and aggregation over lattice values. To this end, we present a novel algorithm called DRedL that supports incremental maintenance of recursive lattice-value aggregation in Datalog. The key insight of DRedL is to dynamically recognize increasing replacements of old lattice values by new ones, which allows us to avoid the expensive deletion of the old value. We integrate DRedL into the analysis framework IncA and use IncA to realize incremental implementations of strong-update points-to analysis and string analysis for Java. As our performance evaluation demonstrates, both analyses react to code changes within milliseconds

MediaWiki Grammar Recovery

The paper describes in detail the recovery effort of one of the official MediaWiki grammars. Over two hundred grammar transformation steps are reported and annotated, leading to delivery of a level 2 grammar, semi-automatically extracted from a community created semi-formal text using at least five different syntactic notations, several non-enforced naming conventions, multiple misspellings, obsolete parsing technology idiosyncrasies and other problems commonly encountered in grammars that were not engineered properly. Having a quality grammar will allow to test and validate it further, without alienating the community with a separately developed grammar.Comment: 47 page

Simpl: valdkonnaspetsiifiliste keelte loomise tööriist ettevõttetarkvara arendamiseks

Domain specific languages (DSLs) are languages designed with the specific purpose of developing or configuring part of a software system using concepts that are close to those of the system's application domain. Documented benefits of DSLs include increased development productivity, flexibility and maintainability, as well as separation of business and technical aspects allowing in some cases non-technical stakeholders to closely partake in the software development process. DSLs however comes at a potentially non-negligible cost, that of creating and maintaining DSL implementations. These costs can be reduced by means of specialized tools that support the creation of parsers, analyzers, code generators, pretty-printers, and other functions associated with a DSL. This thesis deals with the problem of enabling cost-effective DSL-based development in the context of Enterprise Information Systems (EIS). EISs are generally built using application frameworks and middleware. Accordingly, it must be possible to package the DSL implementation as a module that can be called from either the build system or from the enterprise system itself. Additionally, the DSL tool should be accessible to enterprise system developers with little or no expertise in development of programming languages and supporting tools, such as Integrated Development Environments. The central contribution of the thesis is Simpl, a DSL toolkit designed to meet the needs of enterprise software development. Simpl builds up on top of existing tools and programming languages, and introduces the following features: a grammar description language that supports the generation of both the parser and the data types for representing abstract syntax trees; support for lexer states that add context-sensitivity to lexer in a controlled manner; a pretty-printing library; an IDE framework; and an integration layer that combines all components into a single whole and minimizes the need for boilerplate code.Valdkonnaspetsiifilised programmeerimiskeeled (domain specific language, DSL) on keeled, mis on välja töötatud kasutamiseks mingis konkreetses rakendusvaldkonnas. Spetsialiseerumine võimaldab DSLis kasutada konstruktsioone, mis sobivad hästi antud valdkonna mõistete esitamiseks. DSLide kasutamine annab võrreldes üldotstarbeliste keeltega mitmeid eeliseid nagu näiteks kõrgem tarkvaraarenduse efektiivsus ning paindlikum ja hästi hooldatav lõpptulemus. Samuti saavad DSLide abil tarkvaraarenduses osaleda ka isikud, kelle tehnilised oskused ei ole piisavad üldotstarbelistes keeltes programmeerimiseks, näiteks süsteemianalüütikud, lõppkasutajad jne. Teisest küljest kaasnevad DSLide kasutamisega ka kulutused DSLide välja töötamiseks ning haldamiseks. DSL-põhist tarkvaraarendust saab muuta efektiivsemaks, kasutades DSLide realiseerimiseks spetsiaalseid tööriistu. Käesoleva väitekirja fookuses on kuluefektiivne DSLide kasutamisel põhinev ettevõttetarkvara arendus. Ettevõtteinfosüsteemid realiseeritakse tüüpiliselt raamistike ja valmiskomponentide abil. Seega peab olema võimalik pakendada DSLi realisatsioon moodulina, mida on võimalik välja kutsuda kas ehitussüsteemist või EISist endast. DSLi realiseerimise tööriist peab sobima kasutamiseks ka tarkvaraarendajatele, kellel ei ole kogemusi programmeerimiskeelte ja neid toetavate vahendite arendamiseks. Töö olulisemad väited on järgmised. Esiteks, ettevõttetarkvara arendamisel on oma spetsiifika, mis seab nõudeid DSLidele ning nende realiseerimiseks kasutatavatele tööriistadele. Teiseks, enamik populaarseid tööriistu, eriti integreeritud tööriistu, mis katavad ära kogu DSLi realiseerimiseks vajaliku tegevuste spektri, ei rahulda vähemalt osaliselt neid nõudeid. Kolmandaks, me demonstreerime, et on võimalik töötada välja DSL tööriist, mis on sobiv ettevõtteinfosüsteemide arendamiseks ning mis pakub olemasolevate tööriistadega võrreldavat kasutusmugavust.valdkonnaspetsiifilised keeledettevõttedhaldusinfosüsteemiddomain specific languagesenterprisesmanagement information system

Integrating Semantically Configurable State-machine Models in a C Programming Environment

Model-driven engineering is a popular software-development methodology, which requires suitable domain-specific modelling languages (DSLs) to create models. A DSL requires flexible semantics depending on the domain knowledge. Among DSLs, Big-Step Modelling Languages (BSML) is a family of state-machine modelling languages that vary semantically. In BSML, a model can respond to an environmental input with a big-step which comprises a sequence of small-steps, each of which represents the execution of a set of transitions. The semantics of BSMLs are decomposed into mostly orthogonal semantic aspects with a wide range of semantic options. With configurable semantics, the modeller is able to choose the proper option for each semantic aspect, thus to fulfil their per domain/model semantic requirements. In this thesis we present BSML-mbeddr, a state-machine modelling language with hierarchical states, concurrent regions and configurable semantics, which has implemented a large subset of BSML within the mbeddr C programming language environment. mbeddr is a DSL workbench which provides a tool suite that supports the incremental construction of modular DSLs on top of C, together with a set of predefined DSLs. By implementing on mbeddr, BSML-mbeddr is integrated into mbeddr-C that supports programs made with heterogeneous languages, including a combination of programming language and modelling language

Role-Modeling in Round-Trip Engineering for Megamodels

Software is becoming more and more part of our daily life and makes it easier, e.g., in the areas of communication and infrastructure. Model-driven software development forms the basis for the development of software through the use and combination of different models, which serve as central artifacts in the software development process. In this respect, model-driven software development comprises the process from requirement analysis through design to software implementation. This set of models with their relationships to each other forms a so-called megamodel. Due to the overlapping of the models, inconsistencies occur between the models, which must be removed. Therefore, round-trip engineering is a mechanism for synchronizing models and is the foundation for ensuring consistency between models. Most of the current approaches in this area, however, work with outdated batch-oriented transformation mechanisms, which no longer meet the requirements of more complex, long-living, and ever-changing software. In addition, the creation of megamodels is time-consuming and complex, and they represent unmanageable constructs for a single user. The aim of this thesis is to create a megamodel by means of easy-to-learn mechanisms and to achieve its consistency by removing redundancy on the one hand and by incrementally managing consistency relationships on the other hand. In addition, views must be created on the parts of the megamodel to extract them across internal model boundaries. To achieve these goals, the role concept of Kühn in 2014 is used in the context of model-driven software development, which was developed in the Research Training Group 'Role-based Software Infrastructures for continuous-context-sensitive Systems.' A contribution of this work is a role-based single underlying model approach, which enables the generation of views on heterogeneous models. Besides, an approach for the synchronization of different models has been developed, which enables the role-based single underlying model approach to be extended by new models. The combination of these two approaches creates a runtime-adaptive megamodel approach that can be used in model-driven software development. The resulting approaches will be evaluated based on an example from the literature, which covers all areas of the work. In addition, the model synchronization approach will be evaluated in connection with the Transformation Tool Contest Case from 2019