ICSE 2013 Workshops
2013 35th International Conference on Software Engineering (ICSE)
Powered by
Conference Publishing Consulting

2013 4th International Workshop on Emerging Trends in Software Metrics (WETSoM), May 21, 2013, San Francisco, CA, USA

WETSoM 2013 – Proceedings

Contents - Abstracts - Authors

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


Title Page

Welcome to WETSoM 2013, the 4th International Workshop on Emerging Trends in Software Metrics. Since its start, WETSoM has attracted a blend of academic and industrial researchers, creating a stimulating atmosphere to discuss the progresses of software metrics. A key motivation for this workshop is the low impact that software metrics still has on current software development, raising the need for empirically evaluating the effectiveness of existing metrics, as well as to identify directions for development of new metrics.


Dynamic Adaptive Search Based Software Engineering Needs Fast Approximate Metrics (Keynote)
Mark Harman, John A. Clark, and Mel Ó Cinnéide
(University College London, UK; University of York, UK; University College Dublin, Ireland)
Search Based Software Engineering (SBSE) uses fitness functions to guide an automated search for solutions to challenging software engineering problems. The fitness function is a form of software metric, so there is a natural and close interrelationship between software metics and SBSE. SBSE can be used as a way to experimentally validate metrics, revealing startling conflicts between metrics that purport to measure the same software attributes. SBSE also requires new forms of surrogate metrics. This topic is less well studied and, therefore, remains an interesting open problem for future work. This paper overviews recent results on SBSE for experimental metric validation and discusses the open problem of fast approximate surrogate metrics for dynamic adaptive SBSE.

Article Search

Full Papers

A Measure to Assess the Behavior of Method Stereotypes in Object-Oriented Software
Peter Andras, Anjan Pakhira, Laura Moreno, and Andrian Marcus
(Newcastle University, UK; Wayne State University, USA)
The implementation of software systems should ideally follow the design intentions of the system. However, this is not always the case the design and implementation of software systems may diverge during software evolution. In this paper we propose a measure based on run time information to assess the consistency between the design and the implementation of OO methods. The measure is based on the analysis of the run-time behavior of methods and considers the frequency of fan-in and fan-out method calls. We analyze this measure with respect to the design intent of methods, reflected by their stereotype. We apply the proposed approach to data from three open source software systems and analyze the behavior of method stereotypes across the systems and within each system. The analysis shows that most methods behave as expected based on their stereotypes and it also detects cases that may need re-engineering attention.

Article Search
A Study of the Community Structure of a Complex Software Network
Giulio Concas, Cristina Monni, Matteo Orrù, and Roberto Tonelli
(University of Cagliari, Italy)
This paper presents a case study of a large software system, Netbeans 6.0, made of independent subsystems, which are analyzed as complex software networks. Starting from the source code we built the associated software graphs, where classes represent graph nodes and inter-class relationships represent graph edges. We computed various metrics for the software systems and found interdependences with various quantities computed by mean of the complex network analysis. In particular we found that the number of communities in which the software networks can be partitioned and their modularity, average path length and mean degree can be related to the amount of bugs detected in the system. This result can be useful to provide indications about the fault proneness of software clusters in terms of quantities related to the associated graph structure.

Article Search
Adoption and Use of New Metrics in a Large Organization: A Case Study
Vibhu Saujanya Sharma and Vikrant Kaulgud
(Accenture Technology Labs, India)
The success of a software development project is linked to the ability of the project team to deliver high quality artifacts within the budget and on schedule. Thus, a holistic and in-process view of various software metrics that help characterize the current health and future trajectory of the project is crucial. However, these metrics need to be at the right level of granularity and be derived objectively from the project environment to be effective and useful. While the metric literature is rich with proposals of specific metrics and their formulation, there are very few studies which discuss how organizations respond to introduction of such metrics and how they are used and adopted. In this paper, we present such a study on a set of metrics embodied by a framework called PIVoT. This study aims at evaluating the impact of PIVoT, a tool for in-process and non-invasive monitoring of project health, and performing a fine-grained analysis of the adoption of metrics and insights this tool embodies. Here, we present and discuss the results of this survey which are based on feedback from 9 project groups. The results indicate that projects leveraged PIVoT and its metrics well and it aided them to take specific actions that helped their projects. Along with identifying the composite metrics which the project teams find most actionable and insightful, the survey shows that in most cases PIVoT helped them showcase their project to upper management.

Article Search
Measuring Software Projects Mayan Style
Siim Karus
(University of Tartu, Estonia)
The progress of contemporary software projects is a subject to several different measurements. These measurements are often subjective and rely on developers’ personal predictions. In addition, software projects are assumed to progress linearly from the beginning to an end. This can be a good approximation of progress in projects with rigid and clearly defined and planned deliverables or deadlines, but is not sufficient for application in community-driven loosely defined projects. In this paper, we are proposing an alternative cyclical view on measuring progress in software development. Based on cyclical time perceptions from other fields of life, we analysed 23 open source software projects to find reoccurring patterns in open source software projects. The empirically derived cyclical and event-based measurements of software projects’ progress does not suffer from the linear approximation issues seen with many other measurements. Accordingly, we believe that the derived progress modelling technique describes community-driven software better as it adapts to environmental changes and lends itself for building estimations on the projects’ future.

Article Search
Metrics for Modularization Assessment of Scala and C# Systems
Basavaraju Muddu, Allahbaksh Asadullah, Vasudev Bhat, and Srinivas Padmanabhuni
(Infosys, India)
Modularization of a software system leads to software that is more understandable and maintainable. Hence it is important to assess the modularization quality of a given system. In this paper, we define metrics for quantifying the level of modularization in Scala and C# systems. We propose metrics for Scala systems, measuring modularization with respect to concepts like referential transparency, functional purity, first order functions etc., which are present in modern functional programming languages. We also propose modularity metrics for C# systems in addition to the Object Oriented metrics that are existing in the literature. We validated our metrics, by applying them to popular open-source Scala Systems - Lift, Play, Akka and C# systems - ProcessHacker and Cosmos.

Article Search
Metrics to Identify Where Object-Oriented Program Comprehension Benefits from the Runtime Structure
Marwan Abi-Antoun, Radu Vanciu, and Nariman Ammar
(Wayne State University, USA)
To evolve object-oriented code, developers often need to understand both the code structure in terms of classes and packages, as well as the runtime structure in terms of abstractions of objects.
Recent empirical studies have shown that for some code modifications tasks, developers do benefit from having access to information about the runtime structure. However, there is no good sense of when object-oriented program comprehension clearly depends on information about the runtime structure.
We propose using metrics to identify cases in object-oriented program comprehension that benefit from information about the runtime structure. The metrics relate properties observed on a statically extracted hierarchical object graph to the type structures declared in the code and highlight key differences between the runtime structure and the code structure.

Article Search
Sextant: A Tool to Specify and Visualize Software Metrics for Java Source-Code
Victor Winter, Carl Reinke, and Jonathan Guerrero
(University of Nebraska at Omaha, USA)
The success of software development efforts typically require guidance derived from a deep understanding of its design space. Well-crafted software metrics can impart invaluable insight into the nature of software and can provide the underpinnings for informed decisions involving design and implementation trade-offs. Leveraging metrics to their full capacity requires (1) the ability to quickly develop custom metrics that are domain-specific and even application specific, and (2) the ability to present metrics-related information in a comprehensible fashion. This paper describes a tool, called Sextant, whose purpose is to achieve the goals stated in the previous paragraph. An overview of Sextant is given followed by two in-depth real-world examples of how the use of metrics can positively impact software development efforts.

Article Search
Software Defect Density Variants: A Proposal
Syed Muhammad Ali Shah, Maurizio Morisio, and Marco Torchiano
(Politecnico di Torino, Italy)
Defect density (DD) is an important measure of software quality, but its usual definition (number of defects found divided by size in lines of code (loc)) is high level and may lead to different interpretations. The objective is to define concrete variants of Defect Density (standard DD, differential DD), analyze their trend over time on a number of projects, and understand which one is more suitable as an indicator of the quality of software projects. In the three projects analyzed the two variants of defect density have distinctly different trends over time; differential DD has a large variability, while standard DD has a steadily increasing trend. The conclusion is that both standard and differential DD are useful variants of DD, the standard DD providing a global quality view of a project (i.e. considering all the history) and the differential DD providing a local quality view (i.e. specific to one version). However, further studies are needed to investigate the usage of these variants.

Article Search
The Inconsistent Measurement of Message Chains
David Bowes, David Randall, and Tracy Hall
(University of Hertfordshire, UK; Brunel University, UK)
Fowler and Beck defined 22 Code Bad Smells. These smells are useful indicators of code that may need to be refactored. A range of tools have been developed that measure smells in Java code. We aim to compare the results of using two smell measurement tools (DECOR which is embedded in the Ptidej tool and Stench Blossom) on the same Java code (ArgoUML). This comparison identifies the code each tool identifies as containing Message Chains. We evaluate the results from these two tools using human judgment on the smells that the code contains. We look in detail at how and why the results differ. Our results show that each tool identified very different code as containing Message Chains. Stench Blossom identified very many more code instances of Message Chains than DECOR. We found three reasons why these discrepancies occurred. First there are significant differences in the definitions of Message Chains used by each tool. Second, the tools use very different measurement strategies. Third, the thresholds embedded in the tools vary. This measurement inconsistency is a problem to practitioners as they may be applying refactoring ineffectively. This inconsistency is also a problem for researchers as it undermines the reliability of making cross study comparisons and prevents mature knowledge the impact of smells being developed.

Article Search
Towards Indicators of Instabilities in Software Product Lines: An Empirical Evaluation of Metrics
Bruno B. P. Cafeo, Francisco Dantas, Elder J. R. Cirilo, and Alessandro Garcia
(PUC-Rio, Brazil; UERN, Brazil)
A Software Product Line (SPL) is a set of software systems (products) that share common functionalities, so-called features. The success of a SPL design is largely dependent on its stability; otherwise, a single implementation change will cause ripple effects in several products. Therefore, there is a growing concern in identifying means to either indicate or predict design instabilities in the SPL source code. However, existing studies up to now rely on conventional metrics as indicators of SPL instability. These conventional metrics, typically used in standalone systems, are not able to capture the properties of SPL features in the source code, which in turn might neglect frequent causes of SPL instabilities. On the other hand, there is a small set of emerging software metrics that take into account specific properties of SPL features. The problem is that there is a lack of empirical validation of the effectiveness of metrics in indicating quality attributes in the context of SPLs. This paper presents an empirical investigation through two set of metrics regarding their power of indicating instabilities in evolving SPLs. A set of conventional metrics was confronted with a set of metrics we instantiated to capture important properties of SPLs. The software evolution history of two SPLs were analysed in our studies. These SPLs are implemented using two different programming techniques and all together they encompass 30 different versions under analysis. Our analysis confirmed that conventional metrics are not good indicators of instabilities in the context of evolving SPLs. The set of employed feature dependency metrics presented a high correlation with instabilities proving its value as indicator of SPL instabilities.

Article Search

Position Papers

A Pragmatic Means for Measuring the Complexity of Source Code Ensembles
Oliver Hummel and Stefan Burger
(KIT, Germany; University of Mannheim, Germany)
Most of the software metrics known and applied today are measured on a per file or even per function basis so that it is difficult to interpret their results for higher-order code ensembles such as components or whole systems. In order to overcome this weakness, we propose the hm-Index as a simple metric to con-dense the dependencies, i.e. the Fan-out, between source units in such code ensembles into a single number. As it is inspi¬red by the h-Index in bibliometrics, it is based on a well-known procedure that already had significant impact in a different field. We expect the hm-Index to become a simple metric for comparing the code complexity of different compo¬nents or systems in software engineering and present promising pre¬liminary results from real-world systems confirming our assumption in this paper.

Article Search
CDI: Cost of Development Index
Vikrant Kaulgud and Vibhu Saujanya Sharma
(Accenture Technology Labs, India)
Managing costs and yet delivering high quality is an essential balancing act in software development projects. Usually, cost management is perceived as a process concern, leading to a disjoint view of team costs and delivered quality. We have proposed a new metric, CDI, that integrates the cost parameter with the quality of the code, to provide managers in a coherent understanding of the trade-off between cost management and quality. The metric is integrated in to an automated tool, making it easy for project teams to adopt the metric in real-life large projects.

Article Search
Towards a Catalog of Object-Oriented Software Maintainability Metrics
Juliana Saraiva, Sérgio Soares, and Fernando Castor
(UFPE, Brazil)
A high number of metrics have been used to measure Object-Oriented Software Maintainability (OOSM). However, there is no comprehensive and useful catalog showing which metrics are more appropriated for adoption in OOSM assessment in both, academic and industrial environments. In a previous work we performed a systematic mapping study to identify maintainability metrics resulting in 570 OOSM metrics found. We classified those metrics in 15 domain categories to help us on the catalog building process. This categorization will be the basement of our inclusion/exclusion criteria when we select which metrics will compose a catalog. Using the proposed categorization we believe that we can select the most relevant and/or popular OOSM metrics. In this position paper we discuss a range of options of OOSM metrics categorization, making the OOSM metrics catalog building process accurate and reliable. Such options include how to evaluate them by the academic and practitioner points of view. We also expect that such discussion during the workshop can help us to identify other options to both propose a more useful catalog and to perform its evaluation.

Article Search

proc time: 0.69