Dalton Dario Serey Guerrero

Comparison of Graph Clustering Algorithms for Recovering Software Architecture Module Views

In the domain of software architecture recovery, classical clustering algorithms have been used to recover module views, while new ones have been proposed to tackle specific software architecture issues. Nonetheless, little information concerning their empirical evaluation in this context is presently available. This paper presents an empirical study that evaluates four clustering algorithms according to three previously proposed criteria: extremity of cluster distribution, authoritativeness, and stability, which were measured against consecutive releases of four different systems. Our results suggest that the k-means algorithm performs best in terms of authoritativeness and extremity and that the modularization quality algorithm produces more stable clusters. They also point out that fully automated clustering techniques alone cannot recover module views in a sensible way, but may provide a reasonable first step to speed up an expert-assisted architecture recovery process.

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.

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.

Improving Automated Mapping in Reflexion Models Using Information Retrieval Techniques

The reflexion model technique supports structural conformance checking of software systems. The scalability of the technique is limited by the requirement for developers to provide a mapping between implementation entities and high-level modules. Such mapping is usually based on regular expressions, and it must also be updated as the system evolves. Automated mapping techniques exist but are solely based on structural dependencies. In this paper, we introduce an automated mapping technique for reflexion models based on information retrieval techniques. It makes use of source code vocabulary and their similarity to the vocabulary of high-level modules. Two case studies conducted across four systems show that the nature of the module view influences which technique performs best. Results also show that combining both mapping techniques into a two step-mapping algorithm generally increases recall, while keeping precision similar to the best approach used in isolation.

Difficulties in solving ill-defined problems: A case study with introductory computer programming students

In this paper we report a case study carried out in the first academic semester of 2008 with novice programming students of the computer science course at the Federal University of Campina Grande. This case study aimed at observing and evaluating strategies adopted by students on ill-defined problem solving. The results of this case study showed that students found it hard to perform problem statement exploratory reading and interpretation, formulate questions to enlighten the problem, analyze the problem constrains and error occurrence, write tests to check non-obvious situations and also to register effectively the new problem information acquired by discussing with client. The present paper also reports on some pedagogic possibilities to improve the introductory programming teaching.

A systematic mapping study on assessing computational thinking abilities

Several initiatives have been created to promote Computational Thinking (CT) abilities in students. There are multiple approaches of assessing CT and wide abilities and skills involved. However, the evidence on how to assess CT has not yet been systematically grouped or reviewed. The goal of our study is to identify and classify approaches to promote CT and the different ways of assessing CT abilities. To achieve this goal, a systematic mapping study was planned and executed. The results reveal that: (i) programming courses are the most common pedagogical approaches to promote CT for K-12 students; (ii) multiple skills are involved in CT, but solving problems, algorithms, and abstraction are most common abilities assessed; and (iii) codes and multi-choice questionnaires are the most common artifacts for assessing CT abilities. This study points out to the fact that there are open questions for exploring and developing new researches for promoting and assessing CT abilities.

A Bag-of-Tasks Approach for State Space Exploration Using Computational Grids

A strategy for exploring distributed state spaces using computational grids that run bag-of-task applications is discussed. The main idea is to use computational grid tools as a layer between the verification tool and the distributed shared resources, aggregating the vast background developed by researchers in grid computing. Hence, the computational grid deals with resource scalability, computational speedup, and reliability in a transparent manner for the verification tool. Experimental results using a state space generation tool for an object-oriented Petri nets and the OurGrid solution show that is possible to achieve speedup applying it to a private network environment. Moreover, when a wide distributed community is considered, the model size can be increased several times

Using a file working set model to speed up the recovery of Peer-to-Peer backup systems

The high churn and low bandwidth characteristics of peer-to-peer (P2P) backup systems make recovery a time-consuming activity that increases the systems outage. This is especially disturbing from the users perspective, because during outage the user is prevented from carrying out useful work. Nevertheless, at any given time, a user typically requires only a small number of her files to continue working. If the backup system is able to quickly recover these files, then the systems outage can be greatly reduced, even if a large portion of the data lost is still being recovered. In this paper, we evaluate the use of a file system working set model to support efficient recovery of a P2P backup system. By exploiting a simple LRU-like working set model, we have designed a recovery mechanism that substantially reduces outage and allows the user to return to work more quickly. The simulations we have performed show that even this simple model is able to reduce the outage by as much as 80%, when compared to the state-of-practice in P2P backup recovery.

An object-based modular CPN approach: its application to the specification of a cooperative editing environment

In this paper we discuss the modeling of a cooperative graphical editor by means of an object-based Petri net framework named GCPN. Initially we introduce the G-CPN tool addressing both its informal and formal aspects. Then, the editor is informally specified, and based on such specification we introduce a multi-agent-based architecture to support its realization. After this, we define the different interactions in the system, in order to allow the computer supported cooperative work. Also, we show how the application of the introduced G-CPN can be applied to obtain an object-oriented model of some of the elements of the cooperative graphical G-CPN editor.