Search

In safety-critical domains, conceptual models are created in the form of metamodels using different concepts from possibly overlapping domains. Comparison between those conceptual models can facilitate the reuse of models from one domain to another. This paper describes the mappings detected when comparing metamodels and models used for safety assurance. We use a small use case to discuss the mappings between metamodels and models, and the relations between model elements expressed in mappings. Finally, an illustrative case study is used to demonstrate our approach.

Open source software (OSS) development communities are typically very specialised, on the one hand, and experience high turnover, on the other. Combination of specialization and turnover can cause parts of the system implemented in a certain programming language to become unmaintainable, if knowledge of that language has disappeared together with the retiring developers. Inspired by measures of linguistic diversity from the study of natural languages, we propose a method to quantify the risk of not having maintainers for code implemented in a certain programming language. To illustrate our approach, we studied risks associated with different languages in Emacs, and found examples of low risk due to high popularity (e.g., C, Emacs Lisp); low risk due to similarity with popular languages (e.g., C++, Java, Python); or high risk due to both low popularity and low similarity with popular languages (e.g., Lex). Our results show that methods from the social sciences can be successfully applied in the study of information systems, and open numerous avenues for future research.

Small languages are gaining popularity in the software engineering community. The development of MOF and EMF has given the Domain Specific Language community a tremendous boost. In this tutorial the basic aspects of model driven engineering in combination with Domain Specific Languages will be discussed. The focus is on textual Domain Specific Languages developed using the language invention pattern. The notion of abstract syntax will be linked to metamodels as well as the definition of concrete syntax. Defining static and dynamic semantics will be discussed. A small but non trivial Domain Specific Language SLCO will be used to illustrate our ideas.

A formal definition of the semantics of a domain-specific language (DSL) is a key prerequisite for the verification of the correctness of models specified using such a DSL and of transformations applied to these models. For this reason, we implemented a prototype of the semantics of a DSL for the specification of systems consisting of concurrent, communicating objects. Using this prototype, models specified in the DSL can be transformed to labeled transition systems (LTS). This approach of transforming models to LTSs allows us to apply existing tools for visualization and verification to models with little or no further effort. The prototype is implemented using the ASF+SDF Meta-Environment, an IDE for the algebraic specification language ASF+SDF, which offers efficient execution of the transformation as well as the ability to read models and produce LTSs without any additional pre or post processing., In Proceedings AMMSE 2011, arXiv:1106.5962

Graphical diagrams are the main modelling constructs offered by the popular modelling language UML. Because textual representations of models also have their benefits, we investigated the integration of textual and graphical modelling languages, by comparing two approaches. One approach uses grammarware and the other uses modelware. As a case study, we implemented two versions of a textual alternative for Activity Diagrams, which is an example of a surface language. This paper describes our surface language, the two approaches, and the two implementations that follow these approaches. Keywords: Grammarware; modelware; surface language.

We present an overview of rewriting-based systems that were presented at the workshop.

In this paper we propose a technique to automate the process of building translators between operations languages, a family of DSLs used to program satellite operations procedures. We exploit the similarities between those languages to semi-automatically build a transformation schema between them, through the use of annotated grammars. To improve the overall translation process even more, reducing its complexity, we also propose an intermediate representation common to all operations languages. We validate our approach by semi-automatically deriving translators between some operations languages, using a prototype tool which we implemented for that purpose.

Generic language technology research focuses on the development of fundamental techniques for language processing. The Asf+Sdf Meta-Environment, an interactive development environment for the automatic generation of interactive systems, is an example of research in this field. The Meta-Environment has been applied in various projects in order to enable the development of high quality tools for the analysis and transformation of large software systems written in languages such as C, Java, Cobol, and PL/I. The Meta-Environment offers the interactive construction of language definitions and the generation of tools given these definitions. Over the years, this system has been used in a variety of academic and industrial projects ranging from formal program manipulation to conversion of industrial Cobol systems.

An environment for the Common Algebraic Specification Language CASL consists of several independent tools. A number of CASL tools have been built using the algebraic specification formalism ASF+SDF and the ASF+SDF Meta-Environment. CASL supports user-defined syntax which is non-trivial to process: ASF+SDF offers a powerful parsing technology (Generalized LR). Its interactive development environment facilitates rapid prototyping complemented by early detection and correction of errors. A number of core technologies developed for the ASF+SDF Meta-Environment can be reused in the context of CASL . Furthermore, an instantiation of a generic format developed for the representation of ASF+SDF specifications and terms provides a CASL -specific exchange format.

Safety assurance or certification is one of the most costly and time-consuming tasks in automotive, railway, avionics, and other safety-critical domains. Different transport sectors have developed their own specific sets of safety standards, which creates a big challenge to reuse pre-certified components and share expertise between different transport sectors. In this paper, we propose to use conceptual models in the form of metamodels to support certification data reuse and facilitate safety compliance. A metamodel transformation approach is outlined to derive domain or project specific metamodels using a generic metamodel as basis. Furthermore, we present a metamodel refinement language, which is a domain-specific language that facilitates simple refinement of metamodels. Finally, we use two case studies from the automotive domain to demonstrate our approach and its ability to reuse metamodels across companies. Keywords: Conceptual Model; Metamodel; Safety Assurance; Safety-Critical Systems; Metamodel transformation

We present work in progress on, verified, transformation of a modeling language based on communicating concurrent state machines, SLCO, to Java. Some concurrency related challenges, related to atomicity and non-standard fairness issues, are pointed out. We discuss solutions based on Java synchronization concepts.

Embedded systemen bestaan uit hardware en software en sluiten 100 procent aan bij de topsector High Tech Systemen en Materialen. Software engineering is essentieel voor embedded systemen – en we blinken er in uit,’ zegt Mark van den Brand van de TU Eindhoven naar aanleiding van het hoofdstuk How can embedded systems make our environment smart? uit The scientific answer to the roadmap ICT for the top sectors. Door Leendert van der Ent

Architecture views have long been used in software industry to systematically model complex systems by representing them from the perspective of related stakeholder concerns. However, consensus has not been reached for the architecture views between automotive architecture description languages and automotive architecture frameworks. Therefore, this paper presents the automotive architecture views based on an elaborate study of existing automotive architecture description techniques. Furthermore, we propose a method to formalize correspondence rules between architecture views to enforce consistency between architecture views. The approach was implemented in a Java plugin for IBM Rational Rhapsody and evaluated in a case study based on the Adaptive Cruise Control system. The outcome of the evaluation is considered to be a useful approach for formalizing correspondences between different views and a useful tool for automotive architects.

International audience; In this paper we present an approach to specifying opera- tor precedence based on declarative disambiguation constructs and an implementation mechanism based on grammar rewriting. We identify a problem with existing generalized context-free parsing and disambigua- tion technology: generating a correct parser for a language such as OCaml using declarative precedence specification is not possible without resorting to some manual grammar transformation. Our approach provides a fully declarative solution to operator precedence specification for context-free grammars, is independent of any parsing technology, and is safe in that it guarantees that the language of the resulting grammar will be the same as the language of the specification grammar. We evaluate our new approach by specifying the precedence rules from the OCaml reference manual against the highly ambiguous reference grammar and validate the output of our generated parser.

In this paper we describe our experience in applying the Event-B formalism for specifying the dynamic semantics of a real-life industrial DSL. The main objective of this work is to enable the industrial use of the broad spectrum of specification analysis tools that support Event-B. To leverage the usage of Event-B and its analysis techniques we developed model transformations, that allowed for automatic generation of Event-B specifications of the DSL programs. The model transformations implement a modular approach for specifying the semantics of the DSL and, therefore, improve scalability of the specifications and the reuse of their verification. Keywords: domain specific language, Event-B, model transformations, verification and validation, reuse, scalability

Software engineers are humans and so they make lots of mistakes. Typically 1 out of 10 to 100 tasks go wrong. The only way to avoid these mistakes is to introduce redundancy in the software engineering process. This article is a plea to consciously introduce several levels of redundancy for each programming task. Depending on the required level of correctness, expressed in a residual error probability (typically 10-3 to 10-10), each programming task must be carried out redundantly 4 to 8 times. This number is hardly influenced by the size of a programming endeavour. Training software engineers does have some effect as non trained software engineers require a double amount of redundant tasks to deliver software of a desired quality. More compact programming, for instance by using domain specific languages, only reduces the number of redundant tasks by a small constant.

As more and more complex software is deployed in safety-critical embedded systems, the challenge of assessing the safety of those systems according to the relevant standards is becoming greater. Due to the extensive manual work required, validating compliance of these systems with safety standards is an expensive and time-consuming activity; furthermore, as products evolve, re-assessment may become necessary. Therefore, obtaining reusable assurance data for safety assessment or re-assessment is very desirable. In this paper, we propose a model-based approach for assuring compliance with safety standards to facilitate reuse in the assessment, qualification and certification processes, using the automotive safety standard ISO 26262 as a specific example. Three different modeling techniques are described: A structure model is introduced to describe the overall structure of the standard; a rule-based technique is used for extracting the conceptual model from it; and a mapping to the software and systems process engineering metamodel provides a description of its processes. Finally, validation in the context of a concrete use case in the FP7 project OPENCOSS shows that the resulting models of our approach resemble the industrial models, but that they, inevitably, require the fine-tuning of domain experts.

Software plays an important role in designing and operating warehouses. However, traditional software engineering methods for designing warehouse software are not able to cope with the complexity, size, and increase of automation in modern warehouses. This chapter describes Model-Driven Software Engineering (MDSE), a discipline aimed at dealing with the increased complexity of software by focusing on the problem domain rather than on the solution domain. In warehouse design, this is achieved by using formal models to describe warehouses, and by using model transformations to transforms those models to, e.g. source code. MDSE relies on tools more than traditional software engineering. Thus, to reap the full benefits of MDSE, tools for developing, managing, and transforming models should be designed, implemented, used, and validated.

Today, when constructing a new software system, many developers build their systems on top of frameworks. Eclipse is such a framework that has been in existence for over a decade and has so far released 11 major releases. Like many other evolving software systems, the Eclipse platform has both stable and supported APIs ("good") and unstable, discouraged and unsupported non-APIs ("bad"). However, despite being discouraged by Eclipse, on our experience, the usage of "bad" APIs is relatively common in practice. In this paper, we study to what extent developers depend on "bad" non-APIs. We also study whether developers continue to use "bad" APIs, and what are the differences between the third-party plug-ins that use non-APIs and those that do not. Furthermore, we also study the commonly use "bad" APIs. To answer these questions, we have conducted an empirical investigation based on a total of 512 Eclipse third-party plug-ins, altogether having a total of 1,873 versions. We discovered that 44% of the 512 analyzed Eclipse third-party plug-ins depends on "bad" non-APIs and that developers continue to use "bad" non-APIs. The empirical study also shows that plug-ins that use or extend at least one "bad" non-API are comparatively larger and use more functionality from Eclipse than those that use only "good" APIs. Furthermore, the findings show that the third-party plug-ins use a diverse set of "bad" APIs. Keywords: Eclipse; Third-party plug-ins; APIs; non-APIs.

We present an approach to model hardware configurations of complex manufacturing systems such as ASML's lithography machines. These hardware configurations consist of actuator and sensor elements which are controlled by system software that consists of over 35 million lines of code. To minimize the cost of testing and system integration, software simulators of hardware configurations are used - acting as virtual hardware platforms on which the real control software can be executed and tested. An important aspect in such simulation and testing is material flow (specifically wafer flow) in the machine. To support the effective and efficient realization of simulators covering material flow, we defined a domain specific language (DSL) for modelling the hardware configurations to be simulated, and used a model-driven engineering approach to generate the software components implementing the simulators. The DSL can be used to specify not only nominal (i.e. good weather) behaviour but also simulation based fault injection scenarios. The overall approach reduces the cost of early hardware-software integration and enables simulating scenarios that cannot be executed on real machines because they are difficult or hazardous to carry out.

Empirical evidence shows that the use of model driven software engineering can result in an up to 10-fold quality improvement and decreased development time. Researchers from Eindhoven University of Technology tested this on a detector control system at CERN. This brings Turing’s vision of software another step closer.

Model transformations are commonly used to transform models suited for one purpose (e.g., describing a solution in a particular domain) to models suited for a related but different purpose (e.g., simulation or execution). The disadvantage of a transformational approach, however, is that feedback acquired from analyzing transformed models is not reported on the level of the problem domain but on the level of the transformed model. Expressing the feedback on the level of the problem domain requires improving traceability in model transformations. We propose to visualize traceability links in (chains of) model transformations, thus making traceability amenable for analysis.

Correctness of model transformations is a prerequisite for generating correct implementations from models. Given refining model transformations that preserve desirable properties, models can be transformed into correct-by-construction implementations. However, proving that model transformations preserve properties is far from trivial. Therefore, we aim for simple correctness proofs by designing model transformations that are as fine-grained as possible. Furthermore, we advocate the reuse of model transformations to reduce the number of proofs. For a simple domain-specific language, SLCO, we define a formal framework to reason about the correctness, reusability, and composition of the fine-grained model transformations used to transform a given model to three target languages: NQC, Promela and POOSL. The correctness criterion induces that the original model and the resulting model obtained after a proper sequence of transformations have the same observable behavior.

Model transformations play a pivotal role in model-driven engineering. Since they are in many ways similar to traditional software artifacts, they have to be treated similarly. Therefore, it is necessary to assess their quality. We propose to use metrics to assess various quality attributes of model transformations In this paper, we focus on model transformations created using ATL, which ATL is currently one of the most widely used model transformation formalisms. We have collected metrics data from a heterogeneous collection of seven model transformations. The quality of the same transformations has been evaluated manually by nineteen ATL experts. We assess whether the metrics are appropriate predictors for the quality attributes by correlating the metrics data with the expert data. To support or refute the correlations, we also acquired qualitative statements from the ATL experts. Although the study was intended as a first exploration of the relation between metrics and quality attributes, some significant correlations were found that are supported by statements of the participants.

Model-driven engineering (MDE) is a software engineering discipline that is gaining popularity, both in academia and industry. One of the integral concepts of MDE is model transformation. The prominent role of model transformations in MDE requires them to be treated in a similar way as traditional software artifacts. Numerous analysis techniques supporting the maintenance process exist for traditional software artifacts. However, few techniques tailored towards analyzing model transformations currently exist. We present in this paper three complementary techniques for the analysis of model transformations. These techniques are mainly focused on increasing the understanding of model transformations. Two of the proposed techniques have already been employed for the analysis of different kinds of software artifacts, viz. metrics, and structure and trace analysis. The third analysis technique, i.e., metamodel coverage analysis is specific for model transformations and does therefore not exist for different kinds of software artifacts.

In this paper we discuss, and provide a generic solution to the problem referred to as model co-evolution: How to evolve models in case their metamodels evolve? We solve this problem by extending a traditional three-step approach. In the first step, differences between an original and an evolved metamodel are determined. Unlike traditional approaches, we treat metamodels as models conforming to a special metamodel, thus the same difference representation and calculation mechanisms for metamodels as for models are used in our approach. In the second step, metamodel differences are classified into four groups based on their possible influence on co-evolving models, and the possibilities of handling them automatically. We adopt two of these groups (non-breaking and breaking and resolvable differences) from the existing co-evolution approaches, and we introduce two new groups (breaking and semi-resolvable and breaking and human-resolvable differences). In the third step, based on the determined metamodel differences, a generic co-evolution transformation is invoked. This transformation takes the metamodel differences, and a model as arguments, and returns an adapted model. We validated our approach by incorporating our method into a prototype tool for generic model co-evolution, and by testing this tool on a large set of metamodels and models.

No abstract.

Model comparison includes three major concerns: presentation, calculation, and visualization of model differences. In this paper we address the concern of visualization of model differences in the context of model configuration management systems. Since models are considered the main artifacts in model configuration management systems, we require that the differences between models are represented by means of a differences model, which conforms to a differences metamodel. The traditional approaches to visualization of model differences based on a textual, tree-like, or even diagrammatic representation of differences do not scale well in the presence of large differences models. The cause for this is that it gets harder to comprehend the meaning of differences as the size of the differences models increase. We focus on this problem and propose a solution that extends and combines two existing approaches, namely polymetric views and a generic visualization framework for metamodel-based languages. Polymetric views offer good overview, zoom, and filtering capabilities. A visualization framework for metamodel-based languages is used to visualize differences details. By using the combination of these two approaches, it becomes easier to comprehend the meaning of differences even in large models. This paper describes both the details of our solution, and a generic tool that implements the described solution.

The original publication is available at www.springerlink.com; International audience; This paper presents the main results and conclusions of the Third Rewrite Engines Competition (REC III). This edition of the competition took place as part of the 8th Workshop on Rewriting Logic and its Applications (WRLA 2010), and the systems ASF+SDF, Maude, Stratego/XT, Tom, and TXL participated in it.

The product line engineering approach is receiving a broad interest to decrease the cost of development and time to market, and to increase product quality as software becomes more and more important for companies in all markets. Although a significant amount of research has been done to define a method for introducing product line engineering in an organization, these methods are limited when a product line stretches over time. When stretching a product line, the evolution of a product line and its products may require fundamental change of the software architecture and consequently result in discontinuous evolutions. In this paper, we discuss the issues of software architecture with respect to discontinuing evolution and present an economic model based on the architecture preservation core concept to influence the product line stretching decision.

One of the key concepts of model-driven engineering (MDE) is model transformation. Because of the crucial role of model transformations in MDE, they have to be treated in a similar way as traditional software artifacts. It is therefore necessary to define and assess their quality. In this paper we present three metric sets for assessing the quality of ATL, QVTO, and Xtend model transformations. We show the overlap between the metric sets, as well as their differences.

In this paper we consider two major concerns in the process of comparing two models -- representation and calculation of model differences. Based on previous work, we adopt a set of requirements which a difference representation should satisfy in order to be seamlessly used in Model Driven Engineering environments. Given these requirements, we represent model differences by means of a differences model, which conforms to a differences metamodel. We show that the traditional meta-modeling approaches, which conform to the four-layered meta-modeling architecture, lack means for the specification of differences metamodels which fully satisfy the specified requirements. Consequently, we specify a metametamodel which offers a different view on the traditional metamodeling approaches and we use it to define the differences metamodel which fully satisfies the specified requirements. Traditional approaches to difference calculation consider models as trees, and use the structure provided by these trees to guide the calculation process. The calculation algorithms used in those approaches are based on matching elements in one model to elements in another model by using one of the following four types of matching: static-identity, signature-based, similarity-based, and language-specific. We adopt the same philosophy, but unlike the traditional approaches which have a fixed calculation algorithm and a fixed matching type, we provide a calculation algorithm that is highly configurable and is designed such that all four traditional types of matching can be used together. As a proof-of-concept we have implemented a tool which allows representation, calculation, and visualization of model differences.

While software metrics are commonly used to assess software maintainability and study software evolution, they are usually defined on a micro-level (method, class, package). Metrics should therefore be aggregated in order to provide insights in the evolution at the macro-level (system). In addition to traditional aggregation techniques such as the mean, recently econometric aggregation techniques such as the Gini index and the Theil index have been proposed. Advantages and disadvantages of different aggregation techniques have not been evaluated empirically so far. In this paper we present the preliminary results of the comparative study of different aggregation techniques.

The objective of the 1st International Workshop on Advanced Software Development Tools and Techniques (WASDeTT-1) was to provide interested researchers with a forum to share their tool building experiences and to explore how tools can be built more effectively and efficiently. The theme for this workshop did focus on tools that target object-oriented languages and that are implemented with object-oriented languages. This workshop report provides a brief overview of the presented tools and of the discussions that took place. The presented tools, 15 in total, covered a broad range of functionalities, among them: refactoring, modeling, behavioral specification, static and dynamic program checking, user interface composition, and program understanding. The discussion during the workshop centered around the following topics: language independent tools, tool building in an industrial context, tool building methodology, tool implementation language, and building tools with external code.

Since their introduction in 1994 the Martin's metrics became popular in assessing object-oriented software architectures. While one of the Martin metrics, normalised distance from the main sequence Dn, has been originally designed with assessing individual packages, it has also been applied to assess quality of entire software architectures. The approach itself, however, has never been studied. In this paper we take the first step to formalising the Dn-based architecture assessment of Java open source software. We present two aggregate measures: average normalised distance from the main sequence Dmacrn, and parameter of the fitted statistical model lambda. Applying these measures to a carefully selected collection of benchmarks we obtain a set of reference values that can be used to assess quality of a system architecture. Furthermore, we show that applying the same measures to different versions of the same system provides valuable insights in system architecture evolution.

The normalized distance from the main sequence, denoted D_n, is a popular object-oriented metric introduced by Martin in 1994. While the metric has been designed for assessment of individual packages it has also been applied in practice to quality assessment of entire software architectures. This gap between the industrial practice and theoretical understanding has been recently addressed for Java open-source systems. Based on study of a benchmarks collection the authors proposed a statistical model characterizing (a) the average value of D_n, and (b) distribution of D_n. Contribution of the current work is twofold. First, we show feasibility of application of the D_n-based assessment above to commercial Java applications. Second, we validate the approach by showing that the results obtained are consistent with those obtained by means of a series of independent studies, such as layering, presence of cyclic dependencies and Chidamber's and Kemerer's metrics.

Evolution of programming languages requires co-evolution of static analysis tools designed for these languages. Traditional approaches to static analysis, e.g., those based on Structural Operational Semantics (SOS), assume, however, that the syntax and the semantics of the programming language under consideration are fixed. Language modification is, therefore, likely to cause redevelopment of the analysis techniques and tools. Moreover, the redevelopment cost can discourage the language engineers from improving the language design. To address the co-evolution problem we suggest to base static analyses on modular structural operational semantics (MSOS). By using an intrinsically modular formalism, type rules can be added, removed or modified easily. We illustrate our approach by developing an MSOSbased type analysis technique for Chi, a domain specific language for hybrid systems engineering.

One of the key points of model-driven engineering is raising the level of abstraction in software development. This phenomenon is not new. In the sixties of the previous century, the first high-level programming languages were developed and they also increased the abstraction level of software development. The development of high-level programming languages initiated research on compilers and programming environments. This research eventually matured into generic language technology: the description of (programming) languages and tooling to generate compilers and programming environments. The model-driven engineering community is developing tools to analyze models and to transform models into code. The application of generic language technology, or at least the lessons learnt by this community, can be beneficial for the model-driven engineering community. By means of a number of case studies it will be shown how generic language technology research can be useful for the development of model-driven engineering technology.

International audience; The 2nd Rewrite Engines Competition (REC) was celebrated as part of the 7th Workshop on Rewriting Logic and its Applications (WRLA 2008). In this edition of the competition participated five systems, namely ASF+SDF, Maude, Stratego/XT, Termware, and Tom. We explain here how the competition was organized and conducted, and present its main results and conclusions.

In this paper we present a novel approach to assess system design quality by means of automatically computed metrics based on source code. We have used in-house reverse engineering tool to extract UML diagrams, class, sequence and activity, from C++ code. These extracted UML diagrams represent the system design and can be used to compute metrics indicating the quality of the system design. The metrics can be visualized in e.g. 3-dimensional way. Besides, we describe two case studies: one to compare existing system design with automatically generated system design and the industrial case study that helped to reveal bad smells in system design.

Analysis of legacy code is often focussed on extracting either metrics or relations, e.g. call relations or structure relations. For object-oriented programs, e.g. Java or C++ code, such relations are commonly represented as UML diagrams: e.g., such tools as Columbus [1] and Cpp2XMI [2] are capable of extracting from the C++ code UML class, and UML class, sequence and activity diagrams, respectively. New challenges in UML diagram extraction arise when a) additional UML diagrams and b) non-object-oriented programs are considered. In this paper we present an ongoing work on extracting state machines from the legacy C code, motivated by the popularity of state machine models in embedded software [3]. To validate the approach we consider an approximately ten-years old embedded system provided by the industrial partner. The system lacks up-to-date documentation and is reportedly hard to maintain.

Model transformations become increasingly important with the emergence of model driven engineering of, amongst others, objectoriented software systems. It is therefore necessary to define and evaluate the quality of model transformations. The goal of our research is to make the quality of model transformations measurable. This position paper presents the first results of this ongoing research. We present the quality attributes we have identified thus far and a set of metrics to assess these quality attributes.

NO ABSTRACT