A heuristic-based approach to code-smell detection

Encapsulation and data hiding are central tenets of the object oriented paradigm. Deciding what data and behaviour to form into a class and where to draw the line between its public and private details can make the difference between a class that is an understandable, flexible and reusable abstraction and one which is not. This decision is a difficult one and may easily result in poor encapsulation which can then have serious implications for a number of system qualities. It is often hard to identify such encapsulation problems within large software systems until they cause a maintenance problem (which is usually too late) and attempting to perform such analysis manually can also be tedious and error prone. Two of the common encapsulation problems that can arise as a consequence of this decomposition process are data classes and god classes. Typically, these two problems occur together – data classes are lacking in functionality that has typically been sucked into an over-complicated and domineering god class. This paper describes the architecture of a tool which automatically detects data and god classes that has been developed as a plug-in for the Eclipse IDE. The technique has been evaluated in a controlled study on two large open source systems which compare the tool results to similar work by Marinescu, who employs a metrics-based approach to detecting such features. The study provides some valuable insights into the strengths and weaknesses of the two approache

Invertible Program Restructurings for Continuing Modular Maintenance

When one chooses a main axis of structural decompostion for a software, such as function- or data-oriented decompositions, the other axes become secondary, which can be harmful when one of these secondary axes becomes of main importance. This is called the tyranny of the dominant decomposition. In the context of modular extension, this problem is known as the Expression Problem and has found many solutions, but few solutions have been proposed in a larger context of modular maintenance. We solve the tyranny of the dominant decomposition in maintenance with invertible program transformations. We illustrate this on the typical Expression Problem example. We also report our experiments with Java and Haskell programs and discuss the open problems with our approach.Comment: 6 pages, Early Research Achievements Track; 16th European Conference on Software Maintenance and Reengineering (CSMR 2012), Szeged : Hungary (2012

A Model-based transformation process to validate and implement high-integrity systems

Despite numerous advances, building High-Integrity Embedded systems remains a complex task. They come with strong requirements to ensure safety, schedulability or security properties; one needs to combine multiple analysis to validate each of them. Model-Based Engineering is an accepted solution to address such complexity: analytical models are derived from an abstraction of the system to be built. Yet, ensuring that all abstractions are semantically consistent, remains an issue, e.g. when performing model checking for assessing safety, and then for schedulability using timed automata, and then when generating code. Complexity stems from the high-level view of the model compared to the low-level mechanisms used. In this paper, we present our approach based on AADL and its behavioral annex to refine iteratively an architecture description. Both application and runtime components are transformed into basic AADL constructs which have a strict counterpart in classical programming languages or patterns for verification. We detail the benefits of this process to enhance analysis and code generation. This work has been integrated to the AADL-tool support OSATE2

A Domain-Specific Language and Editor for Parallel Particle Methods

Domain-specific languages (DSLs) are of increasing importance in scientific high-performance computing to reduce development costs, raise the level of abstraction and, thus, ease scientific programming. However, designing and implementing DSLs is not an easy task, as it requires knowledge of the application domain and experience in language engineering and compilers. Consequently, many DSLs follow a weak approach using macros or text generators, which lack many of the features that make a DSL a comfortable for programmers. Some of these features---e.g., syntax highlighting, type inference, error reporting, and code completion---are easily provided by language workbenches, which combine language engineering techniques and tools in a common ecosystem. In this paper, we present the Parallel Particle-Mesh Environment (PPME), a DSL and development environment for numerical simulations based on particle methods and hybrid particle-mesh methods. PPME uses the meta programming system (MPS), a projectional language workbench. PPME is the successor of the Parallel Particle-Mesh Language (PPML), a Fortran-based DSL that used conventional implementation strategies. We analyze and compare both languages and demonstrate how the programmer's experience can be improved using static analyses and projectional editing. Furthermore, we present an explicit domain model for particle abstractions and the first formal type system for particle methods.Comment: Submitted to ACM Transactions on Mathematical Software on Dec. 25, 201

Building Transformation Networks for Consistent Evolution of Interrelated Models

In dieser Dissertation formalisieren und analysieren wir die Konsistenzerhaltung verschiedener Artefakte zur Beschreibung eines Softwaresystems durch die Kopplung von Transformationen zwischen diesen und unterstützen sie mit geeigneten Methoden. Für die Entwicklung eines Softwaresystems nutzen Entwickler:innen und weitere Beteiligte verschiedene Sprachen, oder allgemein Werkzeuge, zur Beschreibung unterschiedlicher Belange. Meist stellt Programmcode das zentrale Artefakt dar, welches jedoch, implizit oder explizit, durch Spezifikationen von Architektur, Deployment, Anforderungen und anderen ergänzt wird. Neben der Programmiersprache verwenden die Beteiligten weitere Sprachen zur Spezifikation dieser Artefakte, beispielsweise die UML für Modelle des objektorientierten Entwurfs oder der Architektur, den OpenAPI-Standard für Schnittstellen-Definitionen, oder Docker für Deployment-Spezifikationen. Zur Erstellung eines funktionsfähigen Softwaresystems müssen diese Artefakte das System einheitlich und widerspruchsfrei darstellen. Beispielsweise müssen Dienst-Schnittstellen in allen Artefakten einheitlich repräsentiert sein. Wir sagen, die Artefakte müssen konsistent sein. In der modellgetriebenen Entwicklung werden solche verschiedenen Artefakte allgemein Modelle genannt und bereits als wesentliche zentrale Entwicklungsbestandteile genutzt, um auch Teile des Programmcodes aus ihnen abzuleiten. Dies betrifft beispielsweise die Softwareentwicklung für Fahrzeuge. Zur Konsistenzerhaltung der Modelle werden oftmals Transformationen eingesetzt, die nach Änderungen eines Modells die anderen Modelle anpassen. Die bisherige Forschung beschränkt sich auf Transformationen zur Konsistenzerhaltung zweier Modelle und die projektspezifische Kombination von Transformationen zur Konsistenzerhaltung mehrerer Modelle. Ein systematischer Entwicklungsprozess, in dem einzelne Transformationen unabhängig entwickelt und in verschiedenen Kontexten modular wiederverwendet werden können, wird hierdurch jedoch nicht unterstützt. In dieser Dissertation erforschen wir, wie Entwickler:innen mehrere Transformationen zu einem Netzwerk kombinieren können, welches die Transformationen in einer geeigneten Reihenfolge ausführen kann, sodass abschließend alle Modelle konsistent zueinander sind. Dies geschieht unter der Annahme, dass einzelne Transformationen zwischen zwei Sprachen unabhängig voneinander entwickelt werden und daher nicht aufeinander abgestimmt werden können. Unsere Beiträge unterteilen sich in die Untersuchung der Korrektheit einer solchen Kombination von Transformationen zu einem Netzwerk und die Optimierung von Qualitätseigenschaften solcher Netzwerke. Wir diskutieren und definieren zunächst einen adäquaten Korrektheitsbegriff, welcher drei Anforderungen impliziert. Diese umfassen eine Synchronisations-Eigenschaft für die einzelnen Transformationen, eine Kompatibilitäts-Eigenschaft für das Transformationsnetzwerk, sowie das Finden einer geeigneten Ausführungsreihenfolge der Transformationen, einer Orchestrierung. Wir stellen ein Konstruktionsverfahren für Transformationen vor, mit welchem die Synchronisations-Eigenschaft basierend auf einer formal bewiesenen Eigenschaft erfüllt wird. Für dieses zeigen wir Vollständigkeit und Angemessenheit mit einer fallstudienbasierten empirischen Evaluation in der Domäne der komponentenbasierten Softwareentwicklung. Wir definieren die Eigenschaft der Kompatibilität von Transformationen, für welche wir ein formales und bewiesen korrektes Analyseverfahren vorschlagen und eine praktische Realisierung ableiten, deren Anwendbarkeit wir in Fallstudien nachweisen. Schlussendlich definieren wir das Orchestrierungsproblem zum Finden einer Orchestrierung, die zu konsistenten Modelle führt wann immer solch eine Orchestrierung existiert. Wir beweisen die Unentscheidbarkeit dieses Problems und diskutieren, dass eine Einschränkung des Problems, um Entscheidbarkeit zu erreichen, die Anwendbarkeit unpraktikabel beschränken würde. Daher schlagen wir einen Algorithmus vor, der das Problem konservativ behandelt. Er findet eine Orchestrierung unter bestimmten, wohldefinierten Bedingungen und terminiert andernfalls mit einem Fehler. Wir beweisen die Korrektheit des Algorithmus und eine Eigenschaft, die das Finden der Ursache im Fehlerfall unterstützt. Zusätzlich kategorisieren wir Fehler, die auftreten können falls ein Netzwerk den definierten Korrektheitsbegriff nicht erfüllt. Daraus leiten wir mittels den bereits genannten Fallstudien ab, dass die meisten potentiellen Fehler per Konstruktion mit den in dieser Arbeit vorgeschlagenen Ansätzen vermieden werden können. Zur Untersuchung von Qualitätseigenschaften eines Netzwerkes von Transformationen klassifizieren wir zunächst relevante Eigenschaften, sowie den Effekt verschiedener Typen von Netzwerktopologien auf diese. Hierbei zeigt sich, dass insbesondere Korrektheit und Wiederverwendbarkeit im Widerspruch stehen, sodass die Wahl der Netzwerktopologie ein Abwägen bei der Optimierung dieser Eigenschaften erfordert. Wir leiten hieraus ein Konstruktionsverfahren für Transformationsnetzwerke ab, welches die Notwendigkeit einer Abwägung zwischen den Qualitätseigenschaften abmildert und, unter gewissen Voraussetzungen, Korrektheit per Konstruktion gewährleistet. Wir unterstützen den Entwicklungsprozess für diesen Ansatz mithilfe einer spezialisierten Spezifikationssprache. Während die Verminderung der Notwendigkeit einer Abwägung zwischen Qualitätseigenschaften durch den Ansatz per Konstruktion erreicht wird, zeigen wir die Erreichbarkeit der Voraussetzungen und die Vorteile der vorgeschlagenen Sprache in einer empirischen Evaluation mithilfe der Fallstudie aus der komponentenbasierten Softwareentwicklung. Die Beiträge dieser Dissertation unterstützen sowohl Forscher:innen als auch Transformationsentwickler:innen und Transformationsanwender:innen bei der Analyse und Konstruktion von Netzwerken von Transformationen. Sie stellen für Forscher:innen und Transformationsentwickler:innen systematisches Wissen über die Korrektheit und weitere Qualitätseigenschaften solcher Netzwerke bereit. Sie zeigen insbesondere welche Teile dieser Eigenschaften per Konstruktion erreicht werden können, welche per Analyse validiert werden können, und welche Fehler unvermeidbar bei der Ausführung erwartet werden müssen. Zusätzlich zu diesen Einsichten stellen wir konkrete, praktisch nutzbare Verfahren bereit, mit denen Transformationsentwickler:innen und Transformationsanwender:innen korrekte, modular wiederverwendbare Netzwerke konstruieren, analysieren und ausführen können

Early aspects: aspect-oriented requirements engineering and architecture design

This paper reports on the third Early Aspects: Aspect-Oriented Requirements Engineering and Architecture Design Workshop, which has been held in Lancaster, UK, on March 21, 2004. The workshop included a presentation session and working sessions in which the particular topics on early aspects were discussed. The primary goal of the workshop was to focus on challenges to defining methodical software development processes for aspects from early on in the software life cycle and explore the potential of proposed methods and techniques to scale up to industrial applications

Elastic systems

Elastic systems provide tolerance to the variations in computation and communication delays. The incorporation of elasticity opens new opportunities for optimization using new correct-by-construction transformations that cannot be applied to rigid non-elastic systems. The basics of synchronous and asynchronous elastic systems will be reviewed. A set of behavior-preserving transformations will be presented: retiming, recycling, early evaluation, variable-latency units and speculative execution. The application of these transformations for performance and power optimization will be discussed. Finally, a novel framework for microarchitectural exploration will be introduced, showing that the optimal pipelining of a circuit can be automatically obtained by using the previous transformations.Peer ReviewedPostprint (published version

Runtime Enforcement for Component-Based Systems

Runtime enforcement is an increasingly popular and effective dynamic validation technique aiming to ensure the correct runtime behavior (w.r.t. a formal specification) of systems using a so-called enforcement monitor. In this paper we introduce runtime enforcement of specifications on component-based systems (CBS) modeled in the BIP (Behavior, Interaction and Priority) framework. BIP is a powerful and expressive component-based framework for formal construction of heterogeneous systems. However, because of BIP expressiveness, it remains difficult to enforce at design-time complex behavioral properties. First we propose a theoretical runtime enforcement framework for CBS where we delineate a hierarchy of sets of enforceable properties (i.e., properties that can be enforced) according to the number of observational steps a system is allowed to deviate from the property (i.e., the notion of k-step enforceability). To ensure the observational equivalence between the correct executions of the initial system and the monitored system, we show that i) only stutter-invariant properties should be enforced on CBS with our monitors, ii) safety properties are 1-step enforceable. Given an abstract enforcement monitor (as a finite-state machine) for some 1-step enforceable specification, we formally instrument (at relevant locations) a given BIP system to integrate the monitor. At runtime, the monitor observes and automatically avoids any error in the behavior of the system w.r.t. the specification. Our approach is fully implemented in an available tool that we used to i) avoid deadlock occurrences on a dining philosophers benchmark, and ii) ensure the correct placement of robots on a map.Comment: arXiv admin note: text overlap with arXiv:1109.5505 by other author