Search

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. Keywords: Software engineering; Software quality; Redundancy

This paper presents a systematic survey of open source multiphysics frameworks in the en- gineering domains. These domains share many commonalities despite the diverse application areas. A thorough search for the available frameworks with both academic and industrial ori- gins has revealed numerous candidates. Considering key characteristics such as project size, maturity and visibility, we selected Elmer, OpenFOAM and Salome for a detailed analysis. All the public documentation for these tools has been manually collected and inspected. Based on the analysis, we built a feature model for multiphysics in engineering, which captures the commonalities and variability in the domain. We in turn validated the resulting model via two other tools; Kratos by manual inspection, and OOFEM by means of expert validation by domain experts. Keywords: Multiphysics; Multiscale; Modelling and Simulation; Domain Analysis; Feature Model

Multiphysics and multiscale modelling and simulation (MMS) is an emerging trend for the analysis and design of complex systems in many domains. As a result, there are an overwhelmingly large number of MMS software frameworks in the literature and market, while a comprehensive account of these is apparently missing. This paper presents an annotated bibliography of MMS software frameworks. A thorough bibliographic search in Scopus has been done, to nd out the candidates in physical sciences, published from 2000 onwards. Further cross-references have been investigated to achieve a better coverage. The frameworks have been categorized according to their application areas, and annotated with respect to their main features regarding software integration/extension/coupling.

Domain-specific languages (DSLs) allow users to model systems using concepts from a specific domain. Evolution of DSLs triggers co-evolution of models developed in these languages. When the number of models that needs to co-evolve increases, so does the required effort to do so. This is called the co-evolution problem. We have investigated the extent of the co-evolution problem at ASML [1], provider of lithography equipment for the semiconductor industry. Here we have described the structure and evolution of a large-scale ecosystem of DSLs. We have observed that due to the large number of artifacts that require coevolutionary activity, manual solutions have become unfeasible, and an automated approach is required. A popular approach for automating co-evolution is the operator-based approach. In this paper we have evaluated the operator-based approach on a large-scale industrial case-study of twenty-two DSLs and 95 model-to-model transformations with a revision history of over three years, and have revealed deficiencies in existing operator libraries. To address these deficiencies we have presented a topdown methodology to derive a complete set of operators.

Today, when constructing software systems, many developers build their systems on top of frameworks. Eclipse is such a framework that has been in existence for over a decade. Like many other evolving software systems, the Eclipse platform has both stable and supported interfaces (“good”) and unstable, discouraged and unsupported interfaces (“bad”). In this study, we investigate Eclipse interface usage by Eclipse third-party plug-ins (ETPs) based on whether they use bad interfaces or not. The investigations, based on empirical analysis present the following observations. First, we discovered that 44 % of the 512 analyzed Eclipse third-party plug-ins depend on “bad” interfaces and that developers continue to use “bad” interfaces. Second, we have observed that plug-ins that use or extend at least one “bad” interface are comparatively larger and use more functionality from Eclipse than those that use only “good” interfaces. Third, the findings show that the ETPs use a diverse set of “bad” interfaces. Fourth, we observed that the reason why the bad interfaces are being eliminated from the ETPs’ source code is, because (ETP developers believe) these non-APIs will cause incompatibilities when a version of the ETP is ported to new Eclipse SDK release. Finally, we observed that when developers eliminate problematic “bad” interfaces, they either re-implement the same functionality in their own API, find equivalent SDK good interfaces, or completely delete the entities in the ETPs’ source code that use the functionality from the “bad” interfaces.

The systematic literature review conducted in this paper explores the current techniques employed to leverage the development of DSLs using ontologies. Similarities and differences between ontologies and DSLs, techniques to combine DSLs with ontologies, the rationale of these techniques and challenges in the DSL approaches addressed by the used techniques have been investigated. Details about these topics have been provided for each relevant research paper that we were able to investigate in the limited amount of time of one month. At the same time, a synthesis describing the main trends in all the topics mentioned above has been done.

A design language and tool like MATLAB/Simulink is used for the graphical modelling and simulation of automotive control software. As the functionality based on electronics and software systems increases in motor vehicles, it is becoming increasingly important for system/software architects and control engineers in the automotive industry to ensure the quality of the highly complex MATLAB/Simulink control software. For automotive software, modularity is recognized as being a crucial quality attribute; therefore at Eindhoven University of Technology in the Netherlands we have been carrying out industrial case studies on defining and validating the modularity of Simulink models.

Today numerous software systems are being developed on top of frameworks. In this study, we analyzed the survival of 467 Eclipse third-party plug-ins altogether having 1,447 versions. We classify these plug-ins into two categories: those that depend on only stable and supported Eclipse APIs and those that depend on at least one of the potentially unstable, discouraged and unsupported Eclipse non-APIs. Comparing the two categories of plug-ins, we observed that the plug-ins depending solely on APIs have a very high source compatibility success rate compared to those that depend on at least one of the non-APIs. However, we have also observed that recently released plug-ins that depend on non-APIs also have a very high forward source compatibility success rate. This high source compatibility success rate is due to the dependency structure of these plug-ins: recently released plug-ins that depend on non-APIs predominantly depend on old Eclipse non-APIs rather than on newly introduced ones. Finally, we showed that the majority of plug-ins hosted on SourceForge do not evolve beyond the first year of release.

Modern software development commonly makes use of a multitude of software repositories. How can these help us to understand the on-going development process? Researchers of Eindhoven University of Technology design new methods revealing how software has been developed.

Understanding software maintainability often involves calculation of metric values at a micro-level of methods and classes. Building on these micro-level measurements and complementary to them, econometric techniques help to provide a more precise understanding of the maintainability of software systems in general.

No abstract.

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 APIs ("bad"). However, despite being discouraged by Eclipse, in our experience, the usage of "bad" APIs is relatively common in practice. In this paper, we study to what extent developers depend on "bad" APIs? We also study whether developers continue to use "bad" APIs? To answer these questions, we have conducted an empirical investigation based on a total of 512 Eclipse third-party plugins, altogether having a total of 1; 873 versions. We discovered that 44% of the analyzed Eclipse third-party plug-ins depends on "bad" APIs and that developers continue to use "bad" APIs. Furthermore, the empirical study shows that plug-ins that use or extend at least one "bad" API are comparatively larger and also use more functionality from Eclipse than those that use or extend only "good" APIs. We conjecture that since the larger plug-ins use extensive functionality, some of the functionality they require may be absent from the officially supported, "good" APIs.

Since the appearance of Albrechts pioneering work, function points have attracted signi¿cant attention from the industry. In their work, project managers can benchmark function point counts obtained for their projects against large publicly available datasets such as the ISBSG development & enhancement repository release 11, containing function point counts for more than 5000 projects. Unfortunately, larger amount of functionality as re¿ected in the function points count does not necessarily correspond to a more signi¿cant development effort. In this paper we focus on a collection of ISBSG projects with a similar amount of functionality and study the impact of different project attributes on the development effort.

Fault prediction models usually employ software metrics which were previously shown to be a strong predictor for defects, e.g., SLOC. However, metrics are usually defined on a microlevel (method, class, package), and 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, median, or sum, recently econometric aggregation techniques, such as the Gini, Theil, and Hoover indices have been proposed. In this paper we wish to understand whether the aggregation technique influences the presence and strength of the relation between SLOC and defects. Our results indicate that correlation is not strong, and is influenced by the aggregation technique.

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.

Analysis and execution of domain-specific models is typically performed by applying model transformations to transform them to formalisms suitable for that purpose. In this way, model transformations provide great flexibility. However, it is the transformed models that are analyzed and executed instead of the domain-specific models themselves. Consequently, analysis and execution results have to be traced back to the source models. This raises the issue of traceability in model transformations. This issue becomes even more apparent when compositions of multiple model transformations are considered. Therefore, we propose in this paper to visualize traceability in (compositions of) model transformations. In this visualization, the relation between the transformation functions that comprise a model transformation and the source and target metamodel of that transformation are made explicit.

Software developers' activities are in general recorded in software repositories such as version control systems, bug trackers and mail archives. While abundant information is usually present in such repositories, successful information extraction is often challenged by the necessity to simultaneously analyze different repositories and to combine the information obtained. We propose to apply process mining techniques, originally developed for business process analysis, to address this challenge. However, in order for process mining to become applicable, different software repositories should be combined, and "related" software development events should be matched: e.g., mails sent about a file, modifications of the file and bug reports that can be traced back to it. The combination and matching of events has been implemented in FRASR (Framework for Analyzing Software Repositories), augmenting the process mining framework ProM. FRASR has been successfully applied in a series of case studies addressing such aspects of the development process as roles of different developers and the way bug reports are handled.

In model comparison one can distinguish three major sub- problems: representation, calculation, and visualization of model di¿erences. Existing stand-alone tools for managing model di¿erences usually focus on one or sometimes two as- pects of model comparison. In this paper we discuss our stand-alone tool calledRCVDi¿, that incorporates all three aspects of model comparison. Furthermore, we comment on some issues in the process of model comparison that are not easily perceived if the three aspects of model comparison are considered independently.

We are pleased to present the proceedings of the Third International Conference on Software Language Engineering (SLE 2010). The conference will be held in Eindhoven, the Netherlands during October 12-13, 2010 and will be co-located with The Ninth International Conference on Generative Programming and Component Engineering (GPCE'10), and The Workshop on Feature-Oriented Software Development (FOSD). An important goal of SLE is to integrate the different sub-communities of the software-language-engineering community to foster cross-fertilization and strengthen research overall. The Doctoral Symposium at SLE 2010 contributes towards these goals by providing a forum for both early and late-stage PhD students to present their research and get detailed feedback and advice from other researchers. The SLE conference series is devoted to a wide range of topics related to artificial languages in software engineering. SLE is an international research forum that brings together researchers and practitioners from both industry and academia to expand the frontiers of software language engineering. SLE's foremost mission is to encourage and organize communication between communities that have traditionally looked at software languages from different, more specialized, and yet complementary perspectives. SLE emphasizes the fundamental notion of languages as opposed to any realization in specific technical spaces. In this context, the term "software language" comprises all sorts of artificial languages used in software development including general-purpose programming languages, domain-specific languages, modeling and meta-modeling languages, data models, and ontologies. Software language engineering is the application of a systematic, disciplined, quantifiable approach to the development, use, and maintenance of these languages. The SLE conference is concerned with all phases of the lifecycle of software languages; these include the design, implementation, documentation, testing, d

Dependency injection is a recent programming mechanism reducing dependencies among components by delegating them to an external entity, called a dependency injection framework. An increasingly popular approach to dependency injection implementation relies upon using Java annotations, a special form of syntactic metadata provided by the dependency injection frameworks. However, uncontrolled use of annotations may lead to potential violations of well-known modularity principles. In this paper we catalogue "bad smells", i.e., modularity-violating annotations defined by the developer or originating from the popular dependency injection frameworks. For each violation we discuss potential implications and propose means of resolving it. By detecting modularity bad smells in Java annotations our approach closes the gap between the state-of-the-art programming practice and currently available analysis techniques.