Empirical validation of object-oriented metrics on open source software for fault prediction

Open source software systems are becoming increasingly important these days. Many companies are investing in open source projects and lots of them are also using such software in their own work. But, because open source software is often developed with a different management style than the industrial ones, the quality and reliability of the code needs to be studied. Hence, the characteristics of the source code of these projects need to be measured to obtain more information about it. This paper describes how we calculated the object-oriented metrics given by Chidamber and Kemerer to illustrate how fault-proneness detection of the source code of the open source Web and e-mail suite called Mozilla can be carried out. We checked the values obtained against the number of bugs found in its bug database - called Bugzilla - using regression and machine learning methods to validate the usefulness of these metrics for fault-proneness prediction. We also compared the metrics of several versions of Mozilla to see how the predicted fault-proneness of the software system changed during its development cycle.     

故障检测率对软件可靠性影响实证分析

故障检测率是软件可靠性模型的主要参数之一,不同形式的故障检测率具有不同的作用。聚焦于故障检测率对软件可靠性的影响,提出基于信息熵与优劣距离决策算法的单可靠性模型单失效数据集多故障检测率与多可靠性增长模型多失效数据集多故障检测率2种实证分析方案,旨在全面地分析故障检测率的影响。经过实验分析,对于单一可靠性模型单一数据集,故障检测率对软件可靠性的影响主要与失效数据集相关,在不同数据集上不同故障检测率函数的性能差异较大;在多可靠性模型多数据集上,幂函数与S型故障检测率对应的软件可靠性模型的综合性能较好,指数型故障检测率对应的软件可靠性模型的综合性能较差。本文的研究对于软件可靠性建模中的模型参数选择、最优发布时间的确定等具有较强的指导作用。     

Using structural and textual information to capture feature coupling in object-oriented software

Previous studies have demonstrated the relationship between coupling and external software quality attributes, such as fault-proneness, and the application of coupling to software maintenance tasks, such as impact analysis. These previous studies concentrate on class coupling. However, there is a growing focus on the study of features in software, and features are often implemented across multiple classes, meaning class-level coupling measures are not applicable. We ask the pertinent question, “Is measuring coupling at the feature-level also useful?” We define new feature coupling metrics based on structural and textual source code information and extend the unified framework for coupling measurement to include these new metrics. We also conduct three extensive case studies to evaluate these new metrics and answer this research question. The first study examines the relationship between feature coupling and fault-proneness, the second assesses feature coupling in the context of impact analysis, and the third study surveys developers to determine if the metrics align with what they consider to be coupled features. All three studies provide evidence that feature coupling metrics are indeed useful new measures that capture coupling at a higher level of abstraction than classes and can be useful for finding bugs, guiding testing effort, and assessing change impact.     

面向对象软件的技术度量

软件度量学是软件工程领域的一个重要研究方向。通过软件度量,可以改进软件的体系结构,采用合适的软件开发过程,从而降低软件开发的成本,提高软件开发的效率,保证软件能满足用户的需求,开发出高质量的软件。分析了面向对象软件度量的特点,阐述了常用的面向对象软件度量方法,并在此基础上提出了以切片为中心的度量方法。     

面向对象软件的测试评估

软件测试的目的是发现错误,而不是确认其正确性,是为了增强人们对软件能够按照需求者的期望正确运行的信心,因此需要对软件测试质量进行度量.由于面向对象软件所具有的特性,面向对象软件的测试的度量相对于在过程测试中的测试度量已经不再适应.利用切片和领域的概念,通过多层次的测试度量来对面向对象软件的测试进行评估,该方法能够为改进对面向对象软件系统的测试过程和测试策略提供帮助.     

Evaluating inheritance depth on the maintainability of object-oriented software

This empirical research was undertaken as part of a multi-method programme of research to investigate unsupported claims made of object-oriented technology. A series of subject-based laboratory experiments, including an internal replication, tested the effect of inheritance depth on the maintainability of object-oriented software. Subjects were timed performing identical maintenance tasks on object-oriented software with a hierarchy of three levels of inheritance depth and equivalent object-based software with no inheritance. This was then replicated with more experienced subjects. In a second experiment of similar design, subjects were timed performing identical maintenance tasks on object-oriented software with a hierarchy of five levels of inheritance depth and the equivalent object-based software.The collected data showed that subjects maintaining object-oriented software with three levels of inheritance depth performed the maintenance tasks significantly quicker than those maintaining equivalent object-based software with no inheritance. In contrast, subjects maintaining the object-oriented software with five levels of inheritance depth took longer, on average, than the subjects maintaining the equivalent object-based software (although statistical significance was not obtained). Subjects' source code solutions and debriefing questionnaires provided some evidence suggesting subjects began to experience difficulties with the deeper inheritance hierarchy.It is not at all obvious that object-oriented software is going to be more maintainable in the long run. These findings are sufficiently important that attempts to verify the results should be made by independent researchers.     

面向对象软件测试及度量的研究

软件测试方法和度量是提高和保证软件质量的关键,文中介绍了一种认识面向对象软件集成测试和试想量的方法（URI）,以及一种继承树深度（DIT）的度量标准,从这一测试方法显示继承的过多使用将增加软件测试的复杂性,论文最后介绍了有待进一步研究的问题。     

Empirical analysis of CK metrics for object-oriented design complexity: implications for software defects

To produce high quality object-oriented (OO) applications, a strong emphasis on design aspects, especially during the early phases of software development, is necessary. Design metrics play an important role in helping developers understand design aspects of software and, hence, improve software quality and developer productivity. In this paper, we provide empirical evidence supporting the role of OO design complexity metrics, specifically a subset of the Chidamber and Kemerer (1991, 1994) suite (CK metrics), in determining software defects. Our results, based on industry data from software developed in two popular programming languages used in OO development, indicate that, even after controlling for the size of the software, these metrics are significantly associated with defects. In addition, we find that the effects of these metrics on defects vary across the samples from two programming languages-C++ and Java. We believe that these results have significant implications for designing high-quality software products using the OO approach.     

On the complex nature of MDE evolution and its impact on changeability

In model-driven engineering (MDE), a particular MDE setting of employed languages and automated and manual activities has major impact on productivity. Furthermore, it has been observed that such MDE settings evolve over time. However, currently not much is known about this evolution and its impact on the MDE setting’s maturity, i.e., on changeability and other productivity dimensions. Research so far focuses on evolution of separate building blocks, such as (modeling-) languages, tools, or transformation, only. In this article, we address the lack of knowledge about evolution of MDE settings by investigating case studies from different companies. The first results reveal (1) that there is evolution that affects the composition of an MDE setting (structural evolution) and has the potential to strongly impact aspects, such as changeability and (2) that this structural evolution actually occurs in practice. Based on these first results, we investigated (3) whether there are cases in practice, where structural evolution already altered the risks of changeability given by the respective MDE setting. Therefore, we search and identify examples for such evolution steps on MDE settings from practice and collected six case studies on evolution histories in detail. As a result, we show in this paper that structural evolution (a) is not seldom in practice and (b) sometimes leads to the introduction of changeability risks.     

基于面向对象的类测试技术研究

面向对象软件测试是面向对象软件开发的一个重要阶段，是保证软件质量、提高软件可靠性的关键，而类测试又是面向对象软件测试的关键。文章针对面向对象程序的特性对软件测试的影响，研究了一种基于状态的类测试方法，从而能够更有效地对面向对象软件进行测试，提高了软件的质量。     

架构和面向对象技术在PLC软件开发中的应用

为降低开发实时多任务控制系统PLC软件的复杂性、提高软件开发效率和质量,把架构和对象技术引入了PLC软件开发。结合对象技术和控制系统特点,强调了抽象对象的概念,提出了被控对象和控制器对象分离的思想,指出了对象技术的适用范围,设计了PLC控制软件架构的结构模型和控制风格。该模型中单元机器级应用对象技术,在单元机器控制软件内部应用面向任务分析与设计方法,并在一个分布式输送机组的控制软件中实现了该模型。     

基于有限自动机的面向对象软件规约测试

面向对象方法已经逐步代替基于过程的方法成为软件开发的主流,然而面向对象软件的测试和维护代价却并没有因此而减少.虽然在面向对象软件测试方面做了很多的研究工作,但是大多数针对面向对象软件测试的研究都是针对单一类的测试,而不是更高层次上的对面向对象软件规约的测试.提出了一种基于有限自动机的测试框架以测试面向对象软件规约中存在的不完整性和不一致性.该方法有别于公式证明和模型检查,它直接依据可执行的有限自动机来执行测试而不是人工的推导公式证明也不产生大量的状态空间.     

The effect of task order on the maintainability of object-oriented software

This paper presents results from a quasi-experiment that investigates how the sequence in which maintenance tasks are performed affects the time required to perform them and the functional correctness of the changes made. Specifically, the study compares how time required and correctness are affected by (1) starting with the easiest change task and progressively performing the more difficult tasks (Easy-First), versus (2) starting with the most difficult change task and progressively performing the easier tasks (Hard-First). In both cases, the experimental tasks were performed on two alternative types of design of a Java system to assess whether the choice of the design strategy moderates the effects of task order on effort and correctness.The results show that the time spent on making the changes is not affected significantly by the task order of the maintenance tasks, regardless of the type of design. However, the correctness of the maintainability tasks is significantly higher when the task order of the change tasks is Easy-First compared to Hard-First, again regardless of design. A possible explanation for the results is that a steeper learning curve (Hard-First) causes the programmer to create software that is less maintainable overall.     

Mining the impact of evolution categories on object-oriented metrics

Despite the relevance of the software evolution phase, there are few characterization studies on recurrent evolution growth patterns and on their impact on software properties, such as coupling and cohesion. In this paper, we report a study designed to investigate whether the software evolution categories proposed by Lanza can be used to explain not only the growth of a system in terms of lines of code (LOC), but also in terms of metrics from the Chidamber and Kemerer (CK) object-oriented metrics suite. Our results show that high levels of recall (ranging on average from 52 to 72 %) are achieved when using LOC to predict the evolution of coupling and size. For cohesion, we have achieved smaller recall rates (<27 % on average).     

A comprehensive program representation of object-oriented software

An extensible representation for object-oriented programs, the Object-oriented Program Dependence Graph (OPDG), is presented. The representation is divided into three layers: a first layer that presents the class inheritance structure, a second layer that combines a traditional control dependence subgraph and a data dependence subgraph with objects, and a third layer that presents the dynamic, runtime aspects of an object-oriented program as an Object Dependence Subgraph. The representation is modular allowing specific tools to only use the portion required for the tool's operation. The complete representation provides information sufficient for most program analysis techniques including data flow analysis, reverse engineering, interactive debuggers and other tools.     

Search based software testing of object-oriented containers

Automatic software testing tools are still far from ideal for real world object-oriented (OO) software. The use of nature inspired search algorithms for this problem has been investigated recently. Testing complex data structures (e.g., containers) is very challenging since testing software with simple states is already hard. Because containers are used in almost every type of software, their reliability is of utmost importance. Hence, this paper focuses on the difficulties of testing container classes with nature inspired search algorithms. We will first describe how input data can be automatically generated for testing Java containers. Input space reductions and a novel testability transformation are presented to aid the search algorithms. Different search algorithms are then considered and studied in order to understand when and why a search algorithm is effective for a testing problem. In our experiments, these nature inspired search algorithms seem to give better results than the traditional techniques described in literature. Besides, the problem of minimising the length of the test sequences is also addressed. Finally, some open research questions are given.     

Analysis of object-oriented software reliability model development

Can object-oriented methods be applied to mathematical software? Apparently, according to Beall and Shepard (An object-oriented framework for reliable numerical simulations, object-oriented software. Addison Wesley, Reading, 1994) who say: “It has been recognized in a number of different fields that object-oriented programming, in general, and software frameworks, in particular, provide a means to allow the efficient construction and maintenance of large scale software systems. Since general purpose numerical analysis codes certainly qualify as large-scale software it makes sense for us to see how these methodologies can be applied to this field.”     

A software complexity model of object-oriented systems

A model for the emerging area of software complexity measurement of OO systems is required for the integration of measures defined by various researchers and to provide a framework for continued investigation. We present a model, based in the literature of OO systems and software complexity for structured systems. The model defines the software complexity of OO systems at the variable, method, object, and system levels. At each level, measures are identified that account for the cohesion and coupling aspects of the system. Users of OO techniques perceptions of complexity provide support for the levels and measures.     

On the impact of software evolution on software clustering

The evolution of a software project is a rich data source for analyzing and improving the software development process. Recently, several research groups have tried to cluster source code artifacts based on information about how the code of a software system evolves. The results of these evolutionary approaches seem promising, but a direct comparison to traditional software clustering approaches based on structural code dependencies is still missing. To fill this gap, we conducted several clustering experiments with an established software clustering tool comparing and combining the evolutionary and the structural approach. These experiments show that the evolutionary approach could produce meaningful clustering results. While the traditional approach provides better results because of a more reliable data density of the structural data, the combination of both approaches is able to improve the overall clustering quality. A review of related studies shows that this approach of combining dependency information is also successful in other software engineering applications.     

An evaluation of the MOOD set of object-oriented software metrics

This paper describes the results of an investigation into a set of metrics for object-oriented design, called the MOOD metrics. The merits of each of the six MOOD metrics is discussed from a measurement theory viewpoint, taking into account the recognized object-oriented features which they were intended to measure: encapsulation, inheritance, coupling, and polymorphism. Empirical data, collected from three different application domains, is then analyzed using the MOOD metrics, to support this theoretical validation. Results show that (with appropriate changes to remove existing problematic discontinuities) the metrics could be used to provide an overall assessment of a software system, which may be helpful to managers of software development projects. However, further empirical studies are needed before these results can be generalized