An empirical study of evolution of inheritance in Java OSS

Previous studies of Object-Oriented (OO) software have reported avoidance of the inheritance mechanism and cast doubt on the wisdom of ‘deep’ inheritance levels. From an evolutionary perspective, the picture is unclear - we still know relatively little about how, over time, changes tend to be applied by developers. Our conjecture is that an inheritance hierarchy will tend to grow ‘breadth-wise’ rather than ‘depth-wise’. This claim is made on the basis that developers will avoid extending depth in favour of breadth because of the inherent complexity of having to understand the functionality of superclasses. Thus the goal of our study is to investigate this empirically. We conduct an empirical study of seven Java Open-Source Systems (OSSs) over a series of releases to observe the nature and location of changes within the inheritance hierarchies. Results show a strong tendency for classes to be added at levels one and two of the hierarchy (rather than anywhere else). Over 96% of classes added over the course of the versions of all systems were at level 1 or level 2. The results suggest that changes cluster in the shallow levels of a hierarchy; this is relevant for developers since it indicates where remedial activities such as refactoring should be focused

Logic programming and software maintenance

The main objective of this short paper is to describe the relationship between software maintenance and logic programming (both declarative and procedural), and to show how ideas and methods from logic programming (in particular, methods invented by M. Gelfond) can be used in software maintenance. The material presented in this paper partly appeared in (Luqi and Cooke, 1995). The main difference is that (Luqi and Cooke, 1995) is aimed mainly at software engineers, so it only briefly touches on the software engineering problems, while describing in great detail the basics of logic programming. In contrast, in this paper, we assume that the corresponding logic programming notions are well known, but describe the corresponding software engineering applications in greater detail

An application of machine learning to the organization of institutional software repositories

Software reuse has become a major goal in the development of space systems, as a recent NASA-wide workshop on the subject made clear. The Data Systems Technology Division of Goddard Space Flight Center has been working on tools and techniques for promoting reuse, in particular in the development of satellite ground support software. One of these tools is the Experiment in Libraries via Incremental Schemata and Cobweb (ElvisC). ElvisC applies machine learning to the problem of organizing a reusable software component library for efficient and reliable retrieval. In this paper we describe the background factors that have motivated this work, present the design of the system, and evaluate the results of its application

What is Your Software Worth?

This article presents a method for valuing software based on the income that use of that software is expected to generate in the future. Well-known principles of intellectual property (IP) valuation, sales expectations, discounting to present value, and the like, are applied, always focusing on the benefits and costs of software. A major issue, not dealt with in the literature of valuing intangibles, is that software is continually upgraded. Applying depreciation schedules is the simple solution, but does not represent at all the actual devaluation of the inherent IP of software. A realistic approach, allowing ongoing maintenance, is presented here. All steps of the process are presented and then integrated via a simple quantitative example. Having a quantitative model on a spreadsheet allows exploration of business alternatives. An example a service model is evaluated. Conclusions are drawn that reflect on academic and business practice.Valuation, intellectual property, software, software life, maintenance

An experimental examination of the role of re-engineering in the management of software quality

This paper reports on the design and the results of a randomised, controlled experiment estimating the effect of predetermined changes in module complexity on the maintainability of different program versions seeded with equivalent logic errors. The experiment measures maintainability which is a defining sub-attribute of quality. The hypothesis "low module complexity results in high maintainability" is tested experimentally by monitoring and recording the time taken to identify and correct the seeded errors. Prior to the experiment programs are statically analysed to produce measurements of internal sub-attributes of the fundamental attribute of complexity. A first program version is modularised according to established rules giving a new version with a larger number of modules and with smaller individual module complexity. The results of this work can be used to design tools capable of providing an indicator, or factor, for re-engineering whereby a given program can be restructured in such a way that quality improvement can be quantified or at least estimated. As maintainability is a defining attribute of quality the insights gained can be further applied in understanding the underlying processes involved and ultimately lead to quality improvements

Class movement and re-location: An empirical study of Java inheritance evolution

This is the post-print version of the final paper published in Journal of Systems and Software. The published article is available from the link below. Changes resulting from the publishing process, such as peer review, editing, corrections, structural formatting, and other quality control mechanisms may not be reflected in this document. Changes may have been made to this work since it was submitted for publication. Copyright @ 2009 Elsevier B.V.Inheritance is a fundamental feature of the Object-Oriented (OO) paradigm. It is used to promote extensibility and reuse in OO systems. Understanding how systems evolve, and specifically, trends in the movement and re-location of classes in OO hierarchies can help us understand and predict future maintenance effort. In this paper, we explore how and where new classes were added as well as where existing classes were deleted or moved across inheritance hierarchies from multiple versions of four Java systems. We observed first, that in one of the studied systems the same set of classes was continuously moved across the inheritance hierarchy. Second, in the same system, the most frequent changes were restricted to just one sub-part of the overall system. Third, that a maximum of three levels may be a threshold when using inheritance in a system; beyond this level very little activity was observed, supporting earlier theories that, beyond three levels, complexity becomes overwhelming. We also found evidence of ‘collapsing’ hierarchies to bring classes up to shallower levels. Finally, we found that larger classes and highly coupled classes were more frequently moved than smaller and less coupled classes. Statistical evidence supported the view that larger classes and highly coupled classes were less cohesive than smaller classes and lowly coupled classes and were thus more suitable candidates for being moved (within an hierarchy)

MONITORING THE SOFTWARE ASSET: REPOSITORY EVALUATION OF SOFTWARE REUSE

Traditionally, software management has focused primarily upon cost control. Today, with the emerging capabilities of computer aided software engineering (CASE) and corresponding changes in the development process, the opportunity exists to view software development as an activity that creates reusable software assets, rather than just expenses, for the corporation. With this opportunity comes the need to monitor software at the corporate level, as well as at that of the individual software development project. Integrated CASE environments can support such monitoring. In this paper we propose the use of a new approach called repository evaluation, and illustrate it in an analysis of the evolving repository-based software assets of two large firms that have implemented integrated CASE development tools. The analysis shows that these tools have supported high levels of software reuse, but it also suggests that there remains considerable unexploited reuse potential. Our findings indicate that organizational changes will be required before the full potential of the new technology can be realized.Information Systems Working Papers Serie

New Inheritance Complexity Metrics for Object-Oriented Software Systems: An Evaluation with Weyuker's Properties

Two inheritance complexity metrics, one at class level CCI (Class Complexity due to Inheritance) and another at program level ACI (Average Complexity of a program due to Inheritance), have been proposed for object-oriented software systems. These proposed metrics are evaluated with Weyuker's properties and compared with other well known object-oriented inheritance metrics. It has been found that the proposed metrics better represent the complexity, due to inheritance, of a class and a program. Weyuker's property 7 (Significance of Permutation) has received a negative response regarding its applicability to object-oriented software metrics. It has been observed that this property is not satisfied by any of the object-oriented inheritance metrics proposed so far. Contrary to past beliefs, the relevance of this property to object-oriented systems has been brought out in this paper. Examples with C++ code are also presented to support the applicability of this property