Powered by
Conference Publishing Consulting

2015 ACM SIGPLAN International Conference on Software Language Engineering (SLE 2015), October 26–27, 2015, Pittsburgh, PA, USA

SLE 2015 – Proceedings

Contents - Abstracts - Authors

Frontmatter

Title Page

Preface
We are pleased to present the proceedings of the 8th International Conference on Software Language Engineering (SLE 2015). The conference was held in Pittsburgh, Pennsylvania, United States, during October 26 and 27, 2015. It was part of the 6th Conference on Systems, Programming, Languages and Applications: Software for Humanity (SPLASH 2015), and thus co-located with the Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA) conference, the 14th Symposium on New Ideas in Programming and Reflections on Software (Onward!), the 11th Dynamic Languages Symposium (DLS), the 14th International Conference on Generative Programming and Component Engineering (GPCE), the 22nd Conference on Pattern Languages of Programs (PLoP), and the 15th International Symposium on Database Programming Languages (DBPL), along with the Parsing@SLE Workshop. The conference program included a keynote presentation, 12 technical paper presentations, and 5 tool paper demonstrations. The invited speaker was Prof. Stéphane Ducasse research director at INRIA Lille leading the RMoD Team (France), with a talk entitled “What's the value of an end user? Platforms and Research: The case of Pharo and Moose”.

Language Development and Evaluation

On Integrating Graphical and Textual Editors for a UML Profile Based Domain Specific Language: An Industrial Experience
Salome Maro, Jan-Philipp Steghöfer, Anthony Anjorin, Matthias Tichy, and Lars Gelin
(Chalmers University of Technology, Sweden; University of Gothenburg, Sweden; University of Ulm, Germany; Ericsson, Sweden)
Domain Specific Languages (DSLs) are an established means of reducing the gap between problem and solution domains. DSLs increase productivity and improve quality as they can be tailored to exactly fit the needs of the problem to be solved. A DSL can have multiple notations including textual and graphical notations. In some cases, one of these notations for a DSL is enough but there are many cases where a single notation does not suffice and there is a demand to support multiple notations for the same DSL. UML profile is one of several approaches used to define a DSL, however most UML tools only come with graphical editors. In this paper, we present our approach and industrial experience on integrating textual and graphical editors for a UML profile-based DSL. This work was conducted as part of an explorative study at Ericsson. The main aim of the study was to investigate how to introduce a textual editor to an already existing UML profile-based DSL in an Eclipse environment. We report on the challenges of integrating textual and graphical editors for UML profile-based DSLs in practice, our chosen approach, specific constraints and requirements of the study.
Publisher's Version Article Search
An Empirical Study on Simplification of Business Process Modeling Languages
Eric Umuhoza, Marco Brambilla, Davide Ripamonti, and Jordi Cabot
(Politecnico di Milano, Italy; ICREA, Spain; Open University of Catalonia, Spain)
The adaptation, specially by means of a simplification process, of modeling languages is a common practice due to the overwhelming complexity of most standard languages (like UML or BPMN), not needed for typical usage scenarios while at the same time companies don't want to go to the extremes of defining a brand new domain specific language. Unfortunately, there is a lack of examples of such simplification experiences that can be used as a reference for future projects. In this paper we report on a field study aimed at the simplification of a business process modeling language (namely, BPMN) for making it suitable to end users. Our simplification process relies on a set of steps that encompass the selection of the language elements to simplify, generation of a set of language variants for them, measurement of effectiveness of the variants through user modeling sessions and extraction of quantitative and qualitative data for guiding the selection of the best language refinement. We describe the experimental setting, the output of the various steps of the analysis, and the results we obtained from users. Finally, we conclude with an outlook towards the generalization of the approach and consolidation of a language simplification method.
Publisher's Version Article Search
Melange: A Meta-language for Modular and Reusable Development of DSLs
Thomas Degueule, Benoit Combemale, Arnaud Blouin, Olivier Barais, and Jean-Marc Jézéquel
(INRIA, France; INSA Rennes, France; University of Rennes 1, France)
Domain-Specific Languages (DSLs) are now developed for a wide variety of domains to address specific concerns in the development of complex systems. When engineering new DSLs, it is likely that previous efforts spent on the development of other languages could be leveraged, especially when their domains overlap. However, legacy DSLs may not fit exactly the end user requirements and thus require further extension, restriction, or specialization. While current language workbenches provide import mechanisms, they usually lack an explicit support for such customizations of imported artifacts. In this paper, we propose an approach for building DSLs by safely assembling and customizing legacy DSLs artifacts. This approach is based on typing relations that provide a reasoning layer for manipulating DSLs while ensuring type safety. On top of this reasoning layer, we provide an algebra of operators for extending, restricting, and assembling separate DSL artifacts. We implemented the typing relations and algebra into the Melange meta-language. We illustrate Melange through the modular definition of an executable modeling language for the Internet Of Things domain. We show how it eases the definition of new DSLs by maximizing the reuse of legacy artifacts without introducing issues in terms of performance, technical ecosystem compatibility, or generated code volume.
Publisher's Version Article Search

Model and Program Transformation

Distributed Model-to-Model Transformation with ATL on MapReduce
Amine Benelallam, Abel Gómez, Massimo Tisi, and Jordi Cabot
(AtlanMod Team, France; ICREA, Spain; Open University of Catalonia, Spain)
Efficient processing of very large models is a key requirement for the adoption of Model-Driven Engineering (MDE) in some industrial contexts. One of the central operations in MDE is rule-based model transformation (MT). It is used to specify manipulation operations over structured data coming in the form of model graphs. However, being based on computationally expensive operations like subgraph isomorphism, MT tools are facing issues on both memory occupancy and execution time while dealing with the increasing model size and complexity. One way to overcome these issues is to exploit the wide availability of distributed clusters in the Cloud for the distributed execution of MT. In this paper, we propose an approach to automatically distribute the execution of model transformations written in a popular MT language, ATL, on top of a well-known distributed programming model, MapReduce. We show how the execution semantics of ATL can be aligned with the MapReduce computation model. We describe the extensions to the ATL transformation engine to enable distribution, and we experimentally demonstrate the scalability of this solution in a reverse-engineering scenario.
Publisher's Version Article Search
Managing Uncertainty in Bidirectional Model Transformations
Romina Eramo, Alfonso Pierantonio, and Gianni Rosa
(University of L'Aquila, Italy)
In Model-Driven Engineering bidirectionality in transformations is regarded as a key mechanism. Recent approaches to non-deterministic transformations have been proposed for dealing with non-bijectivity. Among them, the JTL language is based on a relational model transformation engine which restores consistency by returning all admissible models. This can be regarded as an uncertainty reducing process: the unknown uncertainty at design-time is translated into known uncertainty at run-time by generating multiple choices. Unfortunately, little changes in a model usually correspond to a combinatorial explosion of the solution space. In this paper, we propose to represent the multiple solutions in a intensional manner by adopting a model for uncertainty. The technique is applied to JTL demonstrating the advantages of the proposal.
Publisher's Version Article Search
Modular Capture Avoidance for Program Transformations
Nico Ritschel and Sebastian Erdweg
(TU Darmstadt, Germany)
The application of program transformations and refactorings involves the risk of capturing variables, which may break the intended semantics of the transformed code. One way to resolve variable capture is by renaming of the involved identifiers. However, in a modular context, the renaming of exported declarations is undesirable (affecting a module's clients), and the renaming of imported declarations is impossible (requiring changes to third-party modules). We present an algorithm name-fix that detects and eliminates variable capture modularly. We extend a previous non-modular version of name-fix in order to (i) minimize renamings of exported declarations, (ii) propagate necessary renamings of exported declarations to clients, and (iii) avoid renamings of imported declarations altogether. Together with support for transitive name bindings and conflicting declarations, our extensions to name-fix enable the application to real-world languages that feature separate compilation. To demonstrate the applicability of name-fix, we use it to modularly resolve variable capture for optimizations, refactorings, and desugarings of Lightweight Java.
Publisher's Version Article Search

Tools 1

XMLText: From XML Schema to Xtext
Patrick Neubauer, Alexander Bergmayr, Tanja Mayerhofer, Javier Troya, and Manuel Wimmer
(Vienna University of Technology, Austria)
A multitude of Domain-Specific Languages (DSLs) have been implemented with XML Schemas. While such DSLs are well adopted and flexible, they miss modern DSL editor functionality. Moreover, since XML is primarily designed as a machine-processible format, artifacts defined with XML-based DSLs lack comprehensibility and, therefore, maintainability. In order to tackle these shortcomings, we propose a bridge between the XML Schema Definition (XSD) language and text-based metamodeling languages. This bridge exploits existing seams between the technical spaces XMLware, modelware, and grammarware as well as closes identified gaps. The resulting approach is able to generate Xtext-based editors from XSDs providing powerful editor functionality, customization options for the textual concrete syntax style, and round-trip transformations enabling the exchange of data between the involved technical spaces. We evaluate our approach by a case study on TOSCA, which is an XML-based standard for defining Cloud deployments. The results show that our approach enables bridging XMLware with modelware and grammarware in several ways going beyond existing approaches and allows the automated generation of editors that are at least equivalent to editors manually built for XML-based languages.
Publisher's Version Article Search Info
Designing Languages using Lightning
Loïc Gammaitoni, Pierre Kelsen, and Christian Glodt
(University of Luxembourg, Luxembourg)
Modelling languages are defined by specifying their abstract syntax, concrete syntax and semantics. In the Lightning tool the definition of all these language components is based on the lightweight formal language Alloy. Lightning makes use of the powerful automatic analysis features of Alloy to allow language designers to develop and validate the definition of a modelling language in an incremental fashion. By providing immediate visual feedback, it allows errors in the language definition to be quickly identified and corrected. Furthermore Lightning introduces F-Alloy, a new Alloy based model transformation language. Transformations expressed in F-Alloy can be efficiently interpreted in Lightning. We illustrate the use of the tool on the language of structured business processes.
Publisher's Version Article Search Info
Analysis and Transformation with the Nuthatch Tree-Walking Library
Anya Helene Bagge
(University of Bergen, Norway)
Nuthatch is a system for traversing, collecting information from, and rewriting trees, based on the idea of tree walking. The main application is software analysis and transformation. Nuthatch traversals are non-recursive by default and independent of the concrete tree representation. We provide an extensible library, Nuthatch/J, for doing tree walking in Java, with adapters for interfacing with popular software transformation tools like Stratego/XT and Rascal. Transformations are described as walks that proceed in programmer-defined steps. Each step can perform actions based on observed properties of current node and walk, and affect state associated with the walk and also rewrite the walked tree. A step ends by walking to a different node in the tree, following the tree branches, and the walk ends by returning to the top.
Publisher's Version Article Search Info

Fomal Modeling and Language Validation

Reference Attribute Grammar Controlled Graph Rewriting: Motivation and Overview
Christoff Bürger
(Lund University, Sweden)
Reference attribute grammars are a well-known language engineering technique for the implementation of semantic analyses. Reference attributes provide declarative means to extend abstract syntax trees to graphs and analyse such graphs; they are well-suited to deduce and reason about abstract syntax graphs. Efficient attribute re-evaluation in case of abstract syntax graph changes and a systematic integration of attribute-based analyses with further rewrite-based transformations are open research problems however. To solve these problems, a novel incremental syntax-directed compiler-compiler technique is presented, that seamlessly combines reference attribute grammars and graph rewriting. The presented technique not only permits incremental reference attribute evaluation, but also the reuse of analyses to ease the specification of, and guide, rewrite-based transformations. It enables efficient, mutually dependent, memoized analyses and transformations. The paper motivates and explains the concepts of such a reference attribute grammar controlled graph rewriting. For evaluation, a reference implementation is used to specify fUML Activity Diagram and Petri net interpreters.
Publisher's Version Article Search Info
Example-Based Validation of Domain-Specific Visual Languages
Jesús J. López-Fernández, Esther Guerra, and Juan de Lara
(Autonomous University of Madrid, Spain)
The definition of Domain-Specific Languages (DSLs) is a recurrent activity in Model-Driven Engineering. However, their construction is many times an ad-hoc process, partly due to the lack of tools enabling a proper engineering of DSLs and promoting domain experts to play an active role. The focus of this paper is on the validation of meta-models for visual DSLs. For this purpose, we propose a language and tool support for describing properties that instances of meta-models should (or should not) meet. Then, our system uses a model finder to produce example models, enriched with a graphical concrete syntax, that confirm or refute the assumptions of the meta-model developer. Our language complements metaBest, a framework for the validation and verification of meta-models that includes two other languages for unit testing and specification-based testing of meta-models. A salient feature of our approach is that it fosters interaction with domain experts by the use, processing and creation of informal drawings constructed in editors liked yED or Dia. We assess the usefulness of the approach in the validation of a DSL for house blueprints, with the participation of 26 4th year computer science students.
Publisher's Version Article Search
A Combined Formal Model for Relational Context-Dependent Roles
Thomas Kühn, Stephan Böhme, Sebastian Götz, and Uwe Aßmann
(TU Dresden, Germany)
Role-based modeling has been investigated for over 35 years as a promising paradigm to model complex, dynamic systems. Although current software systems are characterized by increasing complexity and context-dependence, all this research had almost no influence on current software development practice, still being discussed in recent literature. One reason for this is the lack of a coherent, comprehensive, readily applicable notion of roles. Researchers focused either on relational roles or context-dependent roles rather then combining both natures. Currently, there is no role-based modeling language sufficiently incorporating both the relational and context-dependent nature of roles together with the various proposed constraints. Hence, this paper formalizes a full-fledged role-based modeling language supporting both natures. To show its sufficiency and adequacy, a real world example is employed.
Publisher's Version Article Search Info

Model Execution and Verification

Weaving Concurrency in eXecutable Domain-Specific Modeling Languages
Florent Latombe, Xavier Crégut, Benoit Combemale, Julien Deantoni, and Marc Pantel
(University of Toulouse, France; IRIT, France; University of Rennes 1, France; IRISA, France; INRIA, France; University of Nice Sophia Antipolis, France; CNRS, France)
The emergence of modern concurrent systems (e.g., Cyber- Physical Systems or the Internet of Things) and highly- parallel platforms (e.g., many-core, GPGPU pipelines, and distributed platforms) calls for Domain-Specific Modeling Languages (DSMLs) where concurrency is of paramount im- portance. Such DSMLs are intended to propose constructs with rich concurrency semantics, which allow system design- ers to precisely define and analyze system behaviors. How- ever, specifying and implementing the execution semantics of such DSMLs can be a difficult, costly and error-prone task. Most of the time the concurrency model remains implicit and ad-hoc, embedded in the underlying execution environ- ment. The lack of an explicit concurrency model prevents: the precise definition, the variation and the complete under- standing of the semantics of the DSML, the effective usage of concurrency-aware analysis techniques, and the exploitation of the concurrency model during the system refinement (e.g., during its allocation on a specific platform). In this paper, we introduce a concurrent executable metamodeling approach, which supports a modular definition of the execution seman- tics, including the concurrency model, the semantic rules, and a well-defined and expressive communication protocol between them. Our approach comes with a dedicated meta- language to specify the communication protocol, and with an execution environment to simulate executable models. We illustrate and validate our approach with an implementation of fUML, and discuss the modularity and applicability of our approach.
Publisher's Version Article Search Video Info
Supporting Efficient and Advanced Omniscient Debugging for xDSMLs
Erwan Bousse, Jonathan Corley, Benoit Combemale, Jeff Gray, and Benoit Baudry
(IRISA, France; University of Alabama, USA; INRIA, France)
Omniscient debugging is a promising technique that relies on execution traces to enable free traversal of the states reached by a system during an execution. While some General-Purpose Languages (GPLs) already have support for omniscient debugging, developing such a complex tool for any executable Domain-Specific Modeling Language (xDSML) remains a challenging and error prone task. A solution to this problem is to define a generic omniscient debugger for all xDSMLs. However, generically supporting any xDSML both compromises the efficiency and the usability of such an approach. Our contribution relies on a partly generic omniscient debugger supported by generated domain-specific trace management facilities. Being domain-specific, these facilities are tuned to the considered xDSML for better efficiency. Usability is strengthened by providing multidimensional omniscient debugging. Results show that our approach is on average 3.0 times more efficient in memory and 5.03 more efficient in time when compared to a generic solution that copies the model at each step.
Publisher's Version Article Search
Using Decision Rules for Solving Conflicts in Extended Feature Models
Lina Ochoa, Oscar González-Rojas, and Thomas Thüm
(University of Los Andes, Colombia; TU Braunschweig, Germany)
Software Product Line Engineering has introduced feature modeling as a domain analysis technique used to represent the variability of software products and decision-making scenarios. We present a model-based transformation approach to solve conflicts among configurations performed by different stakeholders on feature models. We propose the usage of a domain-specific language named CoCo to specify attributes as non-functional properties of features, and to describe business-related decision rules in terms of costs, time, and human resources. These specifications along with the stakeholders' configurations and the feature model are transformed into a constraint programming problem, on which decision rules are executed to find a non-conflicting set of solution configurations that are aligned to business objectives. We evaluate CoCo's compositionality and model complexity simplification while using a set of motivating decision scenarios.
Publisher's Version Article Search

Tools 2

The Whiley Rewrite Language (WyRL)
David J. Pearce
(Victoria University of Wellington, New Zealand)
The Whiley Rewrite Language (WyRL) is a standalone tool providing a domain-specific declarative rewrite language and code generator. The tool is currently used to generate a critical component of the Whiley verifying compiler, namely the automated theorem prover. The tool automatically generates Java source code from a given rule set. The runtime library provides support for different heuristics to control aspects of the generated system, such as the order in which rewrite rules are applied. Novel aspects of WyRL include support for true union types and the ability to work with cyclic terms.
Publisher's Version Article Search Info
Parsing Expression Grammars Made Practical
Nicolas Laurent and Kim Mens
(Université Catholique de Louvain, Belgium)
Parsing Expression Grammars (PEGs) define languages by specifying a recursive-descent parser that recognises them. The PEG formalism exhibits desirable properties, such as closure under composition, built-in disambiguation, unification of syntactic and lexical concerns, and closely matching programmer intuition. Unfortunately, state of the art PEG parsers struggle with left-recursive grammar rules, which are not supported by the original definition of the formalism and can lead to infinite recursion under naive implementations. Likewise, support for associativity and explicit precedence is spotty. To remedy these issues, we introduce Autumn, a general purpose PEG library that supports left-recursion, left and right associativity and precedence rules, and does so efficiently. Furthermore, we identify infix and postfix operators as a major source of inefficiency in left-recursive PEG parsers and show how to tackle this problem. We also explore the extensibility of the PEG paradigm by showing how one can easily introduce new parsing operators and how our parser accommodates custom memoization and error handling strategies. We compare our parser to both state of the art and battle-tested PEG and CFG parsers, such as Rats!, Parboiled and ANTLR.
Publisher's Version Article Search

proc time: 0.14