van den Mgj Mark Brand

Analyzing the Eclipse API Usage: Putting the Developer in the Loop

Eclipse guidelines distinguish between two types of interfaces provided to third-party developers, i.e., APIs and non-APIs. APIs are stable and supported, while non-APIs are unstable, unsupported and discouraged as they are subject to arbitrary change or removal without notice. In our previous work, we found that despite the discouragement of Eclipse, the use of non-APIs in Eclipse third-party plug-ins (ETPs) is not uncommon. Furthermore, we found that these non-APIs are the main cause of ETP incompatibilities in forthcoming releases of the Eclipse. In the current work we conducted a survey aiming at understanding why do the ETP developers use non-APIs. We have observed that developers with a level of education of up to master degree have a tendency not to read product manuals/guidelines. Furthermore, while for less experienced developers instability of the non-APIs overshadows their benefits, more experienced developers prefer to enjoy the benefits of non-APIs despite the instability problem. Finally, we have observed that there are no significant differences between Open Source and commercial Eclipse products in terms of awareness of Eclipse guidelines and interfaces, Eclipse product size and updating of Eclipse product in the new SDK releases.

Less is more: unparser-completeness of metalanguages for template engines

A code generator is a program translating an input model into code. In this paper we focus on template-based code generators in the context of the model view controller architecture (MVC). The language in which the code generator is written is known as a metalanguage in the code generation parlance. The metalanguage should be, on the one side, expressive enough to be of practical value, and, on the other side, restricted enough to enforce the separation between the view and the model, according to the MVC. In this paper we advocate the notion of unparser-complete metalanguages as providing the right level of expressivity. An unparser-complete metalanguage is capable of expressing an unparser, a code generator that translates any legal abstract syntax tree into an equivalent sentence of the corresponding context-free language. A metalanguage not able to express an unparser will fail to produce all sentences belonging to the corresponding context-free language. A metalanguage able to express more than an unparser will also be able to implement code violating the model/view separation. We further show that a metalanguage with the power of a linear deterministic tree-to-string transducer is unparser-complete. Moreover, this metalanguage has been successfully applied in a non-trivial case study where an existing code generator is refactored using templates.

Formally specified type checkers for domain specific languages: experience report

An important part of the usability of a programming or specification language lies in the presence of supporting tools that are provided with the language, e.g., type checkers, debuggers and simulators. Development of such tools for domain-specific languages imposes a number of specific evolvability requirements. Our contribution is twofold: First, we present an MSOS-based approach to automatic generation of formally specified type checkers for domain-specific languages. Second, we report on the application of our approach to Chi, a high level specification language for describing concurrent systems. The resulting type checker has been successfully integrated in the tool chain of the Chi language.

Tool Building on the Shoulders of Others

At the first International Workshop on Advanced Software Development Tools and Techniques, four emerging trends in academic tool building were evident. First, tools are increasingly constructed on the basis of external code, reusing, for instance, existing frameworks and integrated development environments. Second, researchers often choose dynamic languages such as Smalltalk to implement prototype tools. Third, Web-based tools are starting to incorporate Web 2.0 technologies to improve user interaction. Finally, increasing computational resources allow tools to tackle larger, real-world code bases.

Using a DSL and Fine-Grained Model Transformations to Explore the Boundaries of Model Verification -- Extended Abstract

Traditionally, the state-space explosion problem in model checking is handled by applying abstractions and simplifications to the model that needs to be verified. In this paper, we propose a model-driven engineering approach that works the other way around. Instead of making a concrete model more abstract, we propose to refine an abstract model to make it more concrete. We propose to use fine-grained model transformations to enable model checking of models that are as close to the implementation model as possible. We applied our approach in a case study. The results show that models that are more concrete can be validated when fine-grained transformations are applied.

Type checking evolving languages with MSOS

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.

Understanding the dynamics of requirements process improvement: a new approach

Many software development organizations invest heavily in the requirements engineering process programmes, and with good reason. They fail, however, to maximize a healthy return on investment. This paper explores factors that influence requirements process improvement (RPI) with the aim to explain how the attributes of the underpinning process affect both the quality and associated costs of the requirements specification delivered to the customer. Although several tools and techniques have been proposed and used for RPIs, many lack a systematic approach to RPI or fail to provide RPI teams with the required understanding to assess their effectivity. The authors contend that the developed quality-cost RPI descriptive model is a generic framework, discipline and language for an effective approach to RPI. This descriptive model allows a systematic enquiry that yields explanations and provides RPI stakeholders with a common decision making framework. The descriptive model was validated by practicing process improvement consultants and managers and makes a contribution towards understanding of the quality-cost dynamics of RPI. To address the acknowledged deficiencies of RPI, the authors further suggest a generic RPI model and approach that integrates statistical process control (SPC) into system dynamics (SD). The approach enables RPI teams to steer for a cost-effective and successful RPI.

Using a DSL and Fine-Grained Model Transformations to Explore the Boundaries of Model Verification

Traditionally, the state-space explosion problem in model checking is handled by applying abstractions and simplifications to the model that needs to be verified. In this paper, we propose a model-driven engineering approach that works the other way around. Instead of making a concrete model more abstract, we propose to refine an abstract model to make it more concrete. We propose to use fine-grained model transformations to enable model checking of models that are as close to the implementation model as possible. We applied our approach in a case study. The results show that it is possible to validate models that are more concrete when fine-grained transformations are applied.