|
| |
|
 RSS Feed
Information for
Potential Conference
Exhibitors
|
New Ideas and Emerging Results
The New Ideas and Emerging Results (NIER) track of ICSE '09 provides a
forum for presenting and getting early feedback on novel research
ideas and promising work that has not yet been fully evaluated. This
year NIER received an extremely large number of submissions, and the
competition was especially fierce, so we have a very strong program.
We are excited to announce that the presentation style for NIER will
be completely different from that of the other research tracks.
Authors will present their work in Pecha Kucha style (aka chit-chat):
20 slides for 20 seconds each (6:40 min). All of the
discussion and questions will be held to the end of the presentation.
See our Pecha Kucha page for more details and a sample presentation.
The use of this format will make the presentations short and focused
on their core message, therefore avoiding the much dreaded "death by
Powerpoint" syndrome. Exciting new ideas will be thrown at the
audience at a snappy pace, and the audience will feel the creative
pulse of new SE research in just a few hours. More than a slideshow,
NIER will strive to create new connections, initiate discussions, and
foster research relationships.
All papers will be presented in poster form at the conference
reception on Wednesday evening. Some papers will also be
presented during a conference track, as noted below.
Papers
Back to top
|
A Compositional Approach to Bidirectional Model Transformation (Poster)Link to poster and additional post-conference resources!Contact:
Zhenjiang HuAuthors:
Soichiro Hidaka, National Institute of Informatics, Japan
Zhenjiang Hu, National Institute of Informatics, Japan
Hiroyuki Kato, National Institute of Informatics, Japan
Keisuke Nakano, The University of Electro-Communications, Japan
Abstract: Bidirectional model transformation plays an important role in maintaining consistency between two models, and has many potential applications in software development, including model synchronization, round-trip engineering, software evolution, multiple-view software development, and reverse engineering. However, unclear bidirectional semantics, weak bidirectionalization method, and lack of systematic development framework are known problems that prevent it from being practically used. In this paper, we propose a novel compositional framework for bidirectional model transformation based on the well-known graph querying language UnQL, so that one can develop various useful bidirectional model transformation by combination of a fixed number of primitive bidirectional model transformation. We have implemented a prototyped system, and the experimental results show promise of the new approach.
Back to top
A Sense of Community: A Research Agenda for Software Ecosystems (Poster)Link to poster and additional post-conference resources!Contact:
Slinger JansenAuthors:
Slinger Jansen, Utrecht University, Netherlands
Anthony Finkelstein, University College London, United Kingdom
Sjaak Brinkkemper, Utrecht University, Netherlands
Abstract: Software vendors lack the perspective to develop software within a software ecosystem. The inability to function in a software ecosystem has already led to the demise of many software vendors, leading to loss of competition, intellectual property, and eventually jobs in the software industry. In this paper we present a research agenda on software ecosystems to study both the technical and the business aspects of software engineering in vibrant ecosystems. The results of such research enable software vendors to develop software that is adaptable to new business models and new markets, and to make strategic choices that help a software vendor to thrive in a software ecosystem.
Back to top
A Specification Idiom for Reactive Systems (Poster)Link to poster and additional post-conference resources!Contact:
Nigamanth SridharAuthors:
Nigamanth Sridhar, Cleveland State University, USA
Jason O Hallstrom
Abstract: Interrupt- and event-driven applications constitute an important system class, with connections to desktop computing, embedded systems, and sensor networks. We refer to this set of applications collectively as reactive systems. In this paper, we present a specification idiom for documenting reactive system behavior. Specifically, we discuss an approach to documenting split-phase operations -- operations that involve a request, followed by a deferred out-of-context callback. We derive the idiom by example using interfaces from the TinyOS library, a popular component library for sensor network applications. We conclude with a broader discussion of specification idioms for reactive systems.
Back to top
An Environment for Synchronous Software Development (Poster)Link to poster and additional post-conference resources!Contact:
Lile P. HattoriAuthors:
Lile P. Hattori, University of Lugano, Switzerland
Michele Lanza, University of Lugano, Switzerland
Abstract: Collaboration is essential for the development of complex software systems. When a team of developers is geographically distributed, collaboration aspects, such as awareness, communication and synchronization, are compromised by physical distance. We present our approach to reduce the negative distance effects on collaboration, named mph{synchronous development}. We use a fine-grained change tracking mechanism and notify instantaneously any developer working on the system about changes being performed by other developers. We believe that our approach can augment each developer's knowledge of the project and, consequently, promote interaction and increase productivity.
Back to top
Automated Substring Hole Analysis (Presentation and Poster)Link to poster and additional post-conference resources!Contact:
Orna RazAuthors:
Yoram Adler, IBM, Israel
Eitan Farchi, IBM, Israel
Moshe Klausner, IBM, Israel
Dan Pelleg, IBM, Israel
Orna Raz, IBM, Israel
Moran Shochat, IBM, Israel
Shmuel Ur, IBM, Israel
Aviad Zlotnick, IBM, Israel
Abstract: Code coverage is a common measure for quantitatively assessing the quality of software testing. Code coverage indicates the fraction of code that is actually executed by tests in a test suite. While code coverage has been around since the 60's there has been little work on how to effectively analyze code coverage data measured in system tests. Raw data of this magnitude, containing millions of data records, is often impossible for a human user to comprehend and analyze. Even drill-down capabilities that enable looking at different granularities starting with directories and going through files to lines of source code are not enough. Substring hole analysis is a novel method for viewing the coverage of huge data sets. We have implemented a tool that enables automatic substring hole analysis. We used this tool to analyze coverage data of several large and complex IBM software systems. The tool identified coverage holes that suggested interesting scenarios that were untested.
Back to top
Automatic Evaluation of API Usability using Complexity Metrics and Visualizations (Poster)Contact:
Cleidson R De SouzaAuthors:
Cleidson R De Souza
David L Bentolila
Abstract: APIs are one of the most important concepts in today's modern software engineering. They allow software developers to work independently and minimize the impact caused by changes in the implementation of software services. Despite their importance, currently there are only a few approaches that guide the design of an API. In this paper, we present our approach, and associated tool, that allows an API client (developer) to evaluate the usability of an API and decide whether to use it (release it). In this aspect, our approach goes beyond previous approaches by performing this complexity and usability API analysis automatically.
Back to top
Better Abstractions for Reusable Components & Architectures (Poster)Link to poster and additional post-conference resources!Contact:
Christos KloukinasAuthors:
Christos Kloukinas, City University London, UK
Abstract: Software architecture (SA) is a crucial component of Model Driven Engineering (MDE), since its abstractions ease the communication and reuse of designs and components. However, the existing industry-lead standards and languages (e.g., UML, AADL, SysML) are lacking many needed features for describing architectures. These languages have rudimentary support for connectors, which is a first-class element in the components and connectors (C&C) architectural view and one of the most reusable architectural element. This is unfortunate, since the difficult properties that need to be guaranteed for complex systems are mainly the non-functional properties, which greatly depend on the connectors used in a system. This work reviews the basic abstractions of the C&C view of SA and examines extra architectural elements which can support the detailed, explicit and separate description of behaviour, interaction and control logic.
Back to top
Can Peer Code Reviews be Exploited for Later Information Needs? (Poster)Link to poster and additional post-conference resources!Contact:
Andrew SutherlandAuthors:
Andrew Sutherland, University of Saskatchewan, Canada
Gina Venolia, Microsoft Research, USA
Abstract: Code reviews have proven to be an effective means of improving overall software quality. During the review, there is an exchange of knowledge between the code author and reviewer that concerns the code being reviewed. We performed a study that looked at the code review practices of software product teams at Microsoft. The study results indicated that code reviews are a point at which design rationale is explicitly stated, but that retention and recovery of this information is not well supported in the current environment. The results also indicated that code reviews in collocated development environments such as Microsoft use a mix of face-to-face and electronic communication.
Back to top
Codebook: Social Networking Over Code (Presentation and Poster)Link to poster and additional post-conference resources!Contact:
Robert DeLineAuthors:
Andrew Begel, Microsoft Research, USA
Robert DeLine, Microsoft Research, USA
Abstract: Social networking systems help people maintain connections to their friends, enabling awareness, communication, and collaboration, especially at a distance. In many studies of coordination in software engineering, the work artifacts, e.g. code, bugs, specifications, are themselves the objects that link engineers together. In this paper, we introduce Codebook, a social networking web service in which people can be 'friends' not only with other people but with the work artifacts they share with them. Providing a web interface to the graph of these connections will enable software engineers to keep track of task dependencies, discover and maintain connections to other teams, and understand the history and rationale behind the code that they work on and use.
Back to top
Configuration and Adaptation of Binary Software Components (Poster)Link to poster and additional post-conference resources!Contact:
Stephen KellAuthors:
Stephen Kell, Computer Laboratory, University of Cambridge, United Kingdom
Abstract: Existing black-box adaptation techniques are insufficiently powerful for a large class of real-world tasks. Meanwhile, white-box techniques are language-specific and overly invasive. We argue for the inclusion of special-purpose adaptation features in a configuration language, and outline the benefits of targetting binary representations of software. We introduce Cake, a onfiguration language with adaptation features, and show how its design is being shaped by two case studies.
Back to top
Creating and Evolving Software by Searching, Selecting and Synthesizing Relevant Source Code (Presentation and Poster)Link to poster and additional post-conference resources!Contact:
Denys PoshyvanykAuthors:
Denys Poshyvanyk, The College of William and Mary, USA
Mark Grechanik, Accenture Technology Labs, USA
Abstract: When programmers develop or maintain software, they instinctively sense that there are fragments of code that other developers implemented somewhere, and thus these code fragments could be reused if found. In this paper we propose a novel solution that addresses the fundamental questions of searching, selecting and synthesizing (S3) software based on the analysis of Application Programming Interface (API) calls as units of abstractions that implement high-level concepts (e.g., the API call EncryptData implements the cryptographic concept). The paper outlines the details behind S3, current challenges and evaluation plans.
Back to top
Deployment Automation with BLITZ (Poster)Link to poster and additional post-conference resources!Contact:
Brian DoughertyAuthors:
Brian Dougherty, Vanderbilt University, USA
Jules White, Vanderbilt University, USA
Jaiganesh Balasubramanian, Vanderbilt University, USA
Chris Thompson, Vanderbilt University, USA
Douglas C. Schmidt, Vanderbilt University, USA
Abstract: Minimizing the computing infrastructure (such as processors) in a distributed real-time embedded (DRE) system deployment helps reduce system size and cost. To support software components on the computing infrastructure, the hardware must provide enough processors to ensure that all applications can be scheduled without missing real-time deadlines. In addition to ensuring scheduling constraints, sufficient resources (such as memory) must be available to the software. This paper provides the following contributions to the study of the deployment of software components to hardware in DRE systems: (1) we present an algorithmic deployment technique that minimizes the required number of processors, while adhering to real-time scheduling, resource, and co-location constraints, (2) we show how this technique can be augmented with a harmonic period heuristic to further reduce the number of required processors, and (3) we present empirical data from applying three different deployment algorithms for processor minimization to a flight avionics DRE system.
Back to top
Design Tests: An Approach to Programmatically Check your Code Against Design Rules (Presentation and Poster)Link to poster and additional post-conference resources!Contact:
Joăo BrunetAuthors:
Joăo Brunet, Federal University of Campina Grande, Brazil
Dalton Guerrero, Federal University of Campina Grande, Brazil
Jorge Figueiredo, Federal University of Campina Grande, Brazil
Abstract: Assuring that a program conforms to its specification is a key concern in software quality assurance. Although there is substantial tool support to check whether an implementation complies to its functional requirements, checking whether it conforms to its design remains as an almost completely manual activity. In this paper, we present the concept of design tests, which are test-like programs that automatically check whether an implementation conforms to a specific design rule. Design rules are implemented directly in the target programming language in the form of tests. As a proof of concept, we present DesignWizard, an API developed to support design tests for Java programs as JUnit test cases. We applied design tests in two case studies and observed that our approach is suitable to check conformance automatically. Moreover, we observed that designers and programmers appreciate design tests as an executable documentation that can be easily kept up to date.
Back to top
Detecting Inefficient API Usage (Presentation and Poster)Link to poster and additional post-conference resources!Contact:
David KawrykowAuthors:
David Kawrykow, McGill University, Canada
Martin Robillard, McGill University, Canada
Abstract: Large software projects often rely on third-party libraries, made accessible through Application Programming Interfaces (APIs). We have observed many cases where APIs are used in ways that are not efficient. We developed a technique to automatically detect inefficient API usage in software projects. The main hypothesis underlying the technique is that client code that imitates the behavior of a library method without calling it is likely not to use the library as efficiently as possible. In addition to warning developers of potentially inefficient API usage, our technique also indicates how to improve the use of the API. Application of the technique on Java open-source systems revealed many cases of inefficient API usage, and corresponding recommendations that led to code improvements.
Back to top
From System Specifications to Component Behavioral Models (Presentation and Poster)Link to poster and additional post-conference resources!Contact:
Ivo KrkaAuthors:
Ivo Krka, University of Southern California, USA
George Edwards, University of Southern California, USA
Yuriy Brun, University of Southern California, USA
Nenad Medvidovic, University of Southern California, USA
Abstract: Early system specifications, such as use-case scenarios and properties, are rarely complete. Partial models of system-level behavior, derived from these specifications, have proven useful in early system analysis. We believe that the scope of possible analyses can be enhanced by component-level partial models. In this paper, we outline an algorithm for deriving a component-level Modal Transition System (MTS) from system-level scenario and property specifications. The generated MTSs capture the possible component implementations that (1) necessarily provide the behavior required by the scenarios, (2) restrict behavior forbidden by the properties, and (3) leave the behavior that is neither explicitly required nor forbidden as undefined. We discuss how these generated models can help discover system design flaws, support requirements elicitation, and help select off-the-shelf components.
Back to top
Genetics as a Role Model for Software Variability Management (Presentation and Poster)Link to poster and additional post-conference resources!Contact:
Deepak DhunganaAuthors:
Deepak Dhungana, Johannes Kepler University Linz, Austria
Iris Groher, Johannes Kepler University Linz, Austria
Abstract: Researchers are often inspired by ingenious problem solving strategies of nature. This paper is motivated by the seemingly infinite expressive power of genes (in terms of variability). To bring in the flexibility required for dealing with variable requirements and volatile assumptions in software engineering, we consider genetic variability to be a role model for software variability management. We exemplify how individual species can be seen as natural product lines. By identifying parallels between software product lines and natural product lines, we present initial ideas for software product line engineering research based on the observation of how "products are customized" in nature. We then draw conclusions about the implications for research on software product lines, thereby identifying future research directions.
Back to top
Guided Path Exploration for Regression Test Generation (Poster)Link to poster and additional post-conference resources!Contact:
Kunal TanejaAuthors:
Kunal Taneja, Department of Computer Science, North Carolina State University, USA
Tao Xie, Department of Computer Science, North Carolina State University, USA
Nikolai Tillmann, Microsoft Research, One Microsoft Way, Redmond, WA, USA
Jonathan De Halleux, Microsoft Research, One Microsoft Way, Redmond, WA, USA
Wolfram Schulte, Microsoft Research, One Microsoft Way, Redmond, WA, USA
Abstract: Regression test generation aims at generating a test suite that can detect behavioral differences between the original and the modified versions of a program. Regression test generation can be automated by using Dynamic Symbolic Execution (DSE), a state-of-the-art test generation technique, to generate a test suite achieving high structural coverage. DSE explores paths in the program to achieve a high structural coverage, and exploration of all these paths can often be expensive. However, if our aim is to detect behavioral differences between two versions of a program, we do not need to explore all paths in the program as not all these paths are relevant for detecting behavioral differences. In this paper, we propose a guided path exploration approach that avoids exploring irrelevant paths and gives priority to more promising paths (in terms of detecting behavioral differences) such that behavioral differences are more likely to be detected earlier in path exploration. Preliminary results show that our approach requires about 12.9% fewer runs on average (maximum 25%) to cause the execution of a changed statement and 11.8% fewer runs on average (maximum 31.2%) to cause program-state differences after its execution than the search strategies without guidance.
Back to top
High-level Multicore Programming with XJava (Presentation and Poster)Link to poster and additional post-conference resources!Contact:
Frank OttoAuthors:
Frank Otto, University of Karlsruhe, Germany
Victor Pankratius, University of Karlsruhe, Germany
Walter F. Tichy, University of Karlsruhe, Germany
Abstract: Multicore chips are becoming mainstream, but programming them is difficult because the prevalent thread-based programming model is error-prone and does not scale well. To address this problem, we designed XJava, an extension of Java that permits the direct expression of producer/consumer, pipeline, master/slave, and data parallelism. The central concept of the extension is the task, a parallel activity similar to a filter in Unix. Tasks can be combined with new operators to create arbitrary nestings of parallel activities. Preliminary experience with XJava and its compiler suggests that the extensions lead to code savings and reduce the potential for synchronization defects, while preserving the advantages of object-orientation and type-safety. The proposed extensions provide intuitive "what-you-see-is-what-you-get" parallelism. They also enable other software tools, such as autotuning and accurate static analysis for race detection.
Back to top
How Do System Architectures Affect Software Requirements? (Presentation and Poster)Link to poster and additional post-conference resources!Contact:
Remo FerrariAuthors:
James Miller, The University of Western Ontario, Canada
Remo Ferrari, The University of Western Ontario, Canada
Nazim H. Madhavji, The University of Western Ontario, Canada
Abstract: While much research attention has been paid to transitioning from requirements to software architectures, relatively little attention has been paid to how new requirements are affected by an existing system architecture. Specifically, no scientific studies have been conducted on the "characteristic" differences between the newly elicited requirements gathered in the presence or absence of an existing software architecture. This paper describes emerging results from an exploratory controlled study investigating such requirements characteristics.
Back to top
Improving Bug Tracking Systems (Presentation and Poster)Link to poster and additional post-conference resources!Contact:
Rahul PremrajAuthors:
Thomas Zimmermann, Microsoft Research, USA
Rahul Premraj, Vrije Universiteit, The Netherlands
Jonathan Sillito, University of Calgary, Canada
Silvia Breu, University of Cambridge, UK
Abstract: It is important that information provided in bug reports is relevant and complete in order to help resolve bugs quickly. However, often such information trickles to developers after several iterations of communication between developers and reporters. Poorly designed bug tracking systems are partly to blame for the this exchange of information being stretched over time. Our paper addresses the concerns of bug tracking systems by proposing four broad directions for enhancements. As a proof-of-concept, we also demonstrate a prototype interactive bug tracking system that gathers relevant information from the user and identifies files that need to be fixed to resolve the bug.
Back to top
Improving the Reliability of Mobile Software Systems through Continuous Analysis and Proactive Reconfiguration (Presentation and Poster)Link to poster and additional post-conference resources!Contact:
Sam MalekAuthors:
Sam Malek, Department of Computer Science, George Mason University, USA
Roshanak Roshandel, Department of Computer Science & Software Engineering, Seattle University, USA
David Kilgore, Department of Computer Science, George Mason University, USA
Ibrahim Elhag, Department of Computer Science, George Mason University, USA
Abstract: Most of the current software reliability analysis approaches are geared to traditional desktop software systems, which are relatively stable and static throughout their execution. In this paper, we present a framework targeted at mobile computing domain that addresses the uncertainties associated with the reliability analysis in this setting. Moreover, the framework's architecture-centric reliability estimates are leveraged to improve the runtime reliability of the system through dynamic architectural reconfiguration.
Back to top
Increasing Usability of Preprocessing for Feature Management in Product Lines with Query-based Visualization (Poster)Link to poster and additional post-conference resources!Contact:
Hongyu ZhangAuthors:
Stan Jarzabek, National University of Singapore, Singapore
Hongyu Zhang, Tsinghua University, China
Abstract: Managing features that have fine-grained impact on base programs, is a challenging task in software product line development. Despite well-known problems, preprocessing (e.g., cpp) is often used to handle features by including/excluding variant code to/from a base program. In this paper, we show how some of common preprocessing problems can be alleviated with a query-based visual environment that assists programmers in feature analysis. We describe problems of preprocessing that can be helped by tool like ours, and problems that we believe are inherent in program solutions developed with preprocessors.
Back to top
Integrating Sustainability in Decision-Making Processes: A Modelling Strategy (Presentation and Poster)Link to poster and additional post-conference resources!Contact:
Jordi CabotAuthors:
Jordi Cabot, University of Toronto, Canada
Steve Easterbrook, University of Toronto, Canada
Jennifer Horkoff, University of Toronto, Canada
José-Norberto Mazón, University of Toronto, Canada
Lysanne Lessard, University of Toronto, Canada
Sotirios Liaskos, University of Toronto, Canada
Abstract: One of the most difficult problems that humanity currently faces is the sustainable development of our society, i.e. how to meet the needs of the present without compromising the ability of future generations to meet their own needs. Solving this challenge requires a multidisciplinary approach where researchers with different backgrounds combine their efforts. As software engineers, we can contribute to these efforts by offering existing software requirements modeling and analysis techniques as a means to integrate sustainability requirements in decision-making processes. In this paper, we use a popular language for modeling early requirements as a way to visualize the impact of alternative options on sustainability goals and to analyze the conflicts between sustainability and other problem-specific objectives. We apply this idea to the decision-making activities pertaining to the organization of the ICSE'09 conference itself. We find that the modeling activity significantly facilitates exploration, understanding and comparison of large numbers of possible sustainability measures and allows for better informed and justified decisions.
Back to top
Mining Recurrent Activities: Fourier Analysis of Change Events (Presentation and Poster)Link to poster and additional post-conference resources!Contact:
Abram HindleAuthors:
Abram Hindle, Unversity of Waterloo, Canada
Michael W. Godfrey, Unversity of Waterloo, Canada
Richard C. Holt, Unversity of Waterloo, Canada
Abstract: Within the field of software repository mining, it is common-practice to extract change-events from source control systems and then abstract these events to allow for different analyses. One approach is to apply time-series analysis by aggregating these events into signals. Time-series analysis requires that researchers specify a period of study, usually ``natural'' periods such as days, months, and years are chosen. As yet there has been no research to validate that these assumptions are reasonable. We address this by applying Fourier analysis to discover the ``natural'' periodicities of software development. Fourier analysis can detect and determine the periodicity of repeating events. A Fourier transform represents a signal as a linear combination of sine-waves that suggest how much activity occurs at certain frequencies. If behaviors of different frequencies are mixed into one signal, they can be separated. Thus Fourier transforms can help us identify significant development process sub-signals within software projects.
Back to top
Multi-Dimensional Service Compositions (Presentation and Poster)Link to poster and additional post-conference resources!Contact:
Sam GuineaAuthors:
Luciano Baresi, Politecnico di Milano, Italy
Elisabetta Di Nitto, Politecnico di Milano, Italy
Sam Guinea, Politecnico di Milano, Italy
Schahram Dustdar, Vienna University of Technology, Austria
Abstract: The wide diffusion of a reliable Internet is pushing two key novelties in the conception of modern software applications: the Software as a Service paradigm and the idea of the Internet of Things. Traditionally, services and things have been considered as separated entities, even addressing different needs and application domains. In contrast, we feel that services and things should be integrated and demand for proper design and programming paradigms that ease the task of system builders and enable reuse of components through various systems. Our research idea suggests multi-dimensional service assembly as the right abstraction for taking into account all those cross-cutting issues that are typical of any complex application (e.g., security, user interface, transactionality). In this paper we sketch our ideas, discuss the implications of multi-dimensional service assembly, and draft a research agenda that goes towards the development of a well established theory in this area.
Back to top
Murphy: A Web 2.0 Approach for Proactive Risk Management in Hardware/Software Co-Design (Poster)Link to poster and additional post-conference resources!Contact:
Vladimir Blagojevi?Authors:
Vladimir Blagojevi?, Sirris, Belgium
Wim Codenie, Sirris, Belgium
Jessie Dedecker, Sirris, Belgium
Nicolás González-Deleito, Sirris, Belgium
Jeroen Deleu, Sirris, Belgium
Nick Boucart, Sirris, Belgium
Abstract: Risk management of product failure is perceived as a key strategic challenge by an increasing number of software-intensive product builders, and is especially difficult in the context of hardware/software co-design. This paper argues that traditional plan-driven, workshop based risk management approaches suffer from a number of limitations when applied to this context. Mu?phy, a novel approach for risk management in hardware/software co-design is presented. This approach exploits Web 2.0 social technologies for continuous risk monitoring and harvesting collective risk intelligence.
Back to top
Promoting Evolution by Abstracting Over Implementation Structure (Presentation and Poster)Contact:
David LievensAuthors:
David Lievens, Trinity College Dublin, Ireland
Tim Walsh, Trinity College Dublin, Ireland
Dominik Dahlem, Trinity College Dublin, Ireland
William Harrison, Trinity College Dublin, Ireland
Abstract: In service-oriented architectures, services present to their clients a single interface encompassing all the available functionality. In doing so, they offer an abstraction over the implementation structure of the service, insulating clients from changes to that structure. Abstraction over implementation structure yields benefits in terms of software evolution, and hence can be viewed as a general technique for good software engineering. As such, it should become part of mainstream software development, used outside of the loosely-coupled networks of business applications which services-oriented software addresses. In this paper we give an overview of the design of Continuum, a language-based approach that extends the conventional object-oriented model with facilities to abstract over implementation structure and aims to support the construction of malleable software.
Back to top
SecondWATCH: a Workspace Awareness Tool based on a 3-D Virtual World (Presentation and Poster)Link to poster and additional post-conference resources!Contact:
En YeAuthors:
En Ye, Ohio University, United States
Lev A Neiman, Ohio University, United States
Hiep Q Dinh, Ohio University, United States
Chang Liu, Ohio University, United States
Abstract: Awareness of fellow developers' activities has been widely recognized as essential in facilitating collaboration in a software developing team. However, as reported in several field studies on software development, awareness information on software artifact and coworker is difficult to acquire. To help software developers maintain group awareness and enhance their collaboration, we developed a prototype workspace awareness tool called SecondWATCH based on Second Life, a 3-D online virtual world. SecondWATCH informs developers of real-time and history artifact and co-worker information by monitoring team members' activities on local workspaces, version control repository, and bug tracking system. It extracts, analyzes, and visualizes the information in SL as a common view shared by the whole team using a 3-D city metaphor. We have successfully used SecondWATCH to visualize history information of three open-source Java projects, FreeMind, JEdit, and GUJ, and also using it as our workspace awareness tool when we are developing it.
Back to top
Selective Backtracking of Model Changes (Poster)Link to poster and additional post-conference resources!Contact:
Alexander EgyedAuthors:
Iris Groher, Johannes Kepler University, Austria
Alexander Egyed, Johannes Kepler University, Austria
Abstract: Backtracking is necessary when design alternatives are explored or dead ends are reached. Unfortunately, current approaches support chronological backtracking only (undo or version control), where the designer is forced to undo intermittent changes even if they are not related to what should be backtracked. This work introduces an approach for selective backtracking during software modeling where previously discarded design changes are recovered without having to undo intermittent changes. Selective backtracking is a challenge because during multi-view modeling, we must understand how changes across multiple views are connected - in order to undo them together and thus avoid undesired inconsistencies. Our approach automatically discovers dependencies among design changes and is thus able to guide the designer during selective backtracking.
Back to top
Static Ownership Inference for Reasoning Against Concurrency Errors (Poster)Link to poster and additional post-conference resources!Contact:
Ana MilanovaAuthors:
Ana Milanova, Rensselaer Polytechnic Institute, USA
Yin Liu, Rensselaer Polytechnic Institute, USA
Abstract: We propose a new approach for reasoning about concurrency in object-oriented programs. Central to our approach is static ownership inference analysis --- we conjecture that this analysis has important application in reasoning against concurrency errors.
Back to top
Test Selection for Result Inspection via Mining Predicate Rules (Presentation and Poster)Link to poster and additional post-conference resources!Contact:
Wujie ZhengAuthors:
Wujie Zheng, Computer Science and Engineering, Chinese University of Hong Kong, Hong Kong
Michael Lyu, Computer Science and Engineering, Chinese University of Hong Kong, Hong Kong
Tao Xie, Department of Computer Science, North Carolina State University, United States
Abstract: It is labor-intensive to manually verify the outputs of a large set of tests that are not equipped with test oracles. Test selection helps to reduce this cost by selecting a small subset of tests that are likely to reveal faults. A promising approach is to dynamically mine operational models as potential test oracles and then select tests that violate them. Existing work mines operational models from verified passing tests based on dynamic invariant detection. In this paper, we propose to mine common operational models, which are not universally true, from a set of unverified tests based on mining predicate rules. Specifically, we collect values of simple predicates at runtime and then generate and evaluate predicate rules as potential operational models after running all the tests. We then select tests that violate the mined predicate rules for result inspection. Preliminary results show the effectiveness of our approach.
Back to top
The Comment Density of Open Source Software Code (Poster)Link to poster and additional post-conference resources!Contact:
Dirk RiehleAuthors:
Oliver Arafat, SAP Labs LLC, U.S.A.
Dirk Riehle, SAP Labs LLC, U.S.A.
Abstract: The development processes of open source soft-ware are different from traditional closed source development processes. Still, open source software is frequently of high quality. Therefore, we ask how open source software creates high quality and whether it can maintain this quality for ever larger project sizes. In this paper, we look at one particular quality indicator, the density of comments in open source software code. In a large-scale study of more than 5,000 projects, we find that active open source projects document their source code, and we find that the comment density is independent of team and project size, but not of project age. In future work, we intend to refine these conclusions with more precise measurements and to correlate comment density with project success or failure.
Back to top
The Inference Validity Problem in Legal Discovery (Presentation and Poster)Contact:
R. E. K. StirewaltAuthors:
R. E. K. Stirewalt, Michigan State University, USA
Laura K. Dillon, Michigan State University, USA
Eileen T. Kraemer, University of Georgia, USA
Abstract: This paper introduces the inference validity problem, a software-engineering concern that manifests in and complicates the pre-trial process of discovery in litigation. The problem is related to the requirements validation problem in traditional software engineering, but with stricter constraints on stakeholder communication and potentially severe liability risks on the part of software engineers who are retained as expert witnesses. We propose an approach, based on the use of formal methods and traceability, to enable software engineers to avoid this problem, thereby increasing the quality of written opinions while mitigating the risk of liability.
Back to top
The Marketplace of User Interface Real Estate (Presentation and Poster)Link to poster and additional post-conference resources!Contact:
Luigi TroianoAuthors:
Luigi Troiano, University of Sannio, Italy
Gerardo Canfora, University of Sannio, Italy
Abstract: Financial markets suggest new ways to design, organize and evolve user interfaces. In this paper we present an approach based on marketplace simulations, where UI resources are sold and acquired, attempting to prove that this metaphor can innovate the way we think about UI design and deployment, relying on self-ruling emerging properties of complex systems.
Back to top
Toward Deeply Adaptive Societies of Digital Systems (Poster)Link to poster and additional post-conference resources!Contact:
Antonio CarzanigaAuthors:
Antonio Carzaniga, University of Lugano, Switzerland
Giovanni Denaro, University of Milano-Bicocca, Italy
Mauro Pezzč, University of Lugano, Switzerland
Jacky Estublier, Lab. Log., Sys. et Reseaux Grenoble, France
Alexander Wolf, Imperial College London, UK
Abstract: Modern societies are pervaded by computerized, heterogeneous devices designed for specific purposes, interacting with other devices for several different purposes. This type of open environment is what we call a society of digital systems. In this paper, we outline the characteristics of societies of digital systems, and argue that they call for a new approach to cope with unforeseen interactions, possible incompatibilities, failures, and emergent behaviors. We argue that designers can not assume a closed or homogeneous world, and must instead naturally accommodate dynamic adaptations. Self-adaptability also poses problems, as different adaptation strategies may interfere negatively, leading to unstable behaviors. We propose a method to support the graceful integration of devices and software systems in an open environment. The method uses management information, and is specifically centered on the idea of expressing self-adaptation operations as change sets over the management information base.
Back to top
Towards Safer Composition (Presentation and Poster)Link to poster and additional post-conference resources!Contact:
Andreas ClassenAuthors:
Andreas Classen, PReCISE Research Centre, Faculty of Computer Science, University of Namur, Belgium
Patrick Heymans, PReCISE Research Centre, Faculty of Computer Science, University of Namur, Belgium
Thein Tan Thun, Centre for Research in Computing, The Open University, Walton Hall, Milton Keynes, UK
Bashar Nuseibeh, Centre for Research in Computing, The Open University, Walton Hall, Milton Keynes, UK
Abstract: Determining whether a set of features can be composed, or safe composition, is a hard problem in software product line engineering because the number of feature combinations can be exponential. We argue that synergies between current approaches to safe composition should be exploited and propose a combined approach. At the heart of our proposal is a merge operation that creates a behavioural description for the entire product family from a feature diagram and descriptions of individual feature behaviour. As a result, we intend to verify more efficiently safe composition for an exponential number of feature combinations.
Back to top
Towards a Framework for Law-Compliant Software Requirements (Presentation and Poster)Link to poster and additional post-conference resources!Contact:
Alberto SienaAuthors:
Alberto Siena, FBK-Irst, Italy
John Mylopoulos, University of Trento, Italy
Anna Perini, FBK-Irst, Italy
Angelo Susi, FBK-Irst, Italy
Abstract: During the requirements elicitation phase, analysts have often to take into consideration laws and regulations enacted by different levels of government. The purpose of this paper is twofold. First, a systematic process is outlined which, given a problem and a collection of legal prescriptions, generates a set of requirements that address the problem while complying with the prescriptions. Second, the conceptual framework is outlined, which characterises the process by providing both legal concepts proposed in theoretical studies in the legal domain and concepts from goal-oriented requirements engineering. The issues and challenges of the proposed framework are also evaluated, with regard to expected results.
Back to top
Using Formal Concept Analysis to Construct and Visualise Social Hierarchies of Software Developers (Poster)Link to poster and additional post-conference resources!Contact:
Michel WermelingerAuthors:
Michel Wermelinger, The Open University, UK
Yijun Yu, The Open University, UK
Markus Strohmaier, Graz University of Technology, Austria
Abstract: Interest in the human aspects of software engineering has grown in the past years. For example, based on activity logs in software artefact repositories, researchers are recommending who should fix a bug for a certain component. However, existing work largely follows ad-hoc approaches to relate software artifacts to developers and rarely makes those socio-technical relations explicit in a single structure. In this paper we propose a novel application of formal concept analysis, in order to overcome those deficiencies. As a case study, we construct and visualise different views of the developers who fix and discuss bugs in the Eclipse project.
Back to top
White-Box Approaches for Improved Testing and Analysis of Configurable Software Systems (Poster)Link to poster and additional post-conference resources!Contact:
Marius NitaAuthors:
Marius Nita, University of Washington, USA
David Notkin, University of Washington, USA
Abstract: There is a significant conceptual gap between the source code of a configurable system and the runtime behaviors of its individual configurations. In the source, configurations are woven together into a conceptually unified program. At runtime, however, they are largely treated as independent executables. This gap leads to static analyses that, by acting on the source representing the entire configurable system, yield imprecise results with respect to individual executables. Testing, in contrast, acts on individual executables without leveraging the configurable codebase per se. In this paper, we sketch a research path that seeks to narrow the configuration source-runtime gap, based on the observation that most configurations share significant amounts of source-level structure (hence 'white-box') with other, related, configurations. We seek to identify and exploit this structure to reduce analysis and testing effort by sharing analysis and test results among related configurations.
Back to top
|
|
|
| |
