Hayden Melton

The Qualitas Corpus: A Curated Collection of Java Code for Empirical Studies

In order to increase our ability to use measurement to support software development practise we need to do more analysis of code. However, empirical studies of code are expensive and their results are difficult to compare. We describe the Qualitas Corpus, a large curated collection of open source Java systems. The corpus reduces the cost of performing large empirical studies of code and supports comparison of measurements of the same artifacts. We discuss its design, organisation, and issues associated with its development.

Understanding the shape of Java software

Large amounts of Java software have been written since the languages escape into unsuspecting software ecology more than ten years ago. Surprisingly little is known about the structure of Java programs in the wild: about the way methods are grouped into classes and then into packages, the way packages relate to each other, or the way inheritance and composition are used to put these programs together. We present the results of the first in-depth study of the structure of Java programs. We have collected a number of Java programs and measured their key structural attributes. We have found evidence that some relationships follow power-laws, while others do not. We have also observed variations that seem related to some characteristic of the application itself. This study provides important information for researchers who can investigate how and why the structural relationships we find may have originated, what they portend, and how they can be managed.

An empirical study of cycles among classes in Java

Advocates of the design principle avoid cyclic dependencies among modules have argued that cycles are detrimental to software quality attributes such as understandability, testability, reusability, buildability and maintainability, yet folklore suggests such cycles are common in real object-oriented systems. In this paper we present the first significant empirical study of cycles among the classes of 78 open- and closed-source Java applications. We find that, of the applications comprising enough classes to support such a cycle, about 45% have a cycle involving at least 100 classes and around 10% have a cycle involving at least 1,000 classes. We present further empirical evidence to support the contention these cycles are not due to intrinsic interdependencies between particular classes in a domain. Finally, we attempt to gauge the strength of connection among the classes in a cycle using the concept of a minimum edge feedback set.

How Do Java Programs Use Inheritance? An Empirical Study of Inheritance in Java Software

Inheritance is a crucial part of object-oriented programming, but its use in practice, and the resulting large-scale inheritance structures in programs, remain poorly understood. Previous studies of inheritance have been relatively small and have generally not considered issues such as Javas distinction between classes and interfaces, nor have they considered the use of external libraries. In this paper we present the first substantial empirical study of the large-scale use of inheritance in a contemporary OO programming language. We present a suite of structured metrics for quantifying inheritance in Java programs. We present the results of performing a corpus analysis using those metrics to over 90 applications consisting of over 100,000 separate classes and interfaces. Our analysis finds higher use of inheritance than anticipated, variation in the use of inheritance between interfaces and classes, and differences between inheritance within application types compared with inheritance from external libraries.

On the usage and usefulness of OO design principles

There is a plethora of instructional literature on Object-Oriented (OO) design. Riel’s book [17] of heuristics, for instance, presents 60 rules of thumb for structuring OO systems (e.g don’t create god classes). The Gang of Four’s Design Patterns book [7] contains 23 “patterns”, which are “elegant” solutions to recurring OO design problems (e.g. use Observer to break the dependency of an application’s model on its view). Other books [4, 19, 10] provide entire methodologies for structuring OO systems with advice ranging from naming conventions (e.g. classes should be nouns) to criteria for identifying abstractions as candidates for operations, classes and subsystems. Despite the vast amount of literature describing how OO systems should be structured, we have very little knowledge of how they are actually structured. In other words, we have very little idea the extent to which software developers in industry follow the “design principles” proposed in the literature. Casual observations made by luminaries such as Wirth [20], Parnas [16] and Foote [6] suggest that many design principles are not widely followed in the construction of “real” software systems. In this paper I explain why we would like to know with greater certainty the extent to which developers of OO software follow design principles, and how we might go about determining this.