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

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)

A framework for the simulation of structural software evolution

This is the author's accepted manuscript. The final published article is available from the link below. Copyright @ 2008 ACM.As functionality is added to an aging piece of software, its original design and structure will tend to erode. This can lead to high coupling, low cohesion and other undesirable effects associated with spaghetti architectures. The underlying forces that cause such degradation have been the subject of much research. However, progress in this field is slow, as its complexity makes it difficult to isolate the causal flows leading to these effects. This is further complicated by the difficulty of generating enough empirical data, in sufficient quantity, and attributing such data to specific points in the causal chain. This article describes a framework for simulating the structural evolution of software. A complete simulation model is built by incrementally adding modules to the framework, each of which contributes an individual evolutionary effect. These effects are then combined to form a multifaceted simulation that evolves a fictitious code base in a manner approximating real-world behavior. We describe the underlying principles and structures of our framework from a theoretical and user perspective; a validation of a simple set of evolutionary parameters is then provided and three empirical software studies generated from open-source software (OSS) are used to support claims and generated results. The research illustrates how simulation can be used to investigate a complex and under-researched area of the development cycle. It also shows the value of incorporating certain human traits into a simulation—factors that, in real-world system development, can significantly influence evolutionary structures

An analysis of inheritance hierarchy evolution

This research investigates the evolution of object-oriented inheritance hierarchies in open source, Java systems. The paper contributes an understanding of how hierarchies, particularly large complex hierarchies, evolve in ‘real world’ systems. It informs object-oriented design practices that aim to control or avoid these complicated design structures. The study is based on a detailed analysis of 665 inheritance hierarchies drawn from a total of 262 versions of 10 open source systems. The research contributions include that: i) the majority of inheritance hierarchies are ‘simple’ in structure and remain that way throughout their lifetimes ii) the majority of hierarchies are stable in terms of size and shape throughout their lifetimes iii) there is a minority of large, complex, branching ‘Subtree’ hierarchies that continue to grow ever more complicated as the systems evolve iv) a detailed analysis of some of these larger hierarchies finds evidence of ‘good’ object-oriented design practices being used but also highlights the significant challenges involved in understanding and refactoring these complex structures. There is clear evidence that some of the complex hierarchies are emphasising reuse while others appear focused on type inheritance

An empirical investigation of inheritance trends in JAVA OSS evolution

This thesis was submitted for the degree of Doctor of Philosophy and awarded by Brunel University.Inheritance is a salient feature of Object-Oriented (OO) paradigm which facilitates reuse and improves system comprehensibility in OO systems. The overall aim of inheritance is to model classes in a structured hierarchy where classes residing lower in the hierarchy (subclasses) can inherit the pre-existing functionality in the classes located higher up (superclasses) in the same line of hierarchy. Software maintenance and evolution are the process of making any modifications to a software system and upgrading its dynamic behaviour. In this Thesis, we empirically investigate the trends of evolution of eight Java Open-Source Systems (OSS) from an inheritance perspective and model the propensity for changes of inheritance in those systems. The systems used as testbed in this Thesis represent a variety of application domains with varying sizes and amount of inheritance employed. There are several levels of granularity for inheritance evolution that may manifest a particular trend. This starts from the highest level (package) to lower class, method an attribute levels; and each level may show a different and yet an important pattern of evolution. We empirically investigate the changes of inheritance in the form of increases (additions) and decreases (deletions) in number of classes, methods and attributes. Our analysis also includes the movement of classes within and across an inheritance hierarchy which is another compelling facet of evolution of inheritance and may not be extrapolated through incremental changes only. It requires a finer-grained scrutiny of evolutionary traits of inheritance. In addition, the Thesis also explores the trends of class interaction within and across an inheritance hierarchy and problems embedded in a system that may lead to faults, from an inheritance perspective. The results demonstrate how inheritance is used in practice, problems associated with inheritance and how inheritance hierarchies evolve as opposed to that of a ‘system’. Overall results informed our understanding of the trends in changes of inheritance in the evolution of Java systems

An empirical investigation into contributory factors of change and fault propensity in large-scale commercial object-oriented software

This thesis was submitted for the degree of Doctor of Philosophy and was awarded by Brunel UniversityObject-Oriented design and development dominates both commercial and open source software projects. One of the principal goals of object-oriented design is to aid reuse, and hence, reduce future maintenance efforts of software systems. However, the on-going maintenance of large-scale software systems (both changes and faults) continues to be a significant proportion of the lifecycle of the system and the total investment cost. Understanding and thus being able to predict - or even reduce - the impact of the contributing factors of future maintenance efforts of a software system is thus highly beneficial to software practitioners. In this Thesis we empirically study a large, commercial software system with the principal aim to determine the contributing factors to the change and fault propensity over a three-year period. We consider the object-oriented design context of the software, specifically its inheritance characteristics, coupling and cohesion properties, object-oriented design pattern participation, and size. We also explore the effect of refactoring and test classes in the software. Our results show that several aspects of the design context of a class have an impact to the change and fault-proneness of the software. Specifically, we show that classes with high afferent or efferent coupling are more change and fault-prone; we also identify a number of design patterns whose participants tend to have a higher change and fault propensity than non-participants and we identify a range of inheritance characteristics (in terms of depth of inheritance and number of children) that result in an increase to change and fault-proneness. Furthermore we show that refactoring is a commonly occurring maintenance activity, although it is largely limited to simpler types of refactorings. Finally, we provide some insight into the co-evolution of production and test code during refactoring

An empirical investigation of inheritance trends in Java OSS evolution

Inheritance is a salient feature of Object-Oriented (OO) paradigm which facilitates reuse and improves system comprehensibility in OO systems. The overall aim of inheritance is to model classes in a structured hierarchy where classes residing lower in the hierarchy (subclasses) can inherit the pre-existing functionality in the classes located higher up (superclasses) in the same line of hierarchy. Software maintenance and evolution are the process of making any modifications to a software system and upgrading its dynamic behaviour. In this Thesis, we empirically investigate the trends of evolution of eight Java Open-Source Systems (OSS) from an inheritance perspective and model the propensity for changes of inheritance in those systems. The systems used as testbed in this Thesis represent a variety of application domains with varying sizes and amount of inheritance employed. There are several levels of granularity for inheritance evolution that may manifest a particular trend. This starts from the highest level (package) to lower class, method an attribute levels; and each level may show a different and yet an important pattern of evolution. We empirically investigate the changes of inheritance in the form of increases (additions) and decreases (deletions) in number of classes, methods and attributes. Our analysis also includes the movement of classes within and across an inheritance hierarchy which is another compelling facet of evolution of inheritance and may not be extrapolated through incremental changes only. It requires a finer-grained scrutiny of evolutionary traits of inheritance. In addition, the Thesis also explores the trends of class interaction within and across an inheritance hierarchy and problems embedded in a system that may lead to faults, from an inheritance perspective. The results demonstrate how inheritance is used in practice, problems associated with inheritance and how inheritance hierarchies evolve as opposed to that of a ‘system’. Overall results informed our understanding of the trends in changes of inheritance in the evolution of Java systems.EThOS - Electronic Theses Online ServiceGBUnited Kingdo