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.

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.

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.

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.

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.

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.

No abstract.

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.

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

There exist many formalisms for modeling the behavior of (software) systems. These formalisms serve different purposes. Process algebras are used for algebraic and axiomatic reasoning about the behavior of distributed systems. UML state machines are suitable for automatic software generation. We have developed a transformation from the process algebra ACP into UML state machines to enable automatic software generation from process algebra models. This transformation needs to preserve both behavioral and structural properties. The combination of these preservation requirements gives rise to a semantic gap. It implies that we cannot transform ACP models into UML state machines on a syntactic level only. We address this semantic gap and propose a way of bridging it. To validate our proposal, we have implemented a tool for automatic transformation of ACP process algebra models into UML state machines.

Model-driven engineering (MDE) refers to the systematic use of models as primary engineering artifacts throughout the engineering life cycle. In this chapter we will show how executable models can be used to aid the design process of a light control subsystem of a wafer scanner. We make an explicit distinction between the model of the application logic and the platform on which it is deployed. It will be shown how the performance of this subsystem can be predicted in an early phase of the design process, before the system is implemented in terms of hardware and software components. The executable model in addition allows a prototype software implementation to be derived from it automatically in a predictable way. The executable model is expressed in POOSL, a special-purpose modeling language targeting real-time embedded systems. To allow an embedding in a future MDE-environment, an experiment is performed to express a similar model in the general-purpose modeling language UML from which the executable models can be derived through model transformations. These transformations further allow one to combine an application model created in UML with a platform model created in POOSL and analyze this combined model.

We report on a project to use SGLR parsing and term rewriting with ELAN4 to extract the semantics of mathematical formulas from a TeX document and representing them in MathML. The TeX document we used is part of the Digital Library of Mathematical Functions (DLMF) project of the US National Institute of Standards and Technology (NIST) and obeys project-specific conventions, which contains macros for mathematical constructions, among them 200 predefined macros for special functions, the subject matter of the project. The SGLR parser can parse general context-free languages, which suffices to extract the structure of mathematical formulas from calculus that are written in the usual mathematical style, with most parentheses and multiplication signs omitted. The parse tree is then rewritten into a more concise and uniform internal syntax that is used as the base for extracting MathML or other semantical information.

In this paper we present the fusion of generalized LR parsing and scannerless parsing. This combination supports syntax definitions in which all aspects (lexical and context-free) of the syntax of a language are defined explicitly in one formalism. Furthermore, there are no restrictions on the class of grammars, thus allowing a natural syntax tree structure. Ambiguities that arise through the use of unrestricted grammars are handled by explicit disambiguation constructs, instead of implicit defaults that are taken by traditional scanner and parser generators. Hence, a syntax definition becomes a full declarative description of a language. Scannerless generalized LR parsing is a viable technique that has been applied in various industrial and academic projects.

The Asf+Sdf Meta-Environment is an interactive development environment for the automatic generation of interactive systems for constructing language definitions and generating tools for them. Over the years, this system has been used in a variety of academic and commercial projects ranging from formal program manipulation to conversion of COBOL systems. Since the existing implementation of the Meta-Environment started exhibiting more and more characteristics of a legacy system, we decided to build a completely new, component-based, version. We demonstrate this new system and stress its open architecture.

This paper describes the development of a new \elan\ parser using \asdf\ parsing technology. \asdf\ and \elan\ are two modern rule-based systems. Both systems have their own features and application domains, however, both formalism have user-defined syntax for defining rewrite rules. The \asdf\ Meta-Environment uses powerful and efficient generic parsing tools, whereas the \elan\ parser is based on an Earley parser. Furthermore, the \elan\ syntax is ``hard-wired'''' in the parser, which makes adaptations of the syntax cumbersome. The use of \asdf\ parsing technology makes the \elan\ syntax more open and adaptable, however, some features of the \elan\ syntax makes the development of a parser a challenging problem.