Stéphane Vaucher

BDTEX: A GQM-based Bayesian approach for the detection of antipatterns

The presence of antipatterns can have a negative impact on the quality of a program. Consequently, their efficient detection has drawn the attention of both researchers and practitioners. However, most aspects of antipatterns are loosely specified because quality assessment is ultimately a human-centric process that requires contextual data. Consequently, there is always a degree of uncertainty on whether a class in a program is an antipattern or not. None of the existing automatic detection approaches handle the inherent uncertainty of the detection process. First, we present BDTEX (Bayesian Detection Expert), a Goal Question Metric (GQM) based approach to build Bayesian Belief Networks (BBNs) from the definitions of antipatterns. We discuss the advantages of BBNs over rule-based models and illustrate BDTEX on the Blob antipattern. Second, we validate BDTEX with three antipatterns: Blob, Functional Decomposition, and Spaghetti code, and two open-source programs: GanttProject v1.10.2 and Xerces v2.7.0. We also compare the results of BDTEX with those of another approach, DECOR, in terms of precision, recall, and utility. Finally, we also show the applicability of our approach in an industrial context using Eclipse JDT and JHotDraw and introduce a novel classification of antipatterns depending on the effort needed to map their definitions to automatic detection approaches.

Deviance from perfection is a better criterion than closeness to evil when identifying risky code

We propose an approach for the automatic detection of potential design defects in code. The detection is based on the notion that the more code deviates from good practices, the more likely it is bad. Taking inspiration from artificial immune systems, we generated a set of detectors that characterize different ways that a code can diverge from good practices. We then used these detectors to measure how far code in assessed systems deviates from normality. We evaluated our approach by finding potential defects in two open-source systems (Xerces-J and Gantt). We used the library JHotDraw as the code base representing good design/programming practices. In both systems, we found that 90% of the riskiest classes were defects, a precision far superiour to state of the art rule-based approaches.

Reconstructing Architectural Views from Legacy Systems

Modernizing a large legacy system is a demanding and costly process which requires a deep understanding of the systems architecture and its components. However legacy systems are poorly documented and they have often undergone many changes that make them deviate from their initial architectural design. Approaches for reconstructing architectural views from legacy systems and re-documenting the resulting components are of great value in the context of a modernization process. In this paper, we propose an approach that helps constructing distinct architectural views from legacy systems. To do so, we propose various clustering algorithms which are driven by common architectural views and styles. Our approach makes use of the knowledge discovery model which provides a standard machine-independent representation of legacy systems. We implemented and applied the approach in an industrial setting. The preliminary experimentations have shown that the algorithms perform well and produce comprehensive views.

Discovering New Change Patterns in Object-Oriented Systems

Modern software has to evolve to meet the needs of stakeholders; but the nature and scope of this evolution is difficult to anticipate and manage. In this paper, we examine techniques which can discover interesting patterns of evolution in large object-oriented systems. To locate patterns, we use clustering to group together classes which change in the same manner at the same time. Then, we use dynamic time warping to find if a group of classes is similar to another when we ignore the exact moment when changes occur. Groups that exhibit distinctive evolution properties are potential candidates for new evolution patterns. Finally, in a study of two industrial open-source libraries, we identified four new types of change patterns whose usefulness is determined by perusal of the release notes and the architecture.

Restructuring object-oriented applications into component-oriented applications by using consistency with execution traces

Software systems should evolve in order to respond to changing client requirements and their evolving environments. But unfortunately, the evolution of legacy applications generates an exorbitant cost. In this paper, we propose an approach to restructure legacy object-oriented applications into component-based applications. Our approach is based on dynamic dependencies between classes to identify potential components. In this way, the composition is dictated by the context of the application to improve its evolvability. We validate our approach through the study of three legacy Java applications.

Deriving Coupling Metrics from Call Graphs

Coupling metrics play an important role in empirical software engineering research as well as in industrial measurement programs. The existing coupling metrics have usually been defined in a way that they can be computed from a static analysis of the source code. However, modern programs extensively use dynamic language features such as polymorphism and dynamic class loading that are difficult to capture by static analysis. Consequently, the derived metric values might not accurately reflect the state of a program. In this paper, we express existing definitions of coupling metrics using call graphs. We then compare the results of four different call graph construction algorithms with standard tool implementations of these metrics in an empirical study. Our results show important variations in coupling between standard and call graph-based calculations due to the support of dynamic features.

Multi-level evaluation of web site navigability

Much research in recent years has focused on the evaluation of web site quality. The majority of this research has focused on evaluating the quality of individual pages or that of a site as a whole. In this paper, we propose an evaluation approach that combines evaluations at the page level with the one of the web site by means of a page-importance weighing model. We illustrate our approach with the particular characteristic of navigability. Both navigability models at the page and site levels are implemented as Bayesian Belief Networks to manage explicitly the uncertainty of web site evaluation. The page importance weighting is implemented using a random walk strategy. We evaluated the resulting model using a mean-different hypothesis testing. The results showed that our model allows discriminating correctly between web sites having a good navigability and randomly-selected web sites.

Do software libraries evolve differently than applications?: an empirical investigation

More and more, developers use reusable components like libraries to produce high quality software systems. These systems need to satisfy not only the initial demands of their stakeholders, but they need to also offer support for future, changing requirements. While several studies have looked at the cost of modifying systems, there exists no work verifying if libraries evolve differently than applications. This study attempts to do so quantitatively. In this paper, we define design changes metrics to estimate the amount of high-level change required of individual classes and use metrics to describe their structure. These measures are then used as inputs in models capable of predicting code change. We used machine learning techniques to build these models and tested them on the evolution of industrial open-source systems. Two of the systems were libraries, and two were standalone applications. We found that while design changes are systematically correlated with code changes, structure metrics are better predictors of code change in libraries with well developed class hierarchies. With the two applications without this characteristic, structure alone was a poor predictor.

Recommending Improvements to Web Applications Using Quality-Driven Heuristic Search

Planning out maintenance tasks to increase the quality of Web applications can be difficult for a manager. First, it is hard to evaluate the precise effect of a task on quality. Second, quality improvement will generally be the result of applying a combination of available tasks; identifying the best combination can be complicated. We present a general approach to recommend improvements to Web applications. The approach uses a meta-heuristic algorithm to find the best sequence of changes given a quality model responsible to evaluate the fitness of candidate sequences. This approach was tested using a navigability model on 15 different Web pages. The meta-heuristic recommended the best possible sequence for every tested configuration, while being much more efficient than an exhaustive search with respect to execution time.

Automated evaluation of website navigability: an empirical validation of multilevel quality models

Websites are an important and efficient means of communication for companies wishing to interact with their clients. Therefore, research has focused on evaluating how websites should be structured to ensure their quality. The majority of this research has focused on evaluating the quality of individual pages or that of a site as a whole. In this article, we propose the use of two‐level models that combine evaluations at the page level with evaluations at the site level, and applied them to the problem of evaluating the navigability of websites. To test our models, we conducted a study with 21 subjects who had to complete navigation tasks on several websites, and compared their quality judgments to those produced by single and two‐level quality models. We found that two‐level models are better predictors of navigability. Finally, we show how two‐level models are able to suggest modifications to improve site navigability. Copyright