Powered by
2013 35th International Conference on Software Engineering (ICSE),
May 18–26, 2013,
San Francisco, CA, USA
ACM Student Research Competition - Posters
Wed, May 22, 15:30 - 16:00, Bayview A
Program Analysis
Supporting Incremental Programming with Ghosts
Oscar Callaú
(University of Chile, Chile)
Best practices in programming typically imply coding using classes and interfaces that are not (fully) defined yet. However, integrated development environments (IDEs) do not support such incremental programming seamlessly. Instead, they get in the way by reporting ineffective error messages. Ignoring these messages altogether prevents the programmer from getting useful feedback regarding actual inconsistencies and type errors. But attending to these error messages repeatedly breaks the programming workflow. In order to smoothly support incremental programming, we propose to extend IDEs with support of undefined entities, called Ghosts. Ghosts are implicitly reified in the IDE through their usages. Programmers can explicitly identify ghosts, get appropriate type feedback, interact with them, and bust them when ready, yielding actual code.
@InProceedings{ICSE13p1428,
author = {Oscar Callaú},
title = {Supporting Incremental Programming with Ghosts},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1428--1430},
doi = {},
year = {2013},
}
Video
Novice Understanding of Program Analysis Tool Notifications
Brittany Johnson
(North Carolina State University, USA)
Program analysis tools are available to make developers' jobs easier by
automating tasks that would otherwise be performed manually or not at all.
To communicate with the developer, these tools use notifications which may be
textual, visual, or a combination of both. Research has shown that these notifications need improvement in two areas:
expressiveness and scalability. In the research described here, I begin an
investigation into the expressiveness and scalability of existing program
analysis tools and potential improvements in expressiveness and scalability in
and across these tools for novice and expert developers. I begin with novices
because I have conducted research with expert developers which found that both
expressiveness and scalability play a part in an expert's ability to effectively
use a subset of program analysis tools.
@InProceedings{ICSE13p1431,
author = {Brittany Johnson},
title = {Novice Understanding of Program Analysis Tool Notifications},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1431--1433},
doi = {},
year = {2013},
}
Energy Aware Self-Adaptation in Mobile Systems
Luca Ardito
(Politecnico di Torino, Italy)
The increasing proliferation of mobile handsets, and the migration of the information access paradigm to mobile platforms, leads researchers to study the energy consumption of this class of devices. The literature still lacks metrics and tools that allow software developers to easily measure and optimize the energy efficiency of their code. Energy efficiency can definitely improve user experience increasing battery life. This paper aims to describe a technique to adapt the execution of a mobile application, based on the actual energy consumption of the device, without using external equipment.
@InProceedings{ICSE13p1434,
author = {Luca Ardito},
title = {Energy Aware Self-Adaptation in Mobile Systems},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1434--1436},
doi = {},
year = {2013},
}
Debugging
ConfDiagnoser: An Automated Configuration Error Diagnosis Tool for Java Software
Sai Zhang
(University of Washington, USA)
This paper presents ConfDiagnoser, an automated configuration error diagnosis tool for Java software. ConfDiagnoser identifies the root cause of a configuration error a single configuration option that can be changed to produce desired behavior. It uses static analysis, dynamic profiling, and statistical analysis to link the undesired behavior to specific configuration options. ConfDiagnoser differs from existing approaches in two key aspects: it does not require users to provide a testing oracle (to check whether the software functions correctly) and thus is fully-automated; and it can diagnose both crashing and non-crashing errors. We demonstrated ConfDiagnosers accuracy and speed on 5 non-crashing configuration errors and 9 crashing configuration errors from 5 configurable software systems.
@InProceedings{ICSE13p1437,
author = {Sai Zhang},
title = {ConfDiagnoser: An Automated Configuration Error Diagnosis Tool for Java Software},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1437--1439},
doi = {},
year = {2013},
}
Reproducing and Debugging Field Failures in House
Wei Jin
(Georgia Tech, USA)
As confirmed by a recent survey among developers of the Apache, Eclipse, and Mozilla projects, failures of the software that occur in the field, after deployment, are difficult to reproduce and investigate in house. To address this problem, we propose an approach for in-house reproducing and debugging failures observed in the field. This approach can synthesize several executions similar to an observed field execution to help reproduce the observed field behaviors, and use these executions, in conjunction with several debugging techniques, to identify causes of the field failure. Our initial results are promising and provide evidence that our approach is able to reproduce failures using limited field execution information and help debugging.
@InProceedings{ICSE13p1440,
author = {Wei Jin},
title = {Reproducing and Debugging Field Failures in House},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1440--1442},
doi = {},
year = {2013},
}
Fault Comprehension for Concurrent Programs
Sangmin Park
(Georgia Tech, USA)
Concurrency bugs are difficult to find because they occur with specific memory-access orderings between threads. Traditional bug-finding techniques for concurrent programs have focused on detecting raw-memory accesses representing the bugs, and they do not identify memory accesses that are responsible for the same bug. To address these limitations, we present an approach that uses memory-access patterns and their suspiciousness scores, which indicate how likely they are to be buggy, and clusters the patterns responsible for the same bug. The evaluation on our prototype shows that our approach is effective in handling multiple concurrency bugs and in clustering patterns for the same bugs, which improves understanding of the bugs.
@InProceedings{ICSE13p1443,
author = {Sangmin Park},
title = {Fault Comprehension for Concurrent Programs},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1443--1445},
doi = {},
year = {2013},
}
Process and Maintenance
A Proposal for the Improvement of Project's Cost Predictability using EVM and Historical Data of Cost
Adler Diniz de Souza
(UFRJ, Brazil)
This paper proposes an extension of the Earned Value Management EVM technique through the integration of historical cost performance data of processes under statistical control as a means to improve the predictability of the cost of projects. The proposed technique was evaluated through a case-study in industry, which evaluated the implementation of the proposed technique in 22 software development projects Hypotheses tests with 95% significance level were performed, and the proposed technique was more accurate and more precise than the traditional technique for calculating the Cost Performance Index - CPI and Estimates at Completion - EAC.
@InProceedings{ICSE13p1446,
author = {Adler Diniz de Souza},
title = {A Proposal for the Improvement of Project's Cost Predictability using EVM and Historical Data of Cost},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1446--1448},
doi = {},
year = {2013},
}
Studying the Effect of Co-change Dispersion on Software Quality
Ehsan Kouroshfar
(George Mason University, USA)
Software change history plays an important role in measuring software quality and predicting defects. Co-change metrics such as number of files changed together has been used as a predictor of bugs. In this study, we further investigate the impact of specific characteristics of co-change dispersion on software quality. Using statistical regression models we show that co-changes that include files from different subsystems result in more bugs than co-changes that include files only from the same subsystem. This can be used to improve bug prediction models based on co-changes.
@InProceedings{ICSE13p1449,
author = {Ehsan Kouroshfar},
title = {Studying the Effect of Co-change Dispersion on Software Quality},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1449--1451},
doi = {},
year = {2013},
}
A Roadmap for Software Maintainability Measurement
Juliana Saraiva
(UFPE, Brazil)
Object-Oriented Programming (OOP) is one of the most used programming paradigms. Thus, researches dedicated in improvement of software quality that adhere to this paradigm are demanded. Complementarily, maintainability is considered a software attribute that plays an important role in its quality level. In this context, Object-Oriented Software Maintainability (OOSM) has been studied through years and several researchers proposed a high number of metrics to measure it. Nevertheless, there is no standardization or a catalogue to summarize all the information about these metrics, helping the researchers to make decision about which metrics can be adopted to perform their experiments in OOSM. Actually, distinct areas in both academic and industrial environment, such as Software Development, Project Management, and Software Research can adopt them to support decision-making processes. Thus, this work researched about the usage of OOSM metrics in academia and industry in order to help researchers in making decision about the metrics suite to be adopted. We found 570 OOSM metrics. Additionally, as a preliminary result we proposed a catalog with 36 metrics that were most used in academic works/experiments, trying to guide researchers with their decision-make about which metrics are more indicated to be adopted in their experiments.
@InProceedings{ICSE13p1452,
author = {Juliana Saraiva},
title = {A Roadmap for Software Maintainability Measurement},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1452--1454},
doi = {},
year = {2013},
}
Models and Requirements
Reasoning with Qualitative Preferences to Develop Optimal Component-Based Systems
Zachary J. Oster
(Iowa State University, USA)
To produce an optimal component-based software system for a given application, it is necessary to consider both the required functionality of the system and its stakeholders' preferences over various non-functional properties. We propose a new modular end-to-end framework for component-based system development that combines formal specification and verification of functional requirements with a novel method for representing and reasoning with stakeholders' qualitative preferences over properties of the system. This framework will facilitate the use of formal verification to ensure system correctness while making it easier to identify truly optimal component-based system designs.
@InProceedings{ICSE13p1455,
author = {Zachary J. Oster},
title = {Reasoning with Qualitative Preferences to Develop Optimal Component-Based Systems},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1455--1457},
doi = {},
year = {2013},
}
From Models to Code and Back: Correct-by-Construction Code from UML and ALF
Federico Ciccozzi
(Mälardalen University, Sweden)
Ever increasing complexity of modern software systems demands new powerful development mechanisms. Model-driven engineering (MDE) can ease the development process through problem abstraction and automated code generation from models. In order for MDE solutions to be trusted, such generation should preserve the system's properties defined at modelling level, both functional and extra-functional, all the way down to the target code. The outcome of our research is an approach that aids the preservation of system's properties in MDE of embedded systems. More specifically, we provide generation of full source code from design models defined using the CHESS-ML, monitoring of selected extra-functional properties at code level, and back-propagation of observed values to design models. The approach is validated against industrial case-studies in the telecommunications applicative domain.
@InProceedings{ICSE13p1458,
author = {Federico Ciccozzi},
title = {From Models to Code and Back: Correct-by-Construction Code from UML and ALF},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1458--1460},
doi = {},
year = {2013},
}
Mitigating the Obsolescence of Specification Models of Service-Based Systems
Romina Torres
(Federico Santa María Technical University, Chile)
Service-based systems (SBS) must be able to adapt their architectural configurations during runtime in order to keep satisfied their specification models. These models are the result of design time derivation of requirements into precise and verifiable specifications by using the knowledge about the current service offerings. Unfortunately, the design time knowledge may be no longer valid during runtime. Then, non- functional constraints may have different numerical meanings at different time even for the same observers. Thus, specification models become obsolete affecting the SBS’ capability of detecting requirement violations during runtime and therefore they trigger reconfigurations when appropriated. In order to mitigate the obsolescence of specification models, we propose to specify and verify them using the computing with words (CWW) methodology. First, non-functional properties (NFPs) of functionally-equivalent services are modeled as linguistic variables, whose domains are concepts or linguistic values instead of precise numbers. Second, architects specify at design time their requirements as linguistic decision models (LDMs) using these concepts. Third, during runtime, the CWW engine monitors the requirements satisfaction by the current chosen architectural configuration. And fourth, each time a global concept drift is detected in the NFPs of the services market, the numerical meanings are updated. Our initial results are encouraging, where our approach mitigates effectively and efficiently the obsolescence of the specification models used by SBS to drive their reconfigurations.
@InProceedings{ICSE13p1461,
author = {Romina Torres},
title = {Mitigating the Obsolescence of Specification Models of Service-Based Systems},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1461--1463},
doi = {},
year = {2013},
}
Decision Theoretic Requirements Prioritization: A Two-Step Approach for Sliding towards Value Realization
Nupul Kukreja
(University of Southern California, USA)
Budget and schedule constraints limit the number of requirements that can be worked on for a software system and is thus necessary to select the most valuable requirements for implementation. However, selecting from a large number of requirements is a decision problem that requires negotiating with multiple stakeholders and satisficing their value propositions. In this paper I present a two-step value-based requirements prioritization approach based on TOPSIS, a decision analysis framework that tightly integrates decision theory with the process of requirements prioritization. In this two-step approach the software system is initially decomposed into high-level Minimal Marketable Features (MMFs) which the business stakeholders prioritize against business goals. Each individual MMF is further decomposed into low-level requirements/features that are primarily prioritized by the technical stakeholders. The priorities of the low-level requirements are influenced by the MMFs they belong to. This approach has been integrated into Winbook, a social-networking influenced collaborative requirements management framework and deployed for use by 10 real-client project teams for the Software Engineering project course at the University of Southern California in Fall 2012. This model allowed the clients and project teams to effectively gauge the importance of each MMF and low-level requirement and perform various sensitivity analyses and take value-informed decisions when selecting requirements for implementation.
@InProceedings{ICSE13p1464,
author = {Nupul Kukreja},
title = {Decision Theoretic Requirements Prioritization: A Two-Step Approach for Sliding towards Value Realization},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1464--1466},
doi = {},
year = {2013},
}
Developers and Users
Changeset Based Developer Communication to Detect Software Failures
Braden Simpson
(University of Victoria, Canada)
As software systems get more complex, the companies developing them consist of larger teams and therefore results in more complex communication artifacts. As these software systems grow, so does the impact of every action to the product. To prevent software failure created by this growth and complexity, companies need to find more efficient and effective ways to communicate. The method used in this paper presents developer communication in the form of social networks of which have properties that can be used to detect software failures.
@InProceedings{ICSE13p1467,
author = {Braden Simpson},
title = {Changeset Based Developer Communication to Detect Software Failures},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1467--1469},
doi = {},
year = {2013},
}
Identifying Failure Inducing Developer Pairs within Developer Networks
Jordan Ell
(University of Victoria, Canada)
Software systems have not only become larger over time, but the amount of technical contributors and dependencies have also increased. With these expansions also comes the increasing risk of introducing a software failure into a pre-existing system. Software failures are a multi-billion dollar problem in the industry today and while integration and other forms of testing are helping to ensure a minimal number of failures, research to understand full impacts of code changes and their social implications is still a major concern. This paper describes how analysis of code changes and the technical relationships they infer can be used to detect pairs of developers whose technical dependencies may induce software failures. These developer pairs may also be used to predict future software failures as well as provide recommendations to contributors to solve these failures caused by source code changes.
@InProceedings{ICSE13p1470,
author = {Jordan Ell},
title = {Identifying Failure Inducing Developer Pairs within Developer Networks},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1470--1472},
doi = {},
year = {2013},
}
On Identifying User Complaints of iOS Apps
Hammad Khalid
(Queen's University, Canada)
In the past few years, the number of smartphone apps has grown at a tremendous rate. To compete in this market, both independent developers and large companies seek to improve the ratings of their apps. Therefore, understanding the user's perspective of mobile apps is extremely important. In this paper, we study the user's perspective of iOS apps by qualitatively analyzing app reviews. In total, we manually tag 6,390 reviews for 20 iOS apps. We find that there are 12 types of user complaints. Functional errors, requests for additional features, and app crashes are examples of the most common complaints. In addition, we find that almost 11% of the studied complaints were reported after a recent update. This highlights the importance of regression testing before updating apps. This study contributes a listing of the most frequent complaints about iOS apps to aid developers and researchers in better understanding the user's perspective of apps.
@InProceedings{ICSE13p1473,
author = {Hammad Khalid},
title = {On Identifying User Complaints of iOS Apps},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1473--1475},
doi = {},
year = {2013},
}
proc time: 0.3