Search

The CHASE 2008 workshop is concerned with exploring the cooperative and human aspects of software engineering, and providing a forum for discussing high-quality resarch. Accepted papers reflect the diversity of the field of software engineering--ranging from requirements to testing, and from ethnographic research to experiments. Moreover, the background of attendees reflects the diversity of researchers in this domain, ranging from sociology to psychology, from informatics to software engineering. CHASE 2008 met its goals in presenting high-quality research and building community through a mixture of presentations, discussions, posters, and social activities. [ABSTRACT FROM AUTHOR]

The CHASE 2008 workshop is concerned with exploring the cooperative and human aspects of software engineering, and providing a forum for discussing high-quality resarch. Accepted papers reflect the diversity of the field of software engineering--ranging from requirements to testing, and from ethnographic research to experiments. Moreover, the background of attendees reflects the diversity of researchers in this domain, ranging from sociology to psychology, from informatics to software engineering. CHASE 2008 met its goals in presenting high-quality research and building community through a mixture of presentations, discussions, posters, and social activities. [ABSTRACT FROM AUTHOR]

Software designers frequently sketch when they design, particularly during the early phases of exploration of a design problem and its solution. In so doing, they shun formal design tools, the reason being that such tools impose conformity and precision prematurely. Sketching on the other hand is a highly fluid and flexible way of expressing oneself. In this paper, we present Calico, a sketch-based distributed software design tool that supports software designers with a variety of features that improve over the use of just pen-and-paper or a regular whiteboard, and are tailored specifically for software design. Calico is meant to be used on electronic whiteboards or tablets, and provides for rapid creation and manipulation of design content by sets of developers who can collaborate distributedly. [ABSTRACT FROM AUTHOR]

Robotics is a challenging domain which sometimes exhibits a clear need for self-adaptive capabilities, as such functionality offers the potential for robots to account for their unstable and unpredictable deployment domains. This paper focuses on a feasibility study in applying a policy- and architecture- based approach to the development of self-adaptive robotic systems. We describe two case studies in which we construct self-adaptive Robocode and Mindstorms robots, report on our development experiences, and discuss the challenges we encountered. The paper establishes that it is feasible to apply our approach to the robotics domain, contributes a discussion of the architectural issues we encountered, and further evaluates our general-purpose approach. [ABSTRACT FROM AUTHOR]

Software design patterns are widely used in software engineering to enhance productivity and maintainability. However, recent empirical studies revealed the high energy overhead in these patterns. Our vision is to automatically detect and transform design patterns during compilation for better energy efficiency without impacting existing coding practices. In this paper, we propose compiler transformations for two design patterns, Observer and Decorator, and perform an initial evaluation of their energy efficiency. [ABSTRACT FROM AUTHOR]

The use of a studio approach-a hands-on teaching method that emphasizes in-class discussion and activities-is becoming an increasingly accepted method of teaching within software engineering. In such studios, emphasis is placed not only on the artifacts to be produced, but also on the process used to arrive at those artifacts. In this paper, we introduce Calico, a sketch-based collaborative software design tool, and discuss how it supports the delivery of a studio approach to software design education. We particularly describe our experiences with Calico in Software Design I, a course aimed at introducing students to the early, creative phases of software design. Our results show that Calico enabled students to work effectively in teams on their design problems, quickly developing, refining, and evaluating their designs. [ABSTRACT FROM AUTHOR]

When software engineers fix bugs, they may have several options as to how to fix those bugs. Which fix they choose has many implications, both for practitioners and researchers: What is the risk of introducing other bugs during the fix? Is the bug fix in the same code that caused the bug? Is the change fixing the cause or just covering a symptom? In this paper, we investigate alternative fixes to bugs and present an empirical study of how engineers make design choices about how to fix bugs. Based on qualitative interviews with 40 engineers working on a variety of products, data from 6 bug triage meetings, and a survey filled out by 326 engineers, we found a number of factors, many of them non-technical, that influence how bugs are fixed, such as how close to release the software is. We also discuss several implications for research and practice, including ways to make bug prediction and localization more accurate. [ABSTRACT FROM AUTHOR]

Physical inactivity and social isolation are the demons of computer gaming. To combat these and similar problems, my goal is to create attractive game experiences that require play outdoors, encourage multi-player interaction, and incorporate vigorous physical activity inherently. However, play outdoors in large scale naturalistic environments, using only the equipment (e.g., smartphones) people normally carry with them in the world, brings new challenges to game design. Gone is the central server that coordinates all activities and manages evolution of the game state; gone is perfect communication among all players at all times; and gone are specialized sensors and controllers purpose built for games. This paper lays out the motivation for this style of gaming, as well as the challenges we face in engineering them, from requirements capture through design, coding, and validation. Finally, I summarize first steps that have already been taken and hint at future directions. [ABSTRACT FROM AUTHOR]

Recently, a move from traditional, network specific multimedia services to IP-based solutions could be observed. Although many of these applications have similar requirements and address the same issues, individual solutions based on specialized protocols are commonly used. This specialization prohibits the extraction and reuse of common services and hinders the interoperability between services and the integration with external components. A promising approach to overcome these disadvantages is the adoption of the service-oriented paradigm in communication protocols and a modularization into cooperating services. In this paper, we present a generic framework for multimedia applications consisting of a set of reusable Web service components, a modeling language based on finite state automata and a compiler. The results of a BPEL based prototypical implementation of a Voice-over-IP application show that the service oriented approach and the automaton based modeling language can satisfy the above mentioned criteria and ease application development through a higher level of abstraction. On the other hand our benchmarks indicate that current Web service technologies can lead to an insufficient performance, depending on the application scenario. Possible solutions to circumvent these deficiencies are presented at the end of the paper. [ABSTRACT FROM AUTHOR]

Central to the problem frames approach is the distinction of three different descriptions: requirements R, domain assumptions W and specifications S, tied together with the so called frame concern, a proof obligation that has to hold between them if a problem diagram is to be correct: S,W ˫ R. The form this proof should take is not fixed a priori. It might, however, be desirable to automate it in order to allow for an efficient analysis of large diagrams. To make this possible, we follow some earlier suggestions to use the Event Calculus as a suitable formalism for these descriptions. The main contribution of the present paper is a set of consistency rules as well as guidelines for passing from a problem diagram to its formal description. [ABSTRACT FROM AUTHOR]

Legacy systems maintenance involves different decisions, of- ten very complex and sometimes requiring high costs and time. Hence studying and applying the right system modernization technique becomes very important for systems evolution. One of the solutions often adopted to modernize a system is the possibility to migrate it towards a SOA architecture. A lot of works in the literature have been done in this direction, which propose methodologies that provide some kind of migration strategy. In the migration process one of the main tasks is related to system comprehension. We often have to analyze not well documented systems, where it is difficult to identify the components which could become services or to recognize the possible problems we could face during the migration process. Software architecture reconstruction is certainly a relevant key activity, which is used for these purposes. In this paper we explore if design pattern detection could be also useful in the migration process: knowing that some design patterns have been applied in the system could give relevant hints to take decisions during migration. [ABSTRACT FROM AUTHOR]

Ultra-Large-Scale (ULS) Software-Intensive Systems are the new frontier for Software Engineering research and development. The requirements space for ULS encompasses, in particular, the system-of-systems integration challenge. This challenge is characterized by the inherently distributed nature of the constituent systems and the integration solution, the typically interdisciplinary back- ground from which these constituent systems emerge, the need to address a broad spectrum of crosscutting concerns as part of the integration fabric, and a significant amount of agility both in the integration architecture and the development process to accommodate changing requirements over time. In this position paper, we discuss some of the consequences we see emerging from this challenge, propose an architectural blueprint for addressing them, and present future research directions. [ABSTRACT FROM AUTHOR]

Games take many forms, including educational environments. Alice is an example of an engaging environment that teaches object-oriented programming through the development of animations. The AliceVI project sought to extent Alice to visually impaired users. This paper describes how the architectural of Alice impacted the ability to add accessibility features. The result has been to start a system, named BridgIT, from scratch. The technology and proposed architecture is discussed for the new system, which takes the tenets of Alice to a new group of users. [ABSTRACT FROM AUTHOR]

Studio-based teaching is a method commonly used in arts and design that emphasizes a physical "home" for students, problem-based and peer-based learning, and mentoring by academic staff rather than formal lectures. There have been some attempts to transfer studio-based teaching to software engineering education. In many ways, this is natural as software engineering has significant practical elements. However, attempts at software studios have usually ignored experiences and theory from arts and design studio teaching. There is therefore a lack of understanding of what "studio" really means, how well the concepts transfer to software engineering, and how effective studios are in practice. Without a clear definition of "studio", software studios cannot be properly evaluated for their impact on student learning nor can best and worst practices be shared between those who run studios. In this paper, we address this problem head-on by conducting a qualitative analysis of what "studio" really means in both arts and design. We carried out 15 interviews with a range of people with studio experiences and present an analysis and model for evaluation here. Our results suggest that there are many intertwined aspects that define studio education, but it is primarily the people and the culture that make a studio. Digital technology on the other hand can have an adverse effect on studios, unless properly recognised. [ABSTRACT FROM AUTHOR]

Framework evolution may break existing users, which need to be migrated to the new framework version. This is a tedious and error-prone process that benefits from automation. Existing approaches compare two versions of the framework code in order to find changes caused by refactorings. However, other kinds of changes exist, which are relevant for the migration. In this paper, we propose to mine framework usage change rules from already ported instantiations, the latter being applications build on top of the framework, or test cases maintained by the framework developers. Our evaluation shows that our approach finds usage changes not only caused by refactorings, but also by conceptual changes within the framework. Further, it copes well with some issues that plague tools focusing on finding refactorings such as deprecated program elements or multiple changes applied to a single program element. [ABSTRACT FROM AUTHOR]

Dynamically discovering likely program invariants from concrete test executions has emerged as a highly promising software engineering technique. Dynamic invariant inference has the advantage of succinctly summarizing both "expected" program inputs and the subset of program behaviors that is normal under those inputs. In this paper, we introduce a technique that can drastically increase the relevance of inferred invariants, or reduce the size of the test suite required to obtain good invariants. Instead of falsifying invariants produced by pre-set patterns, we determine likely program invariants by combining the concrete execution of actual test cases with a simultaneous symbolic execution of the same tests. The symbolic execution produces abstract conditions over program variables that the concrete tests satisfy during their execution. In this way, we obtain the benefits of dynamic inference tools like Daikon: the inferred invariants correspond to the observed program behaviors. At the same time, however, our inferred invariants are much more suited to the program at hand than Daikon's hardcoded invariant patterns. The symbolic invariants are literally derived from the program text itself, with appropriate value substitutions as dictated by symbolic execution. We implemented our technique in the DySy tool, which utilizes a powerful symbolic execution and simplification engine. The results confirm the benefits of our approach. In Daikon's prime example benchmark, we infer the majority of the interesting Daikon invariants, while eliminating invariants that a human user is likely to consider irrelevant. [ABSTRACT FROM AUTHOR]

Service Oriented Architectures (SOA) evolved as an important architectural concept in software engineering. Although the services of an SOA are loosely coupled and reusable, there have been few considerations of SOA in terms of End User Development (EUD). In this paper we will analyze the potential of SOA for the development of adaptable systems and propose challenges, which have to be solved to reach this goal. Our analysis is based on empirical studies and on requirements for EUD systems, taken from earlier research. If SOAs are extended with structures for in-use modifications (even beyond software technologies), it will be possible to design a new generation of user-adaptable systems. [ABSTRACT FROM AUTHOR]

Large software development projects are complex endeavours that involve numerous participants which can work across several sites and act in various roles. Each participant produces and consumes information relevant for the success of the project. In such settings, an effective and efficient allocation of knowledge is a hard challenge, especially if there is no central authority, which enforces standards for the whole ecosystem. We consider semantic technologies as an important enabler to improve information and knowledge sharing in such scenarios, by helping to exchange and interconnect software engineering knowledge across the web. In this paper, we describe the corresponding vision of a Soft- ware Engineering Semantic Web and the role of intelligent IDEs in order to benefit from and contribute to it. [ABSTRACT FROM AUTHOR]

Self-management is considered as one of the crucial means for software systems to deal with changing demands at runtime. Self-management endows a software systems with the ability to adapt its structure or behavior without human intervention. Two different approaches are put forward for self-management: (1) the system components adapt their structure or behavior to changing requirements and cooperatively realize system adaptation-this approach can be considered as endogenous self-management; (2) the system is adapted through a control loop, i.e. the system is monitored to maintain an explicit representation of the system and based on a set of high-level objectives, the system structure or its behavior is adapted-this approach can be considered as exogenous self-management. In this paper, we introduce a hybrid software architecture that combines both approaches. A multi-agent system architecture allows agents to flexibly adapt their behavior to changes in their context providing cooperative system adaptation. Then, we extend the multi-agent system architecture with a decentralized control loop adding self-healing properties to the system. We use intelligent monitoring of traffic jams as an illustrative case. [ABSTRACT FROM AUTHOR]

State machines and similar state models are heavily used model types in model-driven development. This paper discusses how state models can be compared, more precisely how the difference between two state models should be defined, how it can be eficiently computed, and how it can be displayed. Some of the issues result from an inappropriate design of the UML metamodels and can be solved by switching to a more appropriate metamodel. Another issue are move operations, which raise the question how to optimize a difference. We argue in favour of simple heuristics and the interactive correction of a difference. [ABSTRACT FROM AUTHOR]

E-businesses are increasingly facing the need of porting the provision of their e-services to mobile customers. Evolving requirements, such as reliability, security, scalability, performance and privacy, from fixed to mobile settings, has revealed new and important challenges. This is due to the behavioural constraints that mobility poses, and that were not faced in traditional distributed settings. Examples include: dynamic network topology, changes in location, constrained resource availability, communication protocols heterogeneity, unstable connectivity, and so forth. Industrial practice is demonstrating that such transition is not straightforward and tends to be costly. In particular, the evolution may \break" the software system architecture, thus calling for substantial and expensive changes. Even when the system is (re)built from scratch, it is unclear if and how the state-of the-art in software architectures relate to the requirements and concerns brought forward by mobile software systems. Likewise, there is still a lack of systematic software engineering methods and techniques which can assist in developing and evolving mobile software systems. The goal of this workshop is to address these gaps by strengthening the cross-fertilization of advances from requirements and domain engineering, software architectures, and middleware to systematically develop and evolve architectures supporting mobility. [ABSTRACT FROM AUTHOR]

We have reached a major turning point: microprocessor performance can no longer be improved by increasing clock frequencies; instead, higher performance will have to come from parallelism. As multi/manycore processors with multiple CPUs on a chip become standard and affordable for everyone, software engineers face the challenge of parallelizing applications of all sorts. However, compared to sequential applications, our repertoire of tools and methods for cost-effectively developing reliable, parallel applications is spotty. The mission of this workshop is to bring together researchers and practitioners with diverse backgrounds in order to advance the state of the art in software engineering for multi/manycore parallel applications. This is the first workshop specifically focusing on software engineering challenges of multi/manycore. [ABSTRACT FROM AUTHOR]

Enforcing compliance to API usage protocols is notoriously hard due to possible aliasing of objects through multiple references. In previous work we proposed a sound, modular approach to checking protocol compliance based on typestates that offers a great deal of flexibility in aliasing [1]. In our approach, API protocols are defined based on typestates. Every reference is associated with a permission, and reasoning about permissions is appropriately conservative for the "degree" of possible aliasing admitted by a permission. This paper describes Plural, a tool to automatically enforce typestate-based protocols using permissions in Java. API developers can specify protocols with simple annotations on methods and method parameters. A static flow analysis tracks permissions in code that uses specified APIs and issues warnings for possible protocol violations. [ABSTRACT FROM AUTHOR]

Model-Driven Development (MDD) has made models first-class citizens of the software development process. Thus, a key factor for the successful adoption of MDD techniques is the ability to verify models, which can be achieved by model simulation and testing. This is already a reality for UML models, due mainly to the UML action language. However, at the current time, there are currently no tools available which are fully compliant with the UML action language. This leads to tool-interoperability and extensibility problems. In order to overcome this limitation, this paper presents Populo, a UML model debugger that interprets the UML action language. It is fully compliant with the UML 2.0 standard, and can be customised for executing models that need to extend (i.e. profile) the UML action language. [ABSTRACT FROM AUTHOR]

Software problems originate from real world problems. A software solution must address its real world problem in a satisfactory way. A software engineer must therefore understand the real world problem that their software intends to address. To be able to do this, the software engineer must understand the problem context and how it is to be affected by the proposed software, expressed as the requirements. Without this knowledge the engineer can only hope to chance upon the right solution for the problem. Application of problem-oriented approaches may well be a way of meeting this challenge. [ABSTRACT FROM AUTHOR]

This paper presents a software tool called ModelScope which is a co-debugging platform that, during run-time, allows insight into a model running on various different target systems with different views and diagrams for different aspects of the run-time state. [ABSTRACT FROM AUTHOR]

The CHASE 2008 workshop is concerned with exploring the cooperative and human aspects of software engineering, and providing a forum for discussing high-quality resarch. Accepted papers reflect the diversity of the field of software engineering- ranging from requirements to testing, and from ethnographic research to experiments. Moreover, the background of attendees reflects the diversity of researchers in this domain, ranging from sociology to psychology, from informatics to software engineering. CHASE 2008 met its goals in presenting high-quality research and building community through a mixture of presentations, discussions, posters, and social activities. [ABSTRACT FROM AUTHOR]

The success of software applications that collect and process personal data does not only depend on technical aspects, but is also linked to social compatibility and user acceptance. It requires experts from different disciplines to ensure legal compliance, to foster the users' trust, to enhance the usability of the application and to finally realize the application. Multidisciplinary requirements have to be formulated, interwoven and implemented. We advocate the use of interdisciplinary design patterns that capture the design know-how of typical, recurring features in socially aware applications with particular concern for socio-technical requirements. The proposed patterns address interdisciplinary concerns in a tightly interwoven manner and are intended to facilitate the development of accepted and acceptable applications that in particular deal with sensitive user context information. [ABSTRACT FROM AUTHOR]

Developments in the area of software architecture over the past decade have pushed it to the forefront of a number of critical software engineering activities: modeling, design, analysis, simulation, implementation, deployment, and evolution. Architecture is advocated as an effective conceptual tool for addressing the many challenges of developing large, complex, distributed systems. Largely in parallel to these developments, significant advances have also been made in the domain of mobile computing. Many mobile systems are also large, complex, and distributed, yet a majority of the advances in this domain appear not to have resulted from an explicit software architectural focus. Despite this, architecture appears to offer clear benefits in this domain, as evidenced by some recent approaches. In this talk, I will overview the state-of-the-art in the area of mobile computing, with a specific focus on the role software architecture should and does play in this domain. I will highlight the characteristics of software architectures as well as specific architecture-based approaches that make them particularly suitable to developing mobile systems. I will also highlight several impediments, both real and perceived, to the wholesale adoption of architectural principles in this area. [ABSTRACT FROM AUTHOR]

An abstract of the article "Requirements and Architectures: Two sides of the same coin," by Jon G. Hall is presented.

An abstract of the article "Software Architecture and Mobility: A Perfect Marriage or an Uneasy Alliance?," by Nenad Medvidovic is presented.

Because of the strong coupling of classes and the proliferation of unneeded class members induced by inheritance, the suggestion to use composition and delegation instead has become commonplace. The presentation of a corresponding refactoring in the literature may lead one to believe that such a transformation is a straightforward undertaking. However, closer analysis reveals that this refactoring is neither always possible, nor does it necessarily achieve its desired effect. We have therefore identified the necessary preconditions and realizable postconditions of the refactoring, and built a tool that can perform it completely automatically. By applying this tool to all subclasses of several open-source projects, we have collected evidence of the applicability of the refactoring and of its capability to deliver on its promises. The refactoring builds on constraint graphs originally developed for type inference to check the preconditions and to compute the necessary delegation as well as the subtype relationships that must be maintained. [ABSTRACT FROM AUTHOR]

Because of the strong coupling of classes and the proliferation of unneeded class members induced by inheritance, the suggestion to use composition and delegation instead has become commonplace. The presentation of a corresponding refactoring in the literature may lead one to believe that such a transformation is a straightforward undertaking. However, closer analysis reveals that this refactoring is neither always possible, nor does it necessarily achieve its desired effect. We have therefore identified the necessary preconditions and realizable postconditions of the refactoring, and built a tool that can perform it completely automatically. By applying this tool to all subclasses of several open-source projects, we have collected evidence of the applicability of the refactoring and of its capability to deliver on its promises. The refactoring builds on constraint graphs originally developed for type inference to check the preconditions and to compute the necessary delegation as well as the subtype relationships that must be maintained. [ABSTRACT FROM AUTHOR]

One difficulty in software maintenance is that the relationship between observed program behavior and source code is not always clear. This is true for the maintenance of graphical user interfaces (GUIs), because user interface code can be scattered across the decomposition of applications. A popular approach to develop and maintain GUIs is to use "What you see is what you get" editors. They allow developers to work directly with a graphical design view instead of scattered source elements. Unfortunately GUI editors are limited by their ability to statically reconstruct dynamic collaborations between objects. In our research we investigate the combination of a hybrid dynamic and static approach to allow for round-trip maintenance of GUIs. Dynamic analysis reconstructs object relationships, providing a concrete context in which maintenance can be performed. Static checking guides the reconciliation between the GUI editors' design view and source. We implemented a prototype IDE plugin and evaluate our approach by applying it to five open source projects. [ABSTRACT FROM AUTHOR]

Because of the strong coupling of classes and the proliferation of unneeded class members induced by inheritance, the suggestion to use composition and delegation instead has become commonplace. The presentation of a corresponding refactoring in the literature may lead one to believe that such a transformation is a straightforward undertaking. However, closer analysis reveals that this refactoring is neither always possible, nor does it necessarily achieve its desired effect. We have therefore identified the necessary preconditions and realizable postconditions of the refactoring, and built a tool that can perform it completely automatically. By applying this tool to all subclasses of several open-source projects, we have collected evidence of the applicability of the refactoring and of its capability to deliver on its promises. The refactoring builds on constraint graphs originally developed for type inference to check the preconditions and to compute the necessary delegation as well as the subtype relationships that must be maintained. [ABSTRACT FROM AUTHOR]

When software developers want to understand the reason for a program's behavior, they must translate their questions about the behavior into a series of questions about code, speculating about the causes in the process. The Whyline is a new kind of debugging tool that avoids such speculation by instead enabling developers to select a question about program output from a set of why did and why didn't questions derived from the program's code and execution. The tool then finds one or more possible explanations for the output in question, using a combination of static and dynamic slicing, precise call graphs, and new algorithms for determining potential sources of values and explanations for why a line of code was not reached. Evaluations of the tool on one task showed that novice programmers with the Whyline were twice as fast as expert programmers without it. The tool has the potential to simplify debugging in many software development contexts. [ABSTRACT FROM AUTHOR]

Creating secure and privacy-protecting systems entails the simultaneous coordination of development activities along three different yet mutually influencing dimensions: translating (security and privacy) goals to design choices, analyzing the design for threats, and performing a risk analysis of these threats in light of the goals. These activities are often executed in isolation, and such a disconnect impedes the prioritization of elicited threats, assessment which threats are sufficiently mitigated, and decision-making in terms of which risks can be accepted. In the proposed TMaRA approach, we facilitate the simultaneous consideration of these dimensions by integrating support for threat modeling, risk analysis, and design decisions. Key risk assessment inputs are systematically modeled and threat modeling efforts are fed back into the risk management process. This enables prioritizing threats based on their estimated risk, thereby providing decision support in the mitigation, acceptance, or transferral of risk for the system under design. [ABSTRACT FROM AUTHOR]

Multi-core architectures bring parallel programming into the mainstream. Parallel programming poses many new challenges to the developer, one of which is synchronizing concurrent access to shared memory by multiple threads. Programmers have traditionally used locks for synchronization, but locks have well-known pitfalls: Simplistic coarse-grained locking does not scale well, while more sophisticated fine-grained locking risks introducing deadlocks and data races. Furthermore, scalable libraries written using fine-grained locks cannot be easily composed in a way that retains scalability and avoids deadlock and data races. Transactional memory provides new synchronization constructs that alleviate many of the pitfalls of lock-based synchronization. In this talk, I will present our recent work on transactional memory. I will describe the transactional memory stack we have developed at Intel's programming systems lab. This stack includes new transactional memory language constructs for C and Java, compiler optimizations for these constructs, and high-performance transactional memory runtimes. I will also describe how hardware acceleration can improve the performance of transactional memory. Finally, I will discuss the challenges we face in bringing transactional memory into the mainstream. [ABSTRACT FROM AUTHOR]