Jorge C. A. de Figueiredo

On the Precision and Accuracy of Impact Analysis Techniques

Several techniques and algorithms for impact analysis of software systems have been recently published in literature. Most of them, however, are not practical enough to be applied in the software industry because, among other reasons, they produce too many false results (either positive or negative). In this paper, we propose and evaluate the use of two measures from information retrieval, namely precision and recall, to help express and compare precision and accuracy of impact analysis techniques and algorithms.

The Hybrid Technique for Object-Oriented Software Change Impact Analysis

Change impact analysis techniques that underestimate impact may cause important financial losses from the point of view of an IT services company. Thus, reducing false-negatives in these techniques is a goal with strong practical relevance. This work presents a technique that uses both static and dynamic analysis of object-oriented source code to improve resulting impact estimates in terms of recall. The technique consists of three steps: static analysis to identify structural dependencies between code entities, dynamic analysis to identify dependencies based on a succession relation derived from execution traces, and a ranking of results from both analyses that takes into account the relevance of dynamic dependencies. Evaluation was performed through prototype development and a multiple-case quantitative case study that compared our solution against a static technique and a dynamic one. Results showed that our hybrid technique improved recall between 90 and 115% compared to the static technique, and between 21.2 and 39% compared to the dynamic one.

How bad are wrong suspicions? towards adaptive distributed protocols

In this paper, we analyze the performance of consensus protocols based on the rotating coordinator paradigm. We consider a simulated production environment, on which processing and communication resources available for the different processes running the protocols are not necessarily the same. Firstly, we show that, in some scenarios, the performance of the consensus protocol is enhanced when there is an increase in the number and duration of the wrong suspicions periods of the failure detection service used. Since it is well known that wrong suspicions may also decrease the performance of the consensus protocol, a new dilemma is posed to the designers of such protocols. We then propose a new approach to address performance issues in the design of crash-detection based distributed protocols for asynchronous systems. We argue that they must be designed to adapt themselves to the variations on the availability of resources. The concept of slowness oracles is proposed to achieve this goal. Finally, we present a slowness oracle that can be used to transform a non-adaptive consensus protocol into an adaptive one. Simulations show that the adaptive protocol outperforms its conventional non-adaptive counterpart in a number of scenarios, having an equivalent performance in the other scenarios.

Design tests: An approach to programmatically check your code against design rules

Assuring that a program conforms to its specification is a key concern in software quality assurance. Although there is substantial tool support to check whether an implementation complies to its functional requirements, checking whether it conforms to its design remains as an almost completely manual activity. In this paper, we present the concept of design tests, which are test-like programs that automatically check whether an implementation conforms to a specific design rule. Design rules are implemented directly in the target programming language in the form of tests. As a proof of concept, we present DesignWizard, an API developed to support design tests for Java programs as JUnit test cases. We applied design tests in two case studies and observed that our approach is suitable to check conformance automatically. Moreover, we observed that designers and programmers appreciate design tests as an executable documentation that can be easily kept up to date.

Component-based integration testing from UML interaction diagrams

An integration testing method for component- based software is presented. The method, based on the widely used UML (Unified Modelling Language) notation, covers a complete integration testing process at a contractual component level and it is supported by the use of tools. Components and their interfaces are specified by using UML diagrams and OCL (Object Constraint Language) constraints. Software under test is built from composition of components in a standard component-based software development process. A case study that is implemented in the Java language is presented to illustrate the application of the method.

Ecore representation for extending PNML for Input-Output Place-Transition nets

This paper presents a metamodel for the Input-Output Place-Transition nets (IOPT nets), a Petri net class targeted at controllers modeling. The proposed metamodel reuses many of the elements of the Petri Net Markup Language (PNML) metamodel, such as places, transitions, and arcs; it extends the PNML metamodel for Place/Transition nets to comprise concepts inherent to IOPT nets. The IOPT nets metamodel is described in Ecore format, putting IOPT nets in the puzzle of MDA artifacts taking benefit from the MDA infrastructure.

An approach to modelling and applying mobile agent design patterns

Mobile agent design patterns represent solutions to specific problems of implementing mobile agent-based applications that have evolved over time. The use of design patterns can increase productivity, promote reuse and reduce complexity when developing applications. However, most of the mobile agent design patterns presented in the literature are difficult to apply in practice due to the lack of a suitable approach to identify, document and apply them. Also, they are usually related to a specific mobile agent platform. We present an approach for modelling and applying patterns independently of specific platforms along with their counterparts in specific platforms. Also, we show that an adequate platform independent view can be constructed to be used as a guide to implement the pattern in different platforms.

Five Years of Software Architecture Checking: A Case Study of Eclipse

Over time, source code tends to drift from the intended software architecture, often resulting in the loss of desired software qualities. To help keep code aligned with the intended architecture, the developers of core parts of the open source Eclipse platform introduced API Tools to express and check architectural rules. Researchers analyzed five years of Eclipse architecture-checking reports that API Tools produced. They investigated what kinds of rules the developers found helpful to check, how code diverged from the intended architecture, and how the developers dealt with architectural violations over time. This article is part of a special issue on Software Architecture.

Towards medical device behavioural validation using Petri nets

Medical devices development and validation are difficult activities due to the critical nature of these products, involving risks to the human lives. Moreover, regulatory agencies are increasing the control over companies because of the still huge number of harms caused for several reasons, having software failures as one of the main causes. Thus it is clear that more formal and sophisticated software development techniques should be investigated. In this paper, we show how Petri nets can play the role of a generic framework for architectural decisions for control systems, allowing besides verification/simulation, an important bridge in the requested traceability by regulatory bodies. We claim that it is possible to satisfy traceability from architectural elements to code, test cases, functional and safety requirements and so on. In order to make clear our point, we conducted a case study from a generic infusion pump specification.

Properties Preservation in Distributed Execution of Petri Nets Models

Model-based development for embedded system design has been used to support the increase of system’s complexity. Several modeling formalisms are well matched for usage within this area. One of the goals of this work is to contribute to the usage of Petri nets as system specification language within model-based development of embedded systems having MDA proposals as a reference for the development flow. Distributed execution of the Petri net model is achieved through model partitioning into sub-modules. System decomposition is obtained through net splitting operation. Two types of implementation platforms were considered: compliant and non-compliant with zero time delay for communication between modules. Using model-checking techniques, properties associated with the execution of the distributed models in both types of platforms were compared with the execution of the initial (centralized) Petri net model.