Large Object-oriented Software Research Articles

An empirical analysis of package-modularization metrics: Implications for software fault-proneness

ContextIn a large object-oriented software system, packages play the role of modules which group related classes together to provide well-identified services to the rest of the system. In this context, it is widely believed that modularization has a large influence on the quality of packages. Recently, Sarkar, Kak, and Rama proposed a set of new metrics to characterize the modularization quality of packages from important perspectives such as inter-module call traffic, state access violations, fragile base-class design, programming to interface, and plugin pollution. These package-modularization metrics are quite different from traditional package-level metrics, which measure software quality mainly from size, extensibility, responsibility, independence, abstractness, and instability perspectives. As such, it is expected that these package-modularization metrics should be useful predictors for fault-proneness. However, little is currently known on their actual usefulness for fault-proneness prediction, especially compared with traditional package-level metrics. ObjectiveIn this paper, we examine the role of these new package-modularization metrics for determining software fault-proneness in object-oriented systems. MethodWe first use principal component analysis to analyze whether these new package-modularization metrics capture additional information compared with traditional package-level metrics. Second, we employ univariate prediction models to investigate how these new package-modularization metrics are related to fault-proneness. Finally, we build multivariate prediction models to examine the ability of these new package-modularization metrics for predicting fault-prone packages. ResultsOur results, based on six open-source object-oriented software systems, show that: (1) these new package-modularization metrics provide new and complementary views of software complexity compared with traditional package-level metrics; (2) most of these new package-modularization metrics have a significant association with fault-proneness in an expected direction; and (3) these new package-modularization metrics can substantially improve the effectiveness of fault-proneness prediction when used with traditional package-level metrics together. ConclusionsThe package-modularization metrics proposed by Sarkar, Kak, and Rama are useful for practitioners to develop quality software systems.

Extending Linear Temporal Logic with Clocks to Object-Z

Object-Z, an extension to formal specification language Z, is good for describing large scale Object-Oriented software specification. While Object-Z has found application in a number of areas, its utility is limited by its inability to specify continuous variables and real-time constraints. Linear temporal logic can describe real-time system, but it can not deal with time variables well and also can not describe formal specification modularly. This paper extends linear temporal logic with clocks (LTLC) and presents an approach to adding linear temporal logic with clocks to Object-Z. Extended Object-Z with LTLC, a modular formal specification language, is a minimum extension of the syntax and semantics of Object-Z. The main advantage of this extension lies in that it is convenient to describe and verify the complex real-time software specification.

An Instance to Extend Object-Z Formal Specification

Object-Z, an extension to formal specification language Z, is good for describing large scale Object-Oriented software specification. This paper introduces Real-Time Object-Z and describes the characters of real-time system: delay, timeout and multithread. Real-Time Object-Z consists two parts: functional specification and filter specification. While Object-Z has found application in a number of areas, its utility is limited by its inability to specify continuous variables and real-time constraints. The main benefit is that it is convenient to deal with the timing variables defined in the specification developed with our approach. The effective specification after applying filter part to functional part holds the form of specification developed with Object-Z. Expanded Object-Z, a modular formal specification language, is a minimum extension of the syntax and semantics of Object-Z. The main advantage of this extension lies in that it is convenient to describe and verify the complex real-time software specification.

Class Schema Evolution for Persistent Object-Oriented Software: Model, Empirical Study, and Automated Support

With the wide support for object serialization in object-oriented programming languages, persistent objects have become common place and most large object-oriented software systems rely on extensive amounts of persistent data. Such systems also evolve over time. Retrieving previously persisted objects from classes whose schema has changed is however difficult, and may lead to invalidating the consistency of the application. The ESCHER framework addresses these issues through an IDE-integrated approach that handles class schema evolution by managing versions of the code and generating transformation functions automatically. The infrastructure also enforces class invariants to prevent the introduction of potentially corrupt objects. This article describes a model for class attribute changes, a measure for class evolution robustness, four empirical studies, and the design and implementation of the ESCHER system.

A modified Yule process to model the evolution of some object-oriented system properties

We present a model based on the Yule process, able to explain the evolution of some properties of large object-oriented software systems. We study four system properties related to code production of four large object-oriented software systems – Eclipse, Netbeans, JDK and Ant. The properties analysed, namely the naming of variables and methods, the call to methods and the inheritance hierarchies, show a power-law distribution as reported in previous papers for different systems. We use the simulation approach to verify the goodness of our model, finding a very good correspondence between empirical data of subsequent software versions, and the prediction of the model presented.

Metrics for Measuring the Quality of Modularization of Large-Scale Object-Oriented Software

The metrics formulated to date for characterizing the modularization quality of object-oriented software have considered module and class to be synonymous concepts. But a typical class in object oriented programming exists at too low a level of granularity in large object-oriented software consisting of millions of lines of code. A typical module (sometimes referred to as a superpackage) in a large object-oriented software system will typically consist of a large number of classes. Even when the access discipline encoded in each class makes for clean class-level partitioning of the code, the intermodule dependencies created by associational, inheritance-based, and method invocations may still make it difficult to maintain and extend the software. The goal of this paper is to provide a set of metrics that characterize large object-oriented software systems with regard to such dependencies. Our metrics characterize the quality of modularization with respect to the APIs of the modules, on the one hand, and, on the other, with respect to such object-oriented inter-module dependencies as caused by inheritance, associational relationships, state access violations, fragile base-class design, etc. Using a two-pronged approach, we validate the metrics by applying them to popular open-source software systems.

On the suitability of Yule process to stochastically model some properties of object-oriented systems

We present a study of three large object-oriented software systems—VisualWorks Smalltalk, Java JDK and Eclipse—searching for scaling laws in some of their properties. We study four system properties related to code production, namely the inheritance hierarchies, the naming of variables and methods, and the calls to methods. We systematically found power-law distributions in these properties, most of which have never been reported before. We were also able to statistically model the programming activities leading to the studied properties as Yule processes, with very good correspondence between empirical data and the prediction of Yule model. The fact that a design and optimization process like software development can be modeled on the large with the laws of statistical physics poses intriguing issues to software engineers, and could be exploited for finding new metrics and quality measures.

Visualisation et analyse de logiciels de grande taille

Metaphor-based visualization helps in the representation and analysis of large object-oriented software. It uses resources from human visual and cognitive systems to extract from these representations regularities and discontinuities that are the basic elements of any qualitative study. Based on these principles, we propose a preattentive visualization system. Within our system, we use the city metaphor to conduct various powerful analyses.

Role model based framework design and integration

Today, any large object-oriented software system is built using frameworks. Yet, designing frameworks and defining their interaction with clients remains a difficult task. A primary reason is that today's dominant modeling concept, the class, is not well suited to describe the complexity of object collaborations as it emerges in framework design and integration. We use role modeling to overcome the problems and limitations of class-based modeling. Using role models, the design of a framework and its use by clients can be described succinctly and with much better separation of concerns than with classes. Using role objects, frameworks can be integrated into use-contexts that have not been foreseen by their original designers.

Design of class hierarchies based on concept, (Galois) lattices

Building and maintaining the class hierarchy has been recognized as an important but one of the most difficult activities of object-oriented design. Concept (or Galois) lattices and related structures are presented as a framework for dealing with the design and maintenance of class hierarchies. Because the design of class hierarchies is inherently an iterative and incremental process, we designed incremental algorithms that update existing Galois lattices as the result of adding, removing, or modifying class specifications. A prototype tool incorporating this and other algorithms has been developed as part of the IGLOO project, which is a large object-oriented software engineering joint research project involving academic and industrial partners. The tool can generate either the concept lattice or several variant structures incrementally by incorporating new classes one by one. The resulting hierarchies can be interactively explored and refined using a graphical browser. In addition, several metrics are computed to help evaluating the quality of the hierarchies. Experiments are presented to better assess the applicability of the approach. © 1998 John Wiley & Sons, Inc.

Design of class hierarchies based on concept, (Galois) lattices

Building and maintaining the class hierarchy has been recognized as an important but one of the most difficult activities of object-oriented design. Concept (or Galois) lattices and related structures are presented as a framework for dealing with the design and maintenance of class hierarchies. Because the design of class hierarchies is inherently an iterative and incremental process, we designed incremental algorithms that update existing Galois lattices as the result of adding, removing, or modifying class specifications. A prototype tool incorporating this and other algorithms has been developed as part of the IGLOO project, which is a large object-oriented software engineering joint research project involving academic and industrial partners. The tool can generate either the concept lattice or several variant structures incrementally by incorporating new classes one by one. The resulting hierarchies can be interactively explored and refined using a graphical browser. In addition, several metrics are computed to help evaluating the quality of the hierarchies. Experiments are presented to better assess the applicability of the approach. © 1998 John Wiley & Sons, Inc.