Cristina Marinescu

Towards a simplified implementation of object-oriented design metrics

In order to compute metrics automatically, these must be implemented as software programs. As metrics become increasingly complex, implementing them using imperative and interrogative programming is oftentimes cumbersome. Consequently, their understanding, testing and reuse are severely hampered. In this paper we identify a set of key mechanisms that are involved in the implementation of design metrics and, more general, of design-related structural analyses: navigation, selection, set arithmetic, filtering and property aggregation. We show that neither of the aforementioned approaches offers a simple support for all these mechanisms and, as a result, an undesirable overhead of complexity is added to the implementation of metrics. The paper introduces SAIL, a language designed to offer a proper support to a simplified writing of design metrics and similar design-related analyses, with special emphasis on object-oriented design. In order to validate the expressiveness of SAIL the paper provides a comprehensive comparison with the other two approaches

Are the Clients of Flawed Classes (Also) Defect Prone

Design flaws are those characteristics of design entities (e.g., methods, classes) which make them harder to maintain. Existing studies show that classes revealing particular design flaws are more change and defect prone than the other classes. Since various collaborations are found among the instances of classes, classes are not isolated within the source code of object-oriented systems. In this paper we investigate if classes using classes revealing design flaws are more defect prone than classes which do not use classes revealing design flaws. We detect four design flaws in three releases of Eclipse and investigate the relation between classes that use/do not use flawed classes and defects. The results show that classes that use flawed classes are defect prone and this does not depend on the number of the used flawed classes. This findings show a new type of correlation between design flaws and defects, bringing evidence related to an increased likelihood of exhibiting defects for classes that use classes revealing design flaws. Based on the provided evidence, practitioners are advised once again about the negative impact design flaws have at a source code level.

Are the classes that use exceptions defect prone

Exception handling is a mechanism that highlights exceptional functionality of software systems. Currently many empirical studies point out that sometimes developers neglect exceptional functionality, minimizing its importance. In this paper we investigate if the design entities (classes) that use exceptions are more defect prone than the other classes. The results, based on analyzing three releases of Eclipse, show that indeed the classes that use exceptions are more defect prone than the other classes. Based on our results, developers are advertised to pay more attention to the way they handle exceptions.

A Meta-Model for Enterprise Applications

In the last years, as object-oriented software systems became more and more complex, the need of performing automatically reverse engineering upon these systems has increased significantly. This applies also to enterprise applications, a novel category of software systems. As it is well known, one step toward a research infrastructure accelerating the progress of reverse engineering is the creation of an intermediate representation of software systems. This paper shows why existing intermediate representations of object-oriented software are not suitable for performing reverse engineering upon enterprise applications and proposes an intermediate representation (a model) for enterprise applications which facilitates the process of reverse engineering upon this type of applications. Based on an experimental study conducted on three enterprise applications, we prove the reliability of the introduced approach, discuss its benefits and touch the issues that need to be addressed in the future

Discovering the Objectual Meaning of Foreign Key Constraints in Enterprise Applications

The software industry is increasingly confronted with the issues of understanding and maintaining a special type of object-oriented systems, namely enterprise applications. A specific concern for these applications is to understand the persistent data (usually stored in a RDBMS), and its manipulation in the object-oriented source code. While foreign keys are an important means for indicating relations within the persistent data, oftentimes, by looking solely at the database schema, it is impossible to determine the exact nature of these relations. This paper proposes a novel approach for determining a refined understanding of the relations among the persistent data, by correlating the information about foreign keys extracted from the database schema with the way the data are used in the source code. By analyzing two enterprise systems we found that the proposed approach helps specifying a significant number of foreign key constraints in terms of their objectual meaning (e.g., if they denote an inheritance or an aggregation relation). Thus, the approach contributes to enhancing, in an automated manner, the understanding of a systems database schema by tying it to the source code that uses it.

How Good Is Genetic Programming at Predicting Changes and Defects

One of the main problems practitioners have to deal with is the identification of change and defect proneness of source code entities (e.g., Classes). During the last years a lot of techniques have been employed for predicting change and defect proneness of classes. In this paper we study the capabilities of Genetic Programming for performing the addressed problem by measuring the precision and recall of the obtained predictions.

Should We Beware the Exceptions? An Empirical Study on the Eclipse Project

Exception handling is a mechanism that highlights exceptional functionality of software systems. Currently there are empirical studies pointing out that design entities (classes) that use exceptions are more defect prone than the other classes and sometimes developers neglect exceptional functionality, minimizing its importance. In this paper we investigate if classes that use exceptions are the most complex classes from software systems and, consequently, have an increased likelihood to exhibit defects. We also detect two types of improper usages of exceptions in three releases of Eclipse and investigate the relations between classes that handle/do not handle properly exceptions and the defects those classes exhibit. The results show that (i) classes that use exceptions are more complex than the other classes and (ii) classes that handle improperly the exceptions in the source code exhibit an increased likelihood of exhibiting defects than classes which handle them properly. Based on the provided evidence, practitioners get knowledge about the correlations between exceptions and complexity and are advised once again about the negative impact deviations from best programming practices have at a source code level.

McC and Mc#: Unified C++ and C# Design Facts Extractors Tools

In the last years, as object-oriented software systems have become more and more complex, the need of performing automatically reverse engineering upon such systems has significantly increased. It is well known that one step toward a research infrastructure accelerating the progress of reverse engineering is the creation of an intermediate representation of software systems. In the current demonstration we present an unified structure for representing object- oriented systems written in C++ and C#, together with the corresponding model capturing tools. As a result, we can uniformly analyze C++ and C# systems. Moreover, we have integrated the tools in the iPlasma reengineering infrastructure which permits us to obtain easily valuable information for a reverse engineering process.

Identification of Relational Discrepancies between Database Schemas and Source-Code in Enterprise Applications

As enterprise applications become more and more complex, the understanding and quality assurance of these systems become an increasingly important issue. One specific concern of data reverse engineering, a necessary process for this type of applications which tackles the mentioned aspects, is to retrieve constraints which are not explicitly declared in the database schema but verified in the code. In this paper we propose a novel approach for detecting the relational discrepancies between database schemas and source-code in enterprise applications, as part of the data reverse engineering process. Detecting and removing these discrepancies allows us to ensure the accuracy of the stored data as well as to increase the level of understanding of the data involved in an enterprise application.

Quality Assessment of Enterprise Software Systems

In the last years, as object-oriented software systems became more and more complex, the need of having tools that help us to understand and to assess the quality of their design has increased significantly. This applies also to enterprise applications, a novel category of software systems. Unfortunately, the existing techniques for designs understanding and quality assessment of object-oriented systems are not sufficient and sometimes not suitable when applied on enterprise applications. In the current Ph.D. we propose a new approach which increases the level of understanding and the accuracy assessment of the design of enterprise software systems