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

State of Refactoring Adoption: Towards Better Understanding Developer Perception of Refactoring

Context: Refactoring is the art of improving the structural design of a software system without altering its external behavior. Today, refactoring has become a well-established and disciplined software engineering practice that has attracted a significant amount of research presuming that refactoring is primarily motivated by the need to improve system structures. However, recent studies have shown that developers may incorporate refactoring strategies in other development-related activities that go beyond improving the design especially with the emerging challenges in contemporary software engineering. Unfortunately, these studies are limited to developer interviews and a reduced set of projects. Objective: We aim at exploring how developers document their refactoring activities during the software life cycle. We call such activity Self-Affirmed Refactoring (SAR), which is an indication of the developer-related refactoring events in the commit messages. After that, we propose an approach to identify whether a commit describes developer-related refactoring events, to classify them according to the refactoring common quality improvement categories. To complement this goal, we aim to reveal insights into how reviewers develop a decision about accepting or rejecting a submitted refactoring request, what makes such review challenging, and how to the efficiency of refactoring code review. Method: Our empirically driven study follows a mixture of qualitative and quantitative methods. We text mine refactoring-related documentation, then we develop a refactoring taxonomy, and automatically classify a large set of commits containing refactoring activities, and identify, among the various quality models presented in the literature, the ones that are more in-line with the developer\u27s vision of quality optimization, when they explicitly mention that they are refactoring to improve them to obtain an enhanced understanding of the motivation behind refactoring. After that, we performed an industrial case study with professional developers at Xerox to study the motivations, documentation practices, challenges, verification, and implications of refactoring activities during code review. Result: We introduced SAR taxonomy on how developers document their refactoring strategies in commit messages and proposed a SAR model to automate the detection of refactoring. Our survey with code reviewers has revealed several difficulties related to understanding the refactoring intent and implications on the functional and non-functional aspects of the software. Conclusion: Our SAR taxonomy and model, can work in conjunction with refactoring detectors, to report any early inconsistency between refactoring types and their documentation and can serve as a solid background for various empirical investigations. In light of our findings of the industrial case study, we recommended a procedure to properly document refactoring activities, as part of our survey feedback

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

Software module clustering: An in-depth literature analysis

Software module clustering is an unsupervised learning method used to cluster software entities (e.g., classes, modules, or files) with similar features. The obtained clusters may be used to study, analyze, and understand the software entities' structure and behavior. Implementing software module clustering with optimal results is challenging. Accordingly, researchers have addressed many aspects of software module clustering in the past decade. Thus, it is essential to present the research evidence that has been published in this area. In this study, 143 research papers from well-known literature databases that examined software module clustering were reviewed to extract useful data. The obtained data were then used to answer several research questions regarding state-of-the-art clustering approaches, applications of clustering in software engineering, clustering processes, clustering algorithms, and evaluation methods. Several research gaps and challenges in software module clustering are discussed in this paper to provide a useful reference for researchers in this field

Closing the gap between guidance and practice, an investigation of the relevance of design guidance to practitioners using object-oriented technologies

This thesis investigates if object oriented guidance is relevant in practice, and how this affects software that is produced. This is achieved by surveying practitioners and studying how constructs such as interfaces and inheritance are used in open-source systems. Surveyed practitioners framed 'good design' in terms of impact on development and maintenance. Recognition of quality requires practitioner judgement (individually and as a group), and principles are valued over rules. Time constraints heighten sensitivity to the rework cost of poor design decisions. Examination of open source systems highlights the use of interface and inheritance. There is some evidence of 'textbook' use of these structures, and much use is simple. Outliers are widespread indicating a pragmatic approach. Design is found to reflect the pressures of practice - high-level decisions justify 'designed' structures and architecture, while uncertainty leads to deferred design decisions - simpler structures, repetition, and unconsolidated design. Sub-populations of structures can be identified which may represent common trade-offs. Useful insights are gained into practitioner attitude to design guidance. Patterns of use and structure are identified which may aid in assessment and comprehension of object oriented systems.This thesis investigates if object oriented guidance is relevant in practice, and how this affects software that is produced. This is achieved by surveying practitioners and studying how constructs such as interfaces and inheritance are used in open-source systems. Surveyed practitioners framed 'good design' in terms of impact on development and maintenance. Recognition of quality requires practitioner judgement (individually and as a group), and principles are valued over rules. Time constraints heighten sensitivity to the rework cost of poor design decisions. Examination of open source systems highlights the use of interface and inheritance. There is some evidence of 'textbook' use of these structures, and much use is simple. Outliers are widespread indicating a pragmatic approach. Design is found to reflect the pressures of practice - high-level decisions justify 'designed' structures and architecture, while uncertainty leads to deferred design decisions - simpler structures, repetition, and unconsolidated design. Sub-populations of structures can be identified which may represent common trade-offs. Useful insights are gained into practitioner attitude to design guidance. Patterns of use and structure are identified which may aid in assessment and comprehension of object oriented systems

An empirical study on object-oriented software dependencies: logical, structural and semantic

This thesis was submitted for the award of Doctor of Philosophy and was awarded by Brunel University LondonThree of the most widely studied software dependency types are the structural, logical and semantic dependencies. Logical dependencies capture the degree of co-change between software artifacts. Semantic dependencies capture the degree to which artifacts, comments and names are related. Structural dependencies capture the dependencies in the source code of artifacts. Prior studies show that a combination of dependency analysis (e.g., semantic and logical analysis) improves accuracy when predicting which artifacts are likely to be impacted by ripple effects of software changes (though not to a large extent) compared to individual approaches. In addition, some dependencies could be hidden dependencies when an analysis of one dependency type (e.g., logical) does not reveal artifacts only linked by another dependency type (semantic). While previous studies have focused on combining dependency information with minimal benefits, this Thesis explores the consistency of these measurements, and whether hidden dependencies arise between artifacts, and in any of the axes studied. In this Thesis, 79 Java projects are empirically studied to investigate (i) the direct influence and the degree of overlap between dependency types on three axes (logical – structural (LSt); logical – semantic (LSe); structural – semantic (StSe)) (structural, logical and semantic), and (ii) the presence of hidden coupling on the axes. The results show that a high proportion of hidden dependencies can be detected on the LSt and StSe axes. Notwithstanding, the LSe axis shows a much smaller proportion of hidden dependencies. Practicable refactoring methods to mitigate hidden dependencies are proposed in the Thesis and discussed with examples

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