We present a study of 600 Java software networks with the aim of characterizing the relationship among their defectiveness and community metrics. We analyze the community structure of such networks, defined as their topological division into subnetworks of densely connected nodes. A high density of connections represents a higher level of cooperation between classes, so a well-defined division in communities could indicate that the software system has been designed in a modular fashion and all its functionalities are well separated. We show how the community structure can be an indicator of well-written, high quality code by retrieving the communities of the analyzed systems and by ranking their division in communities through the built-in metric called modularity. We found that the software systems with highest modularity possess the majority of bugs, and tested whether this result is related to some confounding effect. We found two power laws relating the maximum defect density with two different metrics: the number of detected communities inside a software network and the clustering coefficient. We finally found a linear correlation between clustering coefficient and number of communities. Our results can be used to make predictive hypotheses about software defectiveness of future releases of the analyzed systems.

Abstract Web applications are among the most popular and relevant kinds of application. Most Web applications are developed using a content management framework (CMF). CMF helps to accelerate the publication of large amounts of information and the development of Web applications. However, developing Web applications through CMF is not exempt from cost and time overruns, as in traditional software projects. Currently, there is no estimation model able to adequately measure the effort of developing a Web application. This work presents a new methodology, called web framework points, to estimate the effort of Web applications developed with CMF. Web framework points is a hybrid methodology, composed of a sizing phase, which follows specific guidelines, and an effort estimation phase, obtained by applying a cost model to the size model of the project to estimate. The sizing of the project takes into account not only usual functional requirements, as in function points analysis, but also elements specific for developing a Web application through CMF. We also present the experimental validation of the proposed methodology, performed on a dataset of 29 real‐world projects, of which 83% show an estimation error of less than 25%. Copyright © 2015 John Wiley & Sons, Ltd.

Standardized formalizations of the knowledge are used by domain experts to share information in the form \nof reusable knowledge. The primary objective of our work is the definition of an approach for multimedia \ncontent management. We reached that goal through a validation activity which lasted for the last three \nyears, and was carried on through the application on different case studies, some of them described in detail \nin previously published papers. This approach aims to represent the knowledge through a mixed-iterative \napproach, where top-down and bottom-up analyses are applied on the knowledge domain we want to \nrepresent. We focused our research on some issues concerning Knowledge Management, strictly related to \nthe process of making multimedia content-related knowledge easily available to users. We need to represent \nand manage this knowledge, in order to formalize and codify all the knowledge in the domain. This \nformalization can eventually lead us to easily manage that knowledge through the use of repositories. \n

A fundamental aspect of a system's performance over time is the number of faults it generates. The relationship between the software engineering concept of "coupling" (i.e., the degree of inter-connectedness of a system's components) and faults is still a research question attracting attention and a relationship with strong implications for performance; excessive coupling is generally acknowledged to contribute to fault-proneness. In this paper, we explore the relationship between faults and coupling. Two releases from each of three open-source Eclipse projects (six releases in total) were used as an empirical basis and coupling and fault data extracted from those systems. A contrasting coupling profile between fault-free and fault-prone classes was observed and this result was statistically supported. Object-oriented (OO) classes with low values of fan-in (incoming coupling) and fan-out (outgoing coupling) appeared to support fault-free classes, while classes with high fan-out supported relatively fault-prone classes. We also considered size as an influence on fault-proneness. The study thus emphasizes the importance of minimizing coupling where possible (and particularly that of fan-out); failing to control coupling may store up problems for later in a system's life; equally, controlling class size should be a concomitant goal.

The spread of the Social Web is influencing the evolution of Semantic Web: the way of producing and consulting information changes, as well as the way people relate themselves with the Internet and the services it gives. Users will participate at first hand to the developing of the Web which therefore becomes interactive. This study considers this feature, trying to link the worlds of Social Media and Semantic Web, with the aim of proposing a semantic classification of the information coming from the Web, which do not always follow a well-defined order and organization. Starting from a precise analysis of the information of the Web through an accurate and meticulous study on how these are presented and used, in order to give a sorted and easily usable data structure, this approach wants to define a taxonomy able to represent knowledge through an iterative combined approach, where top-down and bottom-up analyses are applied on the knowledge domain we want to represent

The term "software entropy" refers to the tendency for software, over time, to become difficult and costly to maintain. A software system that undergoes continuous change, such as having new functionality added to its original design, will eventually become more complex and can become disorganized as it grows, losing its original design structure. A recent study show that software degradation may be measured using the WMC expressed in terms of Shannon entropy. In this paper we extended the empirical analyses also to RFC and CBO since these CK metrics have been shown to be correlated with fault-proneness of OO classes. We analyzed various releases of the publicly available Eclipse and Netbeans software systems, calculating the entropy of some CK metrics for every release analyzed. The validity is shown through a direct measure of software quality such as the number of detected defects. Our results display a very good correlation between the entropy of CBO and RFC and the number of bugs for Eclipse and Netbeans. Complexity and quality metrics are in general computed on every system module while the entropy is just a scalar number that characterizes a whole system, this result suggests that the entropy of some CK metrics could be considered as a global quality metric for large software systems. Our results need, however, to be confirmed for other large software systems.

SUMMARY A software maintenance process is important for reducing maintenance effort and for improving software quality. In recent years, the Lean–Kanban approach has been widely applied in software practice including software maintenance. This approach minimizes Work‐in‐Progress (WIP), which is the number of items that are worked on by the team at any given time, thus improving the maintenance process. In this paper, we describe our simulation studies, which show that the Lean–Kanban approach can indeed help reduce the average time needed to complete maintenance requests. We develop a process simulator that can simulate both existing maintenance processes that do not use a WIP limit and that adopt it. We perform two case studies using real maintenance data collected from a Microsoft project and from a Chinese software firm. The main results of our study are twofold. First, we demonstrate that it is possible to effectively model and simulate, using actors and events, a maintenance process where a flow of issues is processed through a sequence of activities, correctly reproducing key statistics of real data. Second, our results confirm that the WIP‐limited process could be useful to increase the efficiency of software maintenance, as reported in previous industrial practices. Copyright © 2013 John Wiley & Sons, Ltd.

Several Content Management Frameworks (CMF), either open source or with a commercial license, are available to help the publication of huge amounts of information and to develop Web applications. Unfortunately, developing Web applications through a CMF is not exempt from cost and time overruns, as in traditional software projects, and currently there is no estimation model able to adequately measure the effort of Web application development. This work presents a new methodology for estimating the effort of Web applications developed with a Content Management Framework (CMF). We present the new key elements for analysis and planning, needed to define every important step in developing a Web application through a CMF. Using those elements, it is possible to estimate the effort needed to build such an application in man-days. We also present the experimental validation of the proposed methodology performed on a 9-project dataset, provided by three different Italian software companies.

We present an analysis of the evolution of a Web application project developed with object-oriented technology and an agile process. During the development we systematically performed measurements on the source code, using software metrics that have been proved to be correlated with software quality, such as the Chidamber and Kemerer suite and Lines of Code metrics. We also computed metrics derived from the class dependency graph, including metrics derived from Social Network Analysis. The application development evolved through phases, characterized by a different level of adoption of some key agile practices — namely pair programming, test-based development and refactoring. The evolution of the metrics of the system, and their behavior related to the agile practices adoption level, is presented and discussed. We show that, in the reported case study, a few metrics are enough to characterize with high significance the various phases of the project. Consequently, software quality, as measured using these metrics, seems directly related to agile practices adoption.

The Workshop on Emerging Trends in Software Metrics aims at bringing together researchers and practitioners to discuss the progress of software metrics. The motivation for this workshop is the low impact that software metrics has on current software development. The goals of this workshop are to critically examine the evidence for the effectiveness of existing metrics and to identify new directions for development of software metrics.

The distribution of bugs in software systems has been shown to satisfy the Pareto principle, and typically shows a power-law tail when analyzed as a rank-frequency plot. In a recent paper, Zhang showed that the Weibull cumulative distribution is a very good fit for the Alberg diagram of bugs built with experimental data. In this paper, we further discuss the subject from a statistical perspective, using as case studies five versions of Eclipse, to show how log-normal, Double-Pareto, and Yule-Simon distributions may fit the bug distribution at least as well as the Weibull distribution. In particular, we show how some of these alternative distributions provide both a superior fit to empirical data and a theoretical motivation to be used for modeling the bug generation process. While our results have been obtained on Eclipse, we believe that these models, in particular the Yule-Simon one, can generalize to other software systems.

We studied data mining from CVS repositories of two large OO projects, Eclipse and Netbeans, focusing on "fixing-issue" commits.

The Workshop on Emerging Trends in Software Metrics aims at bringing together researchers and practitioners to discuss the progress of software metrics. The motivation for this workshop is the low impact that software metrics has on current software development. The goals of this workshop are to critically examine the evidence for the effectiveness of existing metrics and to identify new directions for development of software metrics.

We analyze the process of software development for large, object oriented, open source software systems. Such systems may be described as complex networks when suitable variables are properly identified. In particular we model the system growth through a Yule process which enable us to fit data extracted from freely available repositories. We consider quantities related to relevant properties of the software system itself, like methods names, instance variable names, number of subclasses of each class. As opposite to a plain analysis of a final product, we perform a dynamic analysis of the product evolution, since we look at how system properties change during the development along different releases. The final goal is to detect statistical features that may be related to software dependability.

We present a comprehensive study of an implementation of the Smalltalk object oriented system, one of the first and purest object-oriented programming environment, searching for scaling laws in its properties. We study ten system properties, including the distributions of variable and method names, inheritance hierarchies, class and method sizes, system architecture graph. We systematically found Pareto - or sometimes log-normal - distributions in these properties. This denotes that the programming activity, even when modeled from a statistical perspective, can in no way be simply modeled as a random addition of independent increments with finite variance, but exhibits strong organic dependencies on what has been already developed. We compare our results with similar ones obtained for large Java systems, reported in the literature or computed by ourselves for those properties never studied before, showing that the behavior found is similar in all studied object oriented systems. We show how the Yule process is able to stochastically model the generation of several of the power-laws found, identifying the process parameters and comparing theoretical and empirical tail indexes. Lastly, we discuss how the distributions found are related to existing object-oriented metrics, like Chidamber and Kemerer's, and how they could provide a starting point for measuring the quality of a whole system, versus that of single classes. In fact, the usual evaluation of systems based on mean and standard deviation of metrics can be misleading. It is more interesting to measure differences in the shape and coefficients of the data?s statistical distributions.