Domain Specific Languages (DSLs) are languages specialized for particular application domains. Examples include SQL (querying), LaTeX (document preparation), MatLab (technical computing) and Excel (spreadsheets) etc. The goal of DSLs is to improve productivity and quality in software construction, by employing high-level notations that are closer to the problem domain. In this talk I will motivate DSLs from a general software engineering pespective and highlight some implementation strategies.
In this talk we explain what the construction of a DSL entails, when implemented using Rascal. This includes parsing, static analysis, code generation and IDE support. We assume that you want to experiment early, interacting with your new (textual) DSL, such that the design can be improved on-the-fly. DSL construction may be conceptually hard, but Rascal provides practical solutions for actually programming the necessary tools.
In the past five years language workbenches have moved from vision to reality. Using several language workbenches it is now possible to build software languages and their integrated development environments with limited effort. In this talk I will give an overview of the typical ingredients of language workbenches based on the Spoofax Language Workbench developed at TU Delft. Following, I will outline a research agenda for further development of language workbenches.
Digital forensics investigations make heavy use of software. This software needs to be fast and scalable, but at the same time support just-in-time modifications. We have developed a model-driven application architecture to address these needs. This includes Derric, a domain-specific language for describing file formats. In this talk we will discuss our recent research results.
In model-driven engineering, evolution is inevitable over the course of the complete life cycle of complex software-intensive systems and more importantly of entire product families. Not only instance models, but also entire modelling languages are subject to change. This is in particular true for domain-specific languages, whose language constructs are tightly coupled to an application domain.
The most popular approach to evolution in the modelling domain is a manual process, with tedious and error-prone migration of artefacts such as instance models as a result. In this presentation, a taxonomy for evolution of modelling languages will be proposed.
The different evolution scenarios for various kinds of modelling artefacts, such as instance models, meta-models, and transformation models will be discussed. Subsequently, the consequences of evolution and the required remedial actions will be decomposed into primitive scenarios such that all possible evolutions can be covered exhaustively. These primitives are then used in a high-level framework for the evolution of modelling languages.
The presentation will use a simple railroad network domain-specific language as a running example.
Spreadsheets are often used in business, for simple tasks as well as for mission critical tasks such as finance or forecasting. Similar to software, some spreadsheets are of better quality than others, for instance with respect to usability, maintainability or reliability.
In contrast with software how-ever, spreadsheets are rarely checked, tested or certified. In this talk, we present an approach for detecting spreadsheet smells that indicate weak points in a spreadsheet's design. These smells are based on the work Martin Fowler did on code smells; especially on the smells with respect to the coupling between classes. We studied these code smells and transformed them to their spreadsheet counterparts. Subsequently we have developed an approach to detect and visualize these smells. This visualization is based on our previous work that extracts dataflow diagrams from spreadsheets.
To evaluate our list of inter-worksheet smells, we have 1) analyzed the Euses corpus, a well-known research set of spreadsheets and 2) conducted ten case studies in an industrial setting.
The results of the evaluation indicate that smells can indeed reveal weaknesses in a spreadsheet's design, and that data flow diagrams are an appropriate way to show those weaknesses to spreadsheet users.
Embedding a domain-specific language inside a general-purpose programming language is a powerful implementation approach. This talk will discuss the strengths and weaknesses of the embedding approach. Examples will be given using a language for probabilistic generative modelling which is embedded in the Scala programming language.
Grammars are a well-researched approach to model software languages (general purpose programming languages, markup languages, domain specific languages, data description languages, etc). During this talk, we will discuss how automated programmable grammar transformations can be used to treat grammars as first-class artefacts in software engineering. Examples of maintenance and evolution scenarios will be provided, ranging from correcting grammars recovered from unreliable sources to architectural modifications of available grammars.
ASML is the world's leading provider of complex lithography systems for the semiconductor industry. Such systems consist of numerous control loop systems to control, for instance, the 6-DOF positioning of a 15 kg wafer positioning module with nanometer accuracy at Formula 1 acceleration. This results in tight hard real-time requirements on their implementation. These control systems are developed according to the control architecture reference model CARM that consists of different layers to describe the control logic in terms of (interconnected) servo networks of elementary sensor, actuator, and control blocks; the (relevant subset of) execution platform of a lithoscanner and the mapping of the control blocks to the execution platform, at different levels of abstraction. Domain specific languages (DSLs) have been developed covering the layers described in CARM. The models specified using these DSLs form the basis
This talk describes TRE, a novel framework for comparing transformation approaches systematically. It applies this framework to classify existing comparative studies and fills an important gap by contributing a study based on a previously unstudied type of transformation problem. The study is based on best-of-breed implementations of a complex transformation of process models (i.e., petri-nets and statecharts). By relying on qualitative as well as quantitative comparison criteria and by making all solutions available for online replay, we illustrate that in this context rule-based transformation languages are superior to general purpose programming languages from multiple perspectives. Especially since our results demonstrate that better runtime performance can be achieved using less specification effort, they may significantly influence the adoptance of graph and model transformation approaches in research and industry. For this talk, we do not assume specific prior knowledge on specific model transformation approaches but the ambitious attendee is encouraged to check the MODELS 2010 results that we are extending in this talk.
Within the context of the functional language Haskell and the Helium compiler, we discuss an approach that allows the EDSL designer to tailor the type error messages of the compiler to be phrased in terms of the domain, by specifying refined type rules for the operations provided in the EDSL. The refined type rules are automatically checked for soundness with respect to the intrinsic type system of the host language, and no knowledge of the internals of the compiler on the part of the EDSL designer is required . Moreover, the designer can anticipate mistakes made by programmers and have the compiler provide suggestions to fix type error inconsistencies.
In the past few years, the Software Engineering and Technology group has developed a Simple Language for Communicating Objects (SLCO), to serve as the central language in a case study on model-driven software engineering. The language started out as a UML look-alike that could be used for performance analysis via a transformation to POOSL. Later on, we investigated the verification of SLCO models using SPIN, and the automated generation of fully functioning implementations in Not Quite C (NQC). The transformations from SLCO to POOSL and SPIN are relatively straightforward, but the chain of transformations to NQC is not. There are quite a number of differences between the simple modeling language SLCO and the low-level implementation language NQC. Each of the gaps between the two languages is bridged by parts of the chain of transformations to NQC. Recently, we have focused on proving that each of these transformations is correct. Although it is easy to show that the transformations preserve behavior for specific models, it is a challenge to prove this in general. This presentation will introduce SLCO, its development, the various ways in which it is used, and the current state of affairs.
Modeling is a common part of modern day software engineering practice. Little is known about how models are made and how they help in producing better software. In this talk I will present highlight from the last decade of research that I have performed in the area of software modeling using UML. Topics that will be addressed: What is the state of UML modeling in practice? How can we assess the quality of UML models? How do engineers look at UML models? Do UML models actually help in creating better software?
Today's complex systems require software architects to address a large number of quality properties. These quality properties can be conflicting. In practice, software architects manually try to come up with a set of different architectural designs and then try to identify the most suitable one. This is a time-consuming and error-prone process. Also this may lead the architect to suboptimal designs. To tackle this problem, we propose an automated approach. The approach aids architects by automatically synthesizing optimal solutions by using multi-objective evolutionary algorithms and supporting various degrees of freedom in architectural variation.
Model transformations are increasingly being incorporated in software development processes. However, as systems being developed with transformations that grow in size or complexity, the performance of the transformations tends to degrade. This talk investigates the factors that can have an impact on the execution performance of model transformations. The performance of three model transformation language engines, namely ATL, QVT Operational Mappings and QVT Relations are compared. In addition a 'baseline' implementation written in Java is used to estimate the overhead introduced by the transformation engines. The obtained results enable a transformation designer to estimate on beforehand the performance of a transformation, and to choose among implementation alternatives to achieve the best performance. The talk also indicates some performance problems with the current transformation engines.
Over the last decade, Architecture Description Languages (ADLs) are attracting considerable attention of automotive companies because they consider them as one of the key solutions to improve the quality of automotive electronic and software systems. Automotive ADLs like EAST-ADL, AADL, TADL, and AML are being defined to address not only the architectural description or the representation issues but also to provide a method to enable requirements traceability and early analysis of a system. Besides the automotive specific ADLs, SysML and MARTE are emerging as viable modeling languages for automotive systems engineering. In this talk, we present the evaluation of the automotive architecture description methods and share the lessons learned from the industrial case study highlighting the advantages and drawbacks of existing automotive ADLs and future challenges.
The Software Architecture field has witnessed a paradigm shift, where architecture decisions and their rationale became the focus of attention. In this talk, we introduce a documentation framework for architecture decisions. This framework consists of five viewpoint definitions using the conventions of ISO/IEC 42010: a Decision Detail viewpoint, a Decision Relationship viewpoint, a Decision Chronology viewpoint, a Decision Stakeholder Involvement viewpoint and a Decision Forces viewpoint. Each viewpoint satisfies several stakeholder concerns related to architecture decision management. With the exception of the Decision Stakeholder Involvement viewpoint, the framework was evaluated in several industrial case studies. The results are promising, as they show that decision views are a documentation format, which is well received by practitioners, satisfying many stakeholder concerns in decision documentation. Our latest studies have shown that some of the viewpoints also support architects in following a more rational decision-making process.