Powered by
Conference Publishing Consulting

5th International Workshop on Emerging Trends in Software Metrics (WETSoM 2014), June 3, 2014, Hyderabad, India

WETSoM 2014 – Proceedings

Contents - Abstracts - Authors

5th International Workshop on Emerging Trends in Software Metrics (WETSoM 2014)

Frontmatter

Title Page

Message from the Chairs
The International Workshop on Emerging Trends in Software Metrics, aims at gathering 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 include critically examining the evidence for the effectiveness of existing metrics and identifying new directions for metrics. Evidence for existing metrics includes how the metrics have been used in practice and studies showing their effectiveness. Identifying new directions includes use of new theories, such as complex network theory, on which to base metrics.

Evolution

What Can Changes Tell about Software Processes?
Barbara Russo and Maximilian Steff
(Free University of Bolzano, Italy)
Code changes propagate. Type, frequency, size of changes typically explain and even predict impact of changes in software products. What can changes tell about software processes? In this study, we propose a novel method to render software processes by graphs of linked commits as carriers of change information. Mining histories in such commit graphs allows to exploit techniques of graph analysis and coloring that can be used to understand activities in software processes. As application of our method, we analysed colored commit graphs to investigate the presence of large architectural changes and their likelihood of occurrence in bug fixing. For this, we introduced a new measure of architectural change based on hashing and a linear-time kernel for bit-labels graphs. We applied our approach to analyse the evolution of change of Eclipse JDT and Spring Framework.
Publisher's Version Article Search
A New Metric for Predicting Software Change using Gene Expression Programming
Ruchika Malhotra and Megha Khanna
(Delhi Technological University, India; Acharya Narendra Dev College, India)
Software metrics help in determining the quality of a software product. They can be used for continuous inspection of a software to assist software developers in improving its quality. We can also use metrics to develop quality models which predict important quality attributes like change proneness. Determination of change prone classes in an Object-Oriented software will help software developers to focus their time and resources on the weak portions of the software. In this paper, we validate the Chidamber and Kemerer metric suite for building an efficient software quality model which predict change prone classes with the help of Gene Expression Programming. The model is developed using an open source software. We further propose a new metric which can be used for identifying change prone classes in the early phases of software development life cycle. The proposed metric is validated on another open source software and the results show that it can be effectively used by the software industry to classify change prone classes. Identification of change prone classes may help in efficient refactoring and rigorous testing of these classes in the forthcoming releases of the software product.
Publisher's Version Article Search
Using Fine-Grained Code Change Metrics to Simulate Software Evolution
Zhongpeng Lin and Jim Whitehead
(University of California at Santa Cruz, USA)
Software evolution simulation can provide support for making informed design decisions. In this research, we explored the distributions of fine-grained code change (FGCC) metrics and used them to build a simple simulator to evolve an existing source code file. The simulator generates synthetic changes to modify the source code analogous to how the code evolves in actual settings. By comparing the simulated evolution with the actual one, we found that the number and types of synthetic changes have no significant difference from those of the actual changes. Furthermore, the simulator is able to produce syntactically correct Java code, allowing us to analyze its static code metrics. The analysis shows that the distributions of method and field counts both have short tails at their left side, making it helpful in estimating the lower bounds for software growth. However, the actual method count falls below the distribution range produced by the simulation runs, indicating more sophisticated simulators are needed.
Publisher's Version Article Search
Structural Evolution of Software: A Social Network Perspective
Naveen Kulkarni, Satya Prateek Bommaraju, and Madhuri Dasa
(Infosys Labs, India)
Structural evolution of an object oriented software is studied using a class collaboration network. The emergence of scale-free property in this network from what could be a random network suggests an inherent process of structural optimization. In the past, software evolution was studied using object oriented metrics. But, these metrics limit our understanding of structural evolution because they are object-class centric and do not take into account the complex relations that span across the structure. As an initial attempt, we apply the social network theories to uncover this hard-to-understand yet essential process of structural evolution. We discuss our findings related to the occurrences of complex relations and influential object-classes that resist the optimization. We do so by observing the revisions chosen at different stages of evolution from open-source software projects.
Publisher's Version Article Search

Software Process

Why Are Industrial Agile Teams Using Metrics and How Do They Use Them?
Eetu Kupiainen, Mika V. Mäntylä, and Juha Itkonen
(Aalto University, Finland)
Agile development methods are increasing in popularity, yet there are limited studies on the reasons and use of metrics in industrial agile development. This paper presents preliminary results from a systematic literature review. Based on our study, metrics and their use are focused to the following areas: Iteration planning, Iteration tracking, Motivating and improving, Identifying process problems, Pre-release quality, Post-release quality and Changes in processes or tools. The findings are mapped against agile principles and it seems that the use of metrics supports the principles with some deviations. Surprisingly, we find little evidence of the use of code metrics. Also, we note that there is a lot of evidence on the use of planning and tracking metrics. Finally, the use of metrics to motivate and enforce process improvements as well as applicable quality metrics can be interesting future research topics.
Publisher's Version Article Search
A Replicated Study on Correlating Agile Team Velocity Measured in Function and Story Points
Hennie Huijgens and Rini van Solingen
(Delft University of Technology, Netherlands; Prowareness, Netherlands)
Since the rapid growth of agile development methods for software engineering, more and more organizations measure the size of iterations, releases, and projects in both function points and story points. In 2011 Santana et al. performed a case study on the relation between function points and story points, from data collected in a Brazilian Government Agency. In this paper we replicate this study, using data collected in a Dutch banking organization. Based on a statistical correlation test we find that a comparison between function points and story points as measured in our repository indicates a moderate negative linear relation, where Santana et al. concluded a strong positive linear relation between both size metrics in their case study. Based on the outcome of our study we conclude that it appears too early to make generic claims on the relation between function points and story points; in fact FSM-theory seems to underpin that such a relationship is a spurious one.
Publisher's Version Article Search
"May the Fork Be with You": Novel Metrics to Analyze Collaboration on GitHub
Marco Biazzini and Benoit Baudry
(INRIA, France)
Multi-repository software projects are becoming more and more popular, thanks to web-based facilities such as Github. Code and process metrics generally assume a single repository must be analyzed, in order to measure the characteristics of a codebase. Thus they are not apt to measure how much relevant information is hosted in multiple repositories contributing to the same codebase. Nor can they feature the characteristics of such a distributed development process. We present a set of novel metrics, based on an original classification of commits, conceived to capture some interesting aspects of a multi-repository development process. We also describe an efficient way to build a data structure that allows to compute these metrics on a set of Git repositories. Interesting outcomes, obtained by applying our metrics on a large sample of projects hosted on Github, show the usefulness of our contribution.
Publisher's Version Article Search
Towards a Catalog Format for Software Metrics
Eric Bouwers, Arie van Deursen, and Joost Visser
(Software Improvement Group, Netherlands; Delft University of Technology, Netherlands)
In the past two decades both the industry and the research community have proposed hundreds of metrics to track software projects, evaluate quality or estimate effort. Unfortunately, it is not always clear which metric works best in a particular context. Even worse, for some metrics there is little evidence whether the metric measures the attribute it was designed to measure. In this paper we propose a catalog format for software metrics as a first step towards a consolidated overview of available software metrics. This format is designed to provide an overview of the status of a metric in a glance, while providing enough information to make an informed decision about the use of the metric. We envision this format to be implemented in a (semantic) wiki to ensure that relationships between metrics can be followed with ease.
Publisher's Version Article Search

Software Quality

Design Test Process in Component-Based Software Engineering: An Analysis of Requirements Scalability
Mariem Haoues, Asma Sellami, and Hanêne Ben-Abdallah
(University of Sfax, Tunisia; King Abdulaziz University, Saudi Arabia)
Producing an acceptable product that will satisfy Functional User Requirements and customer expectations within the quality, time and budget constraints remains a challenge in software development projects. Component-based software development has been widely adopted in software engineering especially when requirements change. However, some challenges remain in this engineering approach when dealing with the scalability of user requirements. Among these challenges, this paper tackles those pertinent to the testing phase. It proposes a design test process in component-based software engineering using functional size measurement and traceability matrix. The proposed test process aims to decreasing the effort required in the testing phase while maintaining the testing efficiency in terms of error detection. It is illustrated through the "Emergency Monitoring System" case study.
Publisher's Version Article Search
In-Depth Measurement and Analysis on Densification Power Law of Software Execution
Yu Qu, Qinghua Zheng, Ting Liu, Jian Li, and Xiaohong Guan
(Xi'an Jiaotong University, China)
Measuring software execution is important for many software engineering tasks. In this paper, Densification Power Law (DPL) of software execution is measured and studied as a feature of growing software complexity. Densification means that during a networked system's evolution, it usually becomes denser and the number of edges and nodes grows with a consistent super linear relation. This feature was discovered and reported in 2005. In this paper, based on a measurement of 15 open-source Java programs, we show that when software systems are modeled as a series of dynamic Call Graphs during their executions, they always obey DPL with very close correlation. Then a comparison between static Call Graph and DPL is presented, showing that DPL's properties cannot be derived statically. An explanation for DPL of software execution is given and verified. We believe the universality of DPL makes it an appropriate metric for software execution process.
Publisher's Version Article Search
Clustering of Defects in Java Software Systems
Giulio Concas, Cristina Monni, Matteo Orrù, and Roberto Tonelli
(University of Cagliari, Italy)
In this paper we present a case study about the clustering of maintenance activities applied on large software systems, from the complex networks perspective. We analyze several releases of two large Open Source Java software systems, using data extracted from Software Configuration Management systems and from Issue Tracking systems (ITS). We find that Java files affected by maintenance activity are likely to be connected with each other, forming interconnected clusters inside the software network associated to the software system. This means that Java files interested by the maintenance activities requested on ITS are likely to be connected each other through dependencies at the source code level. The information carried by the clusters of Java files may be used to improve strategies for large maintenance operations. Since the tendency to form clusters can vary across different systems, such analysis can also be a useful indicator of the impact of defects on source code files in different software systems.
Publisher's Version Article Search
A Security Metric Based on Security Arguments
Benjamin D. Rodes, John C. Knight, and Kimberly S. Wasson
(University of Virginia, USA; Dependable Computing, USA)
Software security metrics that facilitate decision making at the enterprise design and operations levels are a topic of active research and debate. These metrics are desirable to support deployment decisions, upgrade decisions, and so on; however, no single metric or set of metrics is known to provide universally effective and appropriate measurements. Instead, engineers must choose, for each software system, what to measure, how and how much to measure, and must be able to justify the rationale for how these measurements are mapped to stakeholder security goals. An assurance argument for security (i.e., a security argument) provides comprehensive documentation of all evidence and rationales for justifying belief in a security claim about a software system. In this work, we motivate the need for security arguments to facilitate meaningful and comprehensive security metrics, and present a novel framework for assessing security arguments to generate and interpret security metrics.
Publisher's Version Article Search

proc time: 0.13