Powered by
2012 34th International Conference on Software Engineering (ICSE),
June 2–9, 2012,
Zurich, Switzerland
ACM Student Research Competition
Thu, Jun 7, 16:00 - 17:30
Timely Detection of Coordination Requirements to Support Collaboration among Software Developers
Kelly Blincoe
(Drexel University, USA)
Work dependencies often exist between the developers of a software project. These dependencies frequently result in a need for coordination between the involved developers. However, developers are not always aware of these Coordination Requirements. Current methods which detect the need to coordinate rely on information which is available only after development work has been completed. This does not enable developers to act on their coordination needs. I have investigated a more timely method to determine Coordination Requirements in a software development team as they emerge.
@InProceedings{ICSE12p1600,
author = {Kelly Blincoe},
title = {Timely Detection of Coordination Requirements to Support Collaboration among Software Developers},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1600--1602},
doi = {},
year = {2012},
}
Improving Failure-Inducing Changes Identification Using Coverage Analysis
Kai Yu
(Beihang University, China)
Delta debugging has been proposed for failure-inducing changes identification. Despite promising results, there are two practical factors that thwart the application of delta debugging: large number of tests and misleading false positives. To address the issues, we present a combination of coverage analysis and delta debugging that automatically isolates failure-inducing changes. Evaluations on twelve real regressions in GNU software demonstrate both the speed gain and effectiveness improvements.
@InProceedings{ICSE12p1603,
author = {Kai Yu},
title = {Improving Failure-Inducing Changes Identification Using Coverage Analysis},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1603--1605},
doi = {},
year = {2012},
}
A Study on Improving Static Analysis Tools: Why Are We Not Using Them?
Brittany Johnson
(North Carolina State University, USA)
Using static analysis tools for automating code inspections can be beneficial for software engineers. Despite the benefits of using static analysis tools, research suggests that these tools are underused. In this research, we propose to investigate why developers are not widely using static analysis tools and how current tools could potentially be improved to increase usage.
@InProceedings{ICSE12p1606,
author = {Brittany Johnson},
title = {A Study on Improving Static Analysis Tools: Why Are We Not Using Them?},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1606--1608},
doi = {},
year = {2012},
}
Winbook: A Social Networking Based Framework for Collaborative Requirements Elicitation and WinWin Negotiations
Nupul Kukreja
(University of Southern California, USA)
Easy-to-use groupware for diverse stakeholder negotiation has been a continuing challenge [7, 8, 9]. USC’s fifth-generation wiki-based win-win negotiation support tool [1] was not as successful in improving over the previous four generations [2] as hoped - it encountered problems with non-technical stakeholder usage. The popularity of Facebook and Gmail ushered in a new era of widely-used social networking capabilities that I have been using to develop and experiment with a new way for collaborative requirements elicitation and management – marrying the way people collaborate on Facebook and organize their emails on Gmail to come up with a social networking-like platform to help achieve better usage of the WinWin negotiation framework [4]. Initial usage results on 14 small projects involving non-technical stakeholders have shown profound implications on the way requirements are negotiated and used, through the system and software definition and development processes. Subsequently, Winbook has also been adopted as a part of a project to bridge requirements and architecting for a major US government organization.
Keywords – collaborative requirements elicitation; WinWin negotiations; social networking
@InProceedings{ICSE12p1609,
author = {Nupul Kukreja},
title = {Winbook: A Social Networking Based Framework for Collaborative Requirements Elicitation and WinWin Negotiations},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1609--1611},
doi = {},
year = {2012},
}
Using Automatic Static Analysis to Identify Technical Debt
Antonio Vetrò
(Politecnico di Torino, Italy; Fraunhofer CESE, USA)
The technical debt (TD) metaphor describes a tradeoff between short-term and long-term goals in software development. Developers, in such situations, accept compromises in one dimension (e.g. maintainability) to meet an urgent demand in another dimension (e.g. delivering a release on time). Since TD produces interests in terms of time spent to correct the code and accomplish quality goals, accumulation of TD in software systems is dangerous because it could lead to more difficult and expensive maintenance.
The research presented in this paper is focused on the usage of automatic static analysis to identify Technical Debt at code level with respect to different quality dimensions.
The methodological approach is that of Empirical Software Engineering and both past and current achieved results are presented, focusing on functionality, efficiency and maintainability.
@InProceedings{ICSE12p1612,
author = {Antonio Vetrò},
title = {Using Automatic Static Analysis to Identify Technical Debt},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1612--1614},
doi = {},
year = {2012},
}
Coupled Evolution of Model-Driven Spreadsheets
Jorge Mendes
(University of Minho, Portugal)
Spreadsheets are increasingly used as programming languages,
in the construction of large and complex
systems. The fact is that spreadsheets, being a highly flexible
framework, lack important programming language features
such as abstraction or encapsulation. This flexibility, however,
comes with a price: spreadsheets are populated with significant
amounts of errors.
One of the approaches that try to overcome this problem
advocates the use of model-driven spreadsheet development: a
spreadsheet model is defined, from which a concrete spreadsheet
is generated. Although this approach has been proved
effective in other contexts, still it needs to accommodate for
future evolution of both the model and its instance, so that
they remain synchronized at all moments.
In this paper, we propose a pair of transformation sets,
one working at the model level and the other at the instance
level, such that each transformation in one set is related to
a transformation in the other set. With our approach, we
ensure model/data compliance while allowing for model and
data evolution.
@InProceedings{ICSE12p1615,
author = {Jorge Mendes},
title = {Coupled Evolution of Model-Driven Spreadsheets},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1615--1617},
doi = {},
year = {2012},
}
Managing Evolution of Software Product Line
Cheng Thao
(University of Wisconsin-Milwaukee, USA)
In software product line engineering, core assets are shared among multiple
products. Core assets and products generally evolve independently. Developers
need to capture evolution in both contexts and to propagate changes in both
directions between the core assets and the products. We propose a version
control system to support product line engineering by supporting the evolution
of product line, product derivation, and change propagation from core assets to
products and vice versa.
@InProceedings{ICSE12p1618,
author = {Cheng Thao},
title = {Managing Evolution of Software Product Line},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1618--1620},
doi = {},
year = {2012},
}
Enabling Dynamic Metamodels through Constraint-Driven Modeling
Andreas Demuth
(JKU Linz, Austria)
Metamodels are commonly used in Model-Driven Engineering to define available model elements and structures.
However, metamodels are likely to change during development for various reasons like requirement changes or evolving domain knowledge.
Updating a metamodel typically leads to non-conformance issues with existing models.
Hence, evolution strategies must be developed.
Additionally, the tool implementation must also be updated to support the evolved metamodel.
We propose the use of metamodel-independent tools with unified modeling concepts for working with all kinds of metamodels and models.
By applying the Constraint-Driven Modeling approach and generating model constraints from metamodels automatically, we solve the described issues and enable dynamic, evolving metamodels.
A prototype implementation has shown the feasibility of the approach and performance tests suggest that it also scales with increasing model sizes.
@InProceedings{ICSE12p1621,
author = {Andreas Demuth},
title = {Enabling Dynamic Metamodels through Constraint-Driven Modeling},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1621--1623},
doi = {},
year = {2012},
}
Assisting End-User Development in Browser-Based Mashup Tools
Soudip Roy Chowdhury
(University of Trento, Italy)
Despite the recent progresses in end-user development and particularly in mashup application development, developing even simple mashups is still non-trivial and requires intimate knowledge about the functionality of web APIs and services, their interfaces, parameter settings, data mappings, and so on. We aim to assist less skilled developers in composing own mashups by interactively recommending composition knowledge in the form of modeling patterns and fostering knowledge reuse. Our prototype system demonstrates our idea of interactive recommendation and automated pattern weaving, which involves recommending relevant composition patterns to the users during development, and once selected, applying automatically the changes as suggested in the selected pattern to the mashup model under development. The experimental evaluation of our prototype implementation demonstrates that even complex composition patterns can be efficiently stored, queried and weaved into the model under development in browser-based mashup tools.
@InProceedings{ICSE12p1624,
author = {Soudip Roy Chowdhury},
title = {Assisting End-User Development in Browser-Based Mashup Tools},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1624--1626},
doi = {},
year = {2012},
}
Hot Clones: Combining Search-Driven Development, Clone Management, and Code Provenance
Niko Schwarz
(University of Bern, Switzerland)
Code duplication is common in current programming-practice: programmers
search for snippets of code, incorporate them into their projects
and then modify them to their needs. In today's practice, no automated scheme is in place to inform both parties
of any distant changes of the code. As code snippets continue to evolve both on the side of the user and on the side of the author, both may wish to benefit from remote bug fixes or refinements --- authors may be interested in the actual usage of their code snippets, and researchers could gather information on clone usage. We propose to maintain a link between software clones across repositories and outline how the links can be created and maintained.
@InProceedings{ICSE12p1627,
author = {Niko Schwarz},
title = {Hot Clones: Combining Search-Driven Development, Clone Management, and Code Provenance},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1627--1628},
doi = {},
year = {2012},
}
Capturing and Exploiting Fine-Grained IDE Interactions
Zhongxian Gu
(UC Davis, USA)
Developers interact with IDEs intensively to maximize productivity. A developer’s interactions with an IDE reflect his thought process and work habits. In this paper, we propose a general framework to capture and exploit all types of IDE interactions. We have two explicit goals for the framework: its systematic interception of comprehensive user interactions, and the ease of use in writing customized
applications. To this end, we developed IDE++ on top of Eclipse IDE. For evaluation, we built applications upon the framework to illustrate 1) the need for capturing comprehensive, finegrained
IDE interactions, and 2) IDE++’s ease of use. We believe that IDE++ is a step toward building next generation, customizable and intelligent IDEs.
@InProceedings{ICSE12p1629,
author = {Zhongxian Gu},
title = {Capturing and Exploiting Fine-Grained IDE Interactions},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1629--1630},
doi = {},
year = {2012},
}
Restructuring Unit Tests with TestSurgeon
Pablo Estefó
(University of Chile, Chile)
The software engineering community has produced great techniques for software maintainability, however, less effort is dedicated to have unit tests modular and extensible.
TestSurgeon is a profiler for unit tests which collects information from tests execution.
It proposes a metric for similarity between tests and provides a visualization to help developers
restructure their unit tests.
@InProceedings{ICSE12p1631,
author = {Pablo Estefó},
title = {Restructuring Unit Tests with TestSurgeon},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1631--1633},
doi = {},
year = {2012},
}
A Requirements-Based Approach for the Design of Adaptive Systems
Vítor E. Silva Souza
(University of Trento, Italy)
Complexity is now one of the major challenges for the IT industry. Systems might become too complex to be managed by humans and, thus, will have to be self-managed: Self-configure themselves for operation, self-protect from attacks, self-heal from errors and self-tune for optimal performance. (Self-)Adaptive systems evaluate their own behavior and change it when the evaluation indicates that it is not accomplishing the software's purpose or when better functionality and performance are possible.
To that end, we need to monitor the behavior of the running system and compare it to an explicit formulation of requirements and domain assumptions. Feedback loops (e.g., the MAPE loop) constitute an architectural solution for this and, as proposed by past research, should be a first class citizen in the design of such systems. We advocate that adaptive systems should be designed this way from as early as Requirements Engineering and that reasoning over requirements is fundamental for run-time adaptation.
We therefore propose an approach for the design of adaptive systems based on requirements and inspired in control theory. Our proposal is goal-oriented and targets software-intensive socio-technical systems, in an attempt to integrate control-loop approaches with decentralized agents inspired approaches. Our final objective is a set of extensions to state-of-the-art goal-oriented modeling languages that allow practitioners to clearly specify the requirements of adaptive systems and a run-time framework that helps developers implement such requirements.
@InProceedings{ICSE12p1634,
author = {Vítor E. Silva Souza},
title = {A Requirements-Based Approach for the Design of Adaptive Systems},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1634--1636},
doi = {},
year = {2012},
}
Petri Nets State Space Analysis in the Cloud
Matteo Camilli
(University of Milan, Italy)
Several techniques for addressing the state space explosion problem in model checking have been studied. One of these is to use distributed memory and computation for storing and exploring the state space of the model of a system. In this report, we present and compare different multi- thread, distributed, and cloud approaches to face the state-space explosion problem. The experiments report shows the convenience (in particular) of cloud approaches.
@InProceedings{ICSE12p1637,
author = {Matteo Camilli},
title = {Petri Nets State Space Analysis in the Cloud},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1637--1639},
doi = {},
year = {2012},
}
Mining Java Class Identifier Naming Conventions
Simon Butler
(Open University, UK)
Classes represent key elements of knowledge in object-orientated source code. Class identifier names describe the knowledge recorded in the class and, much of the time, record some detail of the lineage of the class. We investigate the structure of Java class names identifying common patterns of naming and the way components of class identifier names are repeated in inheritance hierarchies. Detailed knowledge of class identifier name structures can be used to improve the accuracy of concept location tools, to support reverse engineering of domain models and requirements traceability, and to support development teams through class identifier naming recommendation systems.
@InProceedings{ICSE12p1640,
author = {Simon Butler},
title = {Mining Java Class Identifier Naming Conventions},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1640--1642},
doi = {},
year = {2012},
}
Online Sharing and Integration of Results from Mining Software Repositories
Iman Keivanloo
(Concordia University, Canada)
The mining of software repository involves the extraction of both basic and value-added information from existing software repositories. Depending on stakeholders (e.g., researchers, management), these repositories are mined several times for different application purposes. To avoid unnecessary pre-processing steps and improve productivity, sharing, and integration of extracted facts and results are needed. The motivation of this research is to introduce a novel collaborative sharing platform for software datasets that supports on-the-fly inter-datasets integration. We want to facilitate and promote a paradigm shift in the source code analysis domain, similar to the one by Wikipedia in the knowledge-sharing domain. In this paper, we present the SeCold project, which is the first online, publicly available software ecosystem Linked Data dataset. As part of this research, not only theoretical background on how to publish such datasets is provided, but also the actual dataset. SeCold contains about two billion facts, such as source code statements, software licenses, and code clones from over 18.000 software projects. SeCold is also an official member of the Linked Data cloud and one of the eight largest online Linked Data datasets available on the cloud.
@InProceedings{ICSE12p1643,
author = {Iman Keivanloo},
title = {Online Sharing and Integration of Results from Mining Software Repositories},
booktitle = {Proc.\ ICSE},
publisher = {IEEE},
pages = {1643--1645},
doi = {},
year = {2012},
}
proc time: 0.32