Daily life presents several barriers for people with visual impairments.Modern computers and smartphones alleviate some of these barriers by providing assistive software that can magnify content, adjust visuals, and read text aloud.However, such software is limited to digital contexts; when it interacts with the physical world, it is often too general to support tasks such as reading a physical book, document, or sign.We hypothesize that modern spatial computing devices enable a new generation of assistive technologies.We introduce Spatial Continuity as a novel method for making physical reality accessible to users with visual impairments.Spatial Continuity allows visually impaired readers to engage with physical experiences by transferring physical objects into a virtual environment.We present a prototype in which a smartphone, functioning as a handheld magnifying glass, streams its camera feed to a head-worn augmented reality device.We evaluated the impact of Spatial Continuity in an informal user study, focusing on its usability and potential as an accessibility enabler.

Open-ended textual exercises facilitate the comprehension of problem-solving skills. Students can learn from their mistakes when teachers provide individual feedback. However, courses with hundreds of students cause a heavy workload for teachers: providing individual feedback is mostly a manual, repetitive, and time-consuming activity.

Continuous software engineering (CSE) is characterized by frequent changes. It is challenging for developers to change software while sustaining its high quality so that the software is always deployable to the users. Rationale management provides an opportunity to support the change process during CSE. However, rationale management is not well integrated into CSE. Even if the rationale is captured, e. g. in the issue tracking system, it is difficult to access in the context of requirements, code, and other software artifacts. In this paper, we present tool support called ConDec to make rationale explicit during CSE and to integrate rationale into a knowledge graph data structure consisting of requirements, code, and other software artifacts. The knowledge graph is visualized in various ways and the developers can access the knowledge views from software artifacts such as requirements and code. They can interact with and filter the knowledge views. In particular, they can use transitive links, for example, to access all the decisions made in the context of a particular requirement or code file. We demonstrate the usefulness of the knowledge views using a case study project.

In the last 30 years, the demands placed on software engineers have increased considerably. This is because the systems they develop increase in complexity, size, and criticality as well. Novel system types like adaptive systems or cyber physical systems and new technologies, like artificial intelligence and virtual reality, change the technology landscape. Professionals creating such systems hence need to stay on the cutting edge to face the challenges of the future.

Many goalkeeper trainees cannot afford a personal human coach. Hence, they could benefit from a virtual coach that provides personalized feedback about the execution of their training exercises. As a first step towards this goal, we developed an algorithm to detect and classify goalkeeper training exercises using a wearable inertial sensor attached to a goalkeeper glove. We collected data from 14 goalkeeper trainees while performing a series of training exercises (e.g., dives, catches, throws). Our approach first detects the exercises using an event detection algorithm based on a high-pass filter, a peak detector, and Dynamic Time Warping to detect and eliminate irrelevant motion instances. Then, it extracts a set of statistical and heuristic features to describe the different exercises and train a machine learning classifier. Our exercise detection approach retrieves 93.8% of the relevant exercises with 90.6% precision and classifies the detected exercises with an accuracy of 96.5%. The exercises recognized by our algorithm can be used to compute further qualitative metrics about individual exercise executions to provide goalkeepers with relevant feedback about their training.

Nowadays, the digitalization and automation of industrial processes is already a standard in many companies. Especially maintenance is an essential process with huge impact in business trying to minimize downtimes of industrial equipment. Maintenance can be separated in several different categories including predictive maintenance which we will focus on. In this paper we present AudioForesight, an audio-based approach for industrial equipment predictive maintenance. The approach is based on a combination of two machine learning techniques: Anomaly detection and classification. The anomaly detection is used to predict abnormal behavior in comparison to the normal behavior observed after setting up the system. After detecting an anomaly, a classifier tries to identify the system error based on predefined failure classes. In the case study, we present an example implementation of our approach for an industrial metrology machine provided by our partner from industry. The case study shows the feasibility of the approach and allowed the prediction of machine failures before they occurred using an autoregression model based on mean-squard-errors from the anomaly detection and classification. We present the results, challenges we uncovered and an outlook of future work.

Continuous software engineering (CSE) evolved as a process for rapid software evolution. Continuous delivery enables developers to frequently retrieve user feedback on the latest software increment. Developers use these insights for requirements validation and verification. Despite the importance of users, reports about user feedback in CSE practice are sparse. We conducted 20 interviews with practitioners from 17 companies that apply CSE. We asked practitioners how they capture and utilize user feedback. In this paper, we detail the practitioners' answers by posing three research questions. To improve continuous user feedback capture and utilization with respect to requirements engineering, we derived five recommendations: First, internal sources should be approached, as they provide a rich source of user feedback; second, existing tool support should be adapted and extended to automate user feedback processing; third, a concept of reference points should be established to relate user feedback to requirements; fourth, the utilization of user feedback for requirements validation should be increased; and last, the interaction with user feedback should be enabled and supported by increasing developer-user communication. We conclude that a continuous user understanding activity can improve requirements engineering by contributing to both the completeness and correctness of requirements.

Continuous software engineering (CSE) is an agile process that supports lightweight, flexible, and rapid software development.Decision-making is crucial for CSE, and developers need to know the decisions made and the related rationale to evolve the software.This knowledge is called decision knowledge.The management of decision knowledge in CSE environments remains unexplored.The agile manifesto suggests to value working software over comprehensive documentation as well as individuals and interactions over processes and tools.What does this mean for the documentation, exploitation, and sharing of decision knowledge?We report on results from an interview study with 24 practitioners from 17 companies on how decision knowledge is managed during CSE.The practitioners mainly capture decision knowledge in an informal way, for example, in natural language discussions.Wiki and issue tracking systems represent the preferred medium to preserve decision knowledge.Mentioned benefits are an improved decision-making process, accountability, knowledge sharing, and reuse.However, the exploitation of the captured decision knowledge remains partly unclear.

Despite more than three decades of research in augmented reality and shown positive effect of AR in educational settings, we still don't witness spread of this technology in the schools. Complex technology and limited educational content are among the reasons for this absence. Authoring systems can play a positive role in introduction of AR into the school settings. In this paper we introduce ISAR, a domain-independent authoring system for a camera-projector based interactive tabletop. ISAR allows teachers to create learning content and define interactions for the tabletop themselves, without the need for programming, and hence reduces the entrance barrier of educational practitioners for experimenting with augmented reality and tangible interactions.

Abstract Continuous software engineering (CSE) emerged as a process that is increasingly applied by practitioners. However, different perceptions impede its adoption in industry. Furthermore, opportunities through utilizing usage and decision knowledge remain unexploited. We conducted a semi‐structured interview study with 24 practitioners from 17 companies to study how practitioners apply CSE during software evolution and how usage and decision knowledge can support CSE. Regarding the application of CSE, we identified five perspectives on CSE with tool‐ and methodology‐driven definitions most prevalent. Automated tests, involved users, and shared rulesets are perceived as most relevant for CSE. Practitioners report more positive than negative experiences; however, more than half of their responses were neutral. Practitioners' future plans for CSE focus on enhancement, expansion, and on‐demand adaption. Regarding the integration of usage and decision knowledge into CSE, practitioners perceive accountability and traceability as major benefits, while raising concerns about its feasibility and user groups. As short‐term extensions, practitioners expect improvements regarding automation and role aspects, while long‐term additions to integration and experimentation capabilities are demanded. We conclude that CSE remains partially difficult to capture for practitioners, while their attitude toward integrating usage and decision knowledge into CSE is positive.

In order to keep up with fast-changing markets and customer needs, many organizations are adopting a project-based model in which teams are assembled on a per-project basis. While there is a growing body of academic work on factors that should be taken into account for a team to perform well, there is a lack of insight into the current practices of team composition in industry. In this publication, we present the first results of an interview study with practitioners from project-based organizations with a software engineering focus. We conducted semi-structured interviews with 8 practitioners to understand the processes for team composition as well as team factors they find important. The results show that practitioners rely on informal networks and person-to-person communication much more strongly than expected, even in organizations with a large pool of employees. Motivation and level of challenge of the project along with team ownership were among the most frequently named team factors. From our observations, we derive implications and directions for future work for researchers, tool vendors and practitioners.

Patients of an Anterior Cruciate Ligament (ACL) injury engage in a set of rehabilitation exercises to recover mobility and strength of their injured leg. We developed a smart bandage and user interface that provides live feedback to patients while exercising and computes a series of performance metrics used by orthopedists for assessment of the patient's recovery. The bandage uses smart textile components such as elastic conductive threads and snap buttons. We discuss how the smart textile components contribute to desirable properties of the bandage, such as robustness, washability and user comfort. Furthermore, we present a technique for calibrating the motion sensors on the bandage which is suitable for patients of ACL with limited mobility. Finally, we present the results of a controlled experiment with 10 patients with the goal to assess the accuracy of the bandage's measurements.

Composing project teams of students for software engineering courses is a challenging problem for instructors: they need to take into account objectives and constraints such as project motivation, balance of experience in the teams, team size and cultural criteria. In this paper, we present TEASE, a system that algorithmically supports instructors in creating project teams. TEASE proposes possible assignments and enables the instructor to manually adapt them based on their experience. The system also visualizes the effects of these changes on the previously defined objectives and constraints. Our evaluation in a multi-project capstone course shows that TEASE helps instructors create teams with better mean project priority while enabling them to satisfy constraints that were broken during manual assignment. Moreover, TEASE reduced the time needed for team composition by over 60%, making especially the beginning of large project courses more manageable for instructors.

In modern showjumping and cross-country riding, the success of the horse-rider-pair is measured by the ability to finish a given course of obstacles without penalties within a given time. A horse performs a successful (penalty-free) jump, if no element of the fence falls during the jump. The success of each jump is determined by the correct take-off point of the horse in front of the fence and the amount of strides a horse does between fences. This paper proposes a solution for tracking gaits and jumps using a smartphone attached to the horse's saddle. We propose an event detection algorithm based on Discrete Wavelet Transform and a peak detection to detect jumps and canter strides between fences. We segment the signal to find gait and jump sections, evaluate statistical and heuristic features and classify the segments using different machine learning algorithms. We show that horse jumps and canter strides are detected with a precision of 94.6% and 89.8% recall. All gaits and jumps are further classified with an accuracy of up to 95.4% and a Kappa coefficient (KC) of up to 93%.

Continuous software engineering (CSE) emerged as a process that is increasingly applied by practitioners. However, different perceptions of CSE among practitioners might impede its adoption in industry. We aim to support practitioners by giving a comprehensive overview of current CSE practices. Our observations provide guidance for practice on how to establish, assess, and advance CSE in their company. We conducted an interview study with 24 practitioners from 17 companies during 20 interviews. Following a semi-structured approach, we asked for their definition of CSE, most relevant elements for CSE, their experiences, and plans for further additions to their CSE process. From the practitioners' statements, we identified five perspectives on CSE and found tool- and methodology-driven definitions most prevalent. Automated tests, involved users, and a shared ruleset are perceived as most relevant for CSE. Practitioners' positive experiences with CSE are more frequent than negative ones; however, more than half of the responses were neutral. Practitioners' future plans focus on enhancement, expansion, and on-demand adaption of current practices. We conclude that CSE remains partially difficult to capture for practitioners. Therefore, we structure CSE in a model, the Eye of CSE.

Devices used in fog and edge computing are heterogeneous and distributed. These computing environments are unpredictable and their applications are becoming more complex. This leads to challenges regarding deployment and management of fog and edge applications. It is important to ensure that quality of service, availability, reliability and real-time characteristics are guaranteed during deployment to take advantage of fog computing. In this paper, we present Fogernetes, a fog computing platform that enables management and deployment of fog applications with specific requirements on heterogeneous devices with different capabilities. Fogernetes allows matching the requirements of application components with device capabilities by using a labeling system. Based on a case study, we evaluate and test Fogernetes and examine its practical applicability for the deployment and management of fog computing applications. Fodeo serves as an example application. Fodeo analyzes video streams from multiple cameras and optimizes the video delivery. Fogernetes enables the deployment of Fodeo components on appropriate devices by matching requirements and capabilities.

Developers make various decisions during software development. The rationale behind these decisions is of great importance during software evolution of long living software systems. However, current practices for documenting rationale often fall short and rationale remains hidden in the heads of developers or embedded in development artifacts. Further challenges are faced for capturing rationale in OSS projects; in which developers are geographically distributed and rely mostly on written communication channels to support and coordinate their activities. In this paper, we present an empirical study to understand how OSS developers discuss rationale in IRC channels and explore the possibility of automatic extraction of rationale elements by analyzing IRC messages of development teams. To achieve this, we manually analyzed 7,500 messages of three large OSS projects and identified all fine-grained elements of rationale. We evaluated various machine learning algorithms for automatically detecting and classifying rationale in IRC messages. Our results show that 1) rationale is discussed on average in 25% of IRC messages, 2) code committers contributed on average 54% of the discussed rationale, and 3) machine learning algorithms can detect rationale with 0.76 precision and 0.79 recall, and classify messages into finer-grained rationale elements with an average of 0.45 precision and 0.43 recall.

Modern capstone courses use agile methods to deliver and demonstrate software early in the project. However, a simple demonstration of functional and static aspects does not provide real-world software usage context, although this is integral to understand software requirements. Software engineering involves capabilities such as creativity, imagination, and interaction, which are typically not emphasized in software engineering courses. A more engaging, dynamic way of presenting software prototypes is needed to demonstrate the context in which the software is used. We combine agile methods, scenario-based design, and theatrical aspects into software theater, an approach to present visionary scenarios using techniques borrowed from theater and film, including props and humor. We describe the software theater workflow, provide examples, and explain patterns to demonstrate its potential. We illustrate two large case studies in which we teach students with varying levels of experience to apply software theater: a capstone course involving industrial customers with 100 students and an interactive lecture-based course with 400 students. We empirically evaluated the use of software theater in both courses. Our evaluations show that students can understand and apply software theater within one semester and that this technique increases their motivation to prepare demonstrations even early in the project. Software theater is more creative, memorable, dynamic, and engaging than normal demonstration techniques and brings fun into education.

Developers' chat messages are a rich source of rationale behind development decisions. Rationale comprises valuable knowledge during software evolution for understanding and maintaining the software system. However, developers resist explicit methods for rationale capturing in practice, due to their intrusiveness and cognitive overhead. Aim: Our primary goal is to help developers capture rationale in chat messages with low effort. Further, we seek to encourage the collaborative capturing of rationale in development teams. Method: In this paper, we present REACT, a lightweight approach for annotating chat messages that contain rationale. To evaluate the feasibility of REACT, we conducted two studies. In the first study, we evaluated the approach with eleven development teams during a short-term design task. In the second study, we evaluated the approach with one development team over a duration of two months. In addition, we distributed a questionnaire to both studies' participants. Results: Our results show that REACT is easily learned and used by developers. Furthermore, it encourages the collaborative capturing of rationale. Remarkably, the majority of participants do not perceive privacy as a barrier when capturing rationale from their informal communication. Conclusions: REACT is a first step towards enhancing rationale capturing in developers' chat messages.

Chat messages of development teams play an increasinglysignificant role in software development, having replacedemails in some cases. Chat messages contain informationabout discussed issues, considered alternatives and argumentationleading to the decisions made during software development. These elements, defined as rationale, are invaluable duringsoftware evolution for documenting and reusing developmentknowledge. Rationale is also essential for coping with changesand for effective maintenance of the software system. However, exploiting the rationale hidden in the chat messages is challengingdue to the high volume of unstructured messages covering a widerange of topics. This work presents the results of an exploratorystudy examining the frequency of rationale in chat messages, the completeness of the available rationale and the potential ofautomatic techniques for rationale extraction. For this purpose, we apply content analysis and machine learning techniques onmore than 8,700 chat messages from three software developmentprojects. Our results show that chat messages are a rich source ofrationale and that machine learning is a promising technique fordetecting rationale and identifying different rationale elements.

Learning to apply computer science requires practical experience and cannot only be taught in theory. Interactive learning is a new approach: educators teach small chunks of content in short cycles of theory, example, exercise, solution and feedback. It is based on active, computer-based and experiential learning and focuses on immediate feedback to improve the learning experience. It allows students to reflect about the content incrementally. It includes hands-on activities, guidance by the instructor and increases students' motivation and engagement. This workshop describes experiences of multiple interactive learning courses for large classes, including exercises for (1) multiple choice quizzes, (2) interactive tutorials, (3) interactive programming exercises, (4) interactive modeling, and (5) team activities. Based on our experience, we present multiple case studies and concrete examples of interactive exercises. While the assessment of many exercises can be (semi-)automated, teaching assistants in the classroom manually assess other exercises. We show how educators can integrate these exercises into large classes without significantly increasing their effort. Participants should bring a laptop to this workshop.

Continuous software engineering (CSE) includes activities to continuously evolve software artifacts. Along with these activities, developers employ knowledge such as usage and decision knowledge. Usage knowledge helps developers to understand how users apply software, while decision knowledge comprises all decisions taken during CSE and their rationale. However, due to the frequency, extent, and complexity of knowledge in CSE environments, accessing and processing knowledge is challenging for developers. We propose a dashboard for developers that visualizes knowledge from various sources. This enables developers to follow, reflect, interact, and react on knowledge in CSE environments. We introduce springboards that serve as knowledge selectors while the selected extract of knowledge is visualized in widgets. Widgets allow developers to gain insight into knowledge. We suggest three widget classes: spot, compare, and range. We discuss dashboard extensions such as interaction triggers to add, modify, or combine knowledge. We plan to implement the dashboard and evaluate it with teams during software development projects in an industrial setting.

Smart buildings have become an essential part of our daily life. Due to the increased availability of addressable fixtures and controls, the operation of building components has become complex for occupants, especially when multimodal controls are involved. Thus, occupants are confronted with the need to manage these controls in a user-friendly way. We propose the MIBO IDE, an integrated development environment for defining, connecting, and managing multimodal controls designed with end-users in mind. The MIBO IDE provides a convenient way for occupants to create and customize multimodal interaction models while taking the occupants' preferences, culture, and potential physical limitations into account. The MIBO IDE allows occupants to apply and utilize various components such as the MIBO Editor. This core component can be used to define interaction models visually using the drag-and-drop metaphor and therefore without requiring programming skills. In addition, the MIBO IDE provides components for debugging and compiling interaction models as well as detecting conflicts among them.

Games development brings fun into the software engineering curriculum, but it is a practical activity that educators cannot teach in traditional lecture-based environments. Including pedagogical aspects of problem-based, cooperative, blended and experiential learning is necessary to achieve a high learning experience.

Globalization has long since found its way into software engineering. Many companies transfer part of their development activities to distributed countries in order to ensure their global competitiveness, gain access to local markets and react to the prevailing lack of specialized workforce. The global distribution of project teams introduces new challenges: Geographic separation, different time zones, remote communications, and culture and language barriers make the collaboration between team members more difficult.

Context: Users can have conflicting opinions and different experiences when using software and user reviews serve as a channel in which users can document their opinions and experiences. To develop and evolve software that is usable and relevant for a diverse group of users, different opinions and experiences need to be taken into account. Goal: In this paper we present DIVERSE, a feature and sentiment centric retrieval approach which automatically provides developers with a diverse sample of user reviews that is representative of the different opinions and experiences mentioned in the whole set of reviews. Results: We evaluated the diversity retrieval performance of our approach on reviews from seven apps from two different app stores. We compared the reviews retrieved by DIVERSE with a feature-based retrieval approach and found that on average DIVERSE outperforms the baseline approach. Additionally, a controlled experiment revealed that DIVERSE can help develop- ers save time when analyzing user reviews and was considered useful for detecting conflicting opinions and software evolution. Conclusions: DIVERSE can therefore help developers collect a comprehensive set of reviews and aid in the detection of conflicting opinions.

App marketplaces are distribution platforms for mobile applications that serve as a communication channel between users and developers. These platforms allow users to write reviews about downloaded apps. Recent studies found that such reviews include information that is useful for software evolution. However, the manual analysis of a large amount of user reviews is a tedious and time consuming task. In this work we propose a taxonomy for classifying app reviews into categories relevant for software evolution. Additionally, we describe an experiment that investigates the performance of individual machine learning algorithms and its ensembles for automatically classifying the app reviews. We evaluated the performance of the machine learning techniques on 4550 reviews that were systematically labeled using content analysis methods. Overall, the ensembles had a better performance than the individual classifiers, with an average precision of 0.74 and 0.59 recall.

Software developers make various decisions when implementing software.For instance, they decide on how to implement an algorithm most efficiently or in which way to process user input.When code is revisited during maintenance, the underlying decisions need to be understood and possibly adjusted to the current situation.Common documentation approaches like JavaDoc neither cover knowledge related to decisions explicitly, nor are they integrated closely with knowledge management.In consequence, decision knowledge is rarely documented and therefore inaccessible, especially when developers have left the team.So, effective maintenance is hindered.We have developed an annotation model for decision knowledge and integrated it with the knowledge management tool UNICASE.The approach enables developers to document decisions within code without tool switches to lower their documentation effort.Afterwards, maintainers can exploit the embedded decision knowledge and follow links to external knowledge.This paper presents the approach and evaluation results of a first case study, which indicate its practicability.

Software development has to cope with uncertainties and changing requirements that constantly arise in the development process. Agile methods address this challenge by adopting an incremental development process and delivering working software frequently. However, current validation techniques used in sprint reviews are not sufficient for emerging applications based on ubiquitous technologies. To fill this gap, we propose a new way of demonstration called Software Theater. Based on ideas from theater plays, it aims at presenting scenario-based demonstration in a theatrical way to highlight new features, new user experience and new technical architecture in an integrated performance. We have used Software Theater in more than twenty projects and the result is overall positive.

Bug reports submitted by users and crash reports collected by crash reporting tools often lack information about reproduction steps, i.e. the steps necessary to reproduce a failure. Hence, developers have difficulties to reproduce field failures and might not be able to fix all reported bugs. We present an approach to automatically extract failure reproduction steps from user interaction traces. We capture interactions between a user and a WIMP GUI using a capture/replay tool. Then, we extract the minimal, failure-inducing subsequence of captured interaction traces. We use three algorithms to perform this extraction: Delta Debugging, Sequential Pattern Mining, and a combination of both. Delta Debugging automatically replays subsequences of an interaction trace to identify the minimal, failure-inducing subsequence. Sequential Pattern Mining identifies the common subsequence in interaction traces inducing the same failure. We evaluated our approach in a case study. We injected four bugs to the code of a mail client application, collected interaction traces of five participants trying to find these bugs, and applied the extraction algorithms. Delta Debugging extracted the minimal, failure-inducing interaction subsequence in 90% of all cases. Sequential Pattern Mining produced failure-inducing interaction sequences in 75% of all cases and removed on average 93% of unnecessary interactions, potentially enabling manual analysis by developers. Both algorithms complement each other because they are applicable in different contexts and can be combined to improve performance.

There is an acknowledged need for teaching realistic software development in project courses. The design space for such courses is wide, ranging from single-semester to two-semester courses, from single-client to multicustomer courses, from local to globally distributed courses, and from toy projects to projects with real clients. The challenge for a nontrivial project course is how to make the project complex enough to enrich students’ software engineering experience, yet realistic enough to have a teaching environment that does not unduly burden students or the instructor. We describe a methodology for project courses that is realizable for instructors, improves students’ skills, and leads to viable results for industry partners. In particular, recent advances in release management and collaboration workflows reduce the effort of students and instructors during delivery and increase the quality of the deliverables. To enable release and feedback management, we introduce Rugby, an agile process model based on Scrum that allows reacting to changing requirements. To improve early communication, we use Tornado, a scenario-based design approach that emphasizes the use of informal models for the interaction between clients and students. The combination of Rugby and Tornado allows students to deal with changing requirements, produce multiple releases, and obtain client feedback through the duration of the course. We describe our experience with more than 300 students working on 40 projects with external clients over a 4-year period. In the latest instance of our course, the students have produced more than 7000 builds with 600 releases for eleven clients. In an evaluation of the courses, we found that the introduction of Rugby and Tornado significantly increased students’ technical skills, especially with respect to software engineering, usability engineering, and configuration management, as well as their nontechnical skills such as communication with the client, teamwork, presentation, and demo management. Finally, we discuss how other instructors can adapt the course concept.

Companies transfer part of their development activities to distributed countries in order to ensure their global competitiveness, gain access to local markets and react to the prevailing lack of specialized workforce. Global Software Engineering has brought new challenges to development teams: Geographic separation, different time zones, different culture and language barriers. They introduce communication delay and often lead to quality problems and cost overruns. Despite these challenges Global Software Engineering has become a mainstream trend in industry. However, university instructors face the difficulty how to make students with little or no experience in global software development aware of these challenges and equip them with skills to deal with them. In this paper, we describe a set of interactive exercises for teaching Global Software Engineering in a single classroom and report on our experiences.

App users can submit feedback about downloaded apps by writing review comments and giving star ratings directly in the distribution platforms. Previous research has shown that this type of feedback contains important information for software evolution. However, in the case of the most popular apps, the amount of received feedback and its unstructured nature can produce difficulties in its analysis. We present an interactive user feedback visualization which displays app reviews from four different points of view: general, review based, feature based and topic-feature based. We conducted a study which visualized 2009 reviews from the Dropbox app available in the App Store. Participants considered the approach useful for software evolution tasks as they found it could aid developers and analysts get an overview of the most and least popular app features, and to prioritize their work. While using different strategies to find relevant information during the study, most participants came to the same conclusions regarding the user reviews and assigned tasks.

User involvement in software engineering has been researched over the last three decades. However, existing studies concentrate mainly on early phases of user-centered design projects, while little is known about how professionals work with post-deployment end-user feedback. In this paper we report on an empirical case study that explores the current practice of user involvement during software evolution. We found that user feedback contains important information for developers, helps to improve software quality and to identify missing features. In order to assess its relevance and potential impact, developers need to analyze the gathered feedback, which is mostly accomplished manually and consequently requires high effort. Overall, our results show the need for tool support to consolidate, structure, analyze, and track user feedback, particularly when feedback volume is high. Our findings call for a hypothesis-driven analysis of user feedback to establish the foundations for future user feedback tools.

Support of end-user needs is an important success factor for a software application. In order to optimize the support of end-user needs, developers have to be aware of them and their evolution over time. But a communication gap between developers and users leads to ignorance of developers about how users use their application. Also, developer assumptions about user behavior are rarely tested and corrected if they are wrong. Consequently, many software applications have a mediocre support of user needs and user problems as well as changes in user needs are detected rather late. In this paper, we present a research agenda addressing this problem by comparing use case descriptions to monitored user actions. More specifically, we propose to monitor user actions using instrumentation, detect the current use case of a user using machine learning, and compare use case steps to monitored user actions. By detecting differences between both, we identify mismatches between user behavior and developer assumptions reflected in use case descriptions. Those mismatches can serve as starting points to identify software improvements, to test the use case specification and identify updates, and to revise training programs. Finally, we sketch a plan to evaluate our approach.

The first step to comprehend and fix a software bug is usually to reproduce the corresponding failure. Reproducing a failure requires information about steps to reproduce, i.e. the steps necessary to make a failure occur in the development environment. In case of an application with a user interface, steps to reproduce consist of the interactions between a user and the application that precede the failure. Unfortunately, bug reports typically lack this information. Users are either unaware of its importance to developers, are unable to describe it, or simply do not have time to report it. In this paper, we present a simple but effective and resource efficient approach to monitor interactions between users and their applications selectively at a high level of abstraction, e.g. editing operations and commands. This minimizes the monitoring overhead and enables developers to analyze user interaction traces. We map monitored interactions to a taxonomy of user interactions to help developers comprehend user behavior. Further, we present the Timeline Tool that visualizes monitored interaction traces preceding failures. To evaluate our approach we conducted an experiment with 12 participants and asked them to reproduce bug reports from an open-source project. We found that developers are able to derive steps to reproduce from monitored interaction traces. In particular, inexperienced developers profit from the Timeline Tool, as they are able to reproduce failures that they cannot reproduce without it. The monitoring overhead is rather small (approx. 5% CPU and 2-5% memory) and users feel it does not influence their work in a negative way.

One question which frequently arises within the context of artifacts stored in a bug tracking repository is: “who should work on this bug report?” A number of approaches exist to semi-automatically identify and recommend developers, e.g. using machine learning techniques and social networking analysis. In this work, we propose a new approach for assignee recommendation leveraging user activities in a bug tracking repository. Within the bug tracking repository, an activity profile is created for each user from the history of all his activities (i.e. review, assign, and resolve). This profile, to some extent, indicates the user's role, expertise, and involvement in this project. These activities influence and contribute to the identification and ranking of suitable assignees. In order to evaluate our work, we apply it to bug reports of three different projects. Our results indicate that the proposed approach is able to achieve an average hit ratio of 88%. Comparing this result to the LDA-SVM - based assignee recommendation technique, it was found that the proposed approach performs better.

Early modeling languages have focused on the analysis and the design of systems under construction, but not on requirements elicitation. Consequently, a wide variety of approaches exists for the early phases of requirements engineering, modeling various concepts as stakeholders, goals, features, product lines, systems, processes, risks, and requirements. The purpose of Unified Requirements Modeling Language (URML TM) is to combine these concepts in a single modeling language. In addition, it strengthens support for danger modeling. URML is implemented as an add-in to the Enterprise Architect CASE tool. This tool demo will showcase the URML implementation.

Emotions play an important role in determining work results and how team members collaborate within a project. When working in large, distributed teams, members can lose awareness of the emotional state of the project. We propose an approach to improve emotional awareness in software development teams by means of quantitative emotion summaries. Our approach automatically extracts and summarizes emotions expressed in collaboration artifacts by combining probabilistic topic modeling with lexical sentiment analysis techniques. We applied the approach to 1000 collaboration artifacts produced by three development teams in a three month period. Interviews with the teams' project leaders suggest that the proposed emotion summaries have a good correlation with the emotional state of the project, and could be useful for improving emotional awareness. However, the interviews also indicate that the current state of the summaries is not detailed enough and further improvements are needed.

Software maintenance and support services are key factors to the customer perception of software product quality. The overall goal of FastFix is to provide developers with a real-time maintenance environment that increases efficiency and reduces costs, improving accuracy in identification of failure causes and facilitating their resolution. To achieve this goal, FastFix observes application execution and user interaction at runtime. We give an overview of the functionality of FastFix and present one of its main application scenarios.

This paper presents the results of an online survey with more than a hundred High Performance Computing (HPC) community members. The goal of the survey was to get a deeper understanding of ongoing HPC projects and the project participants' knowledge about software engineering. Previous and current research give the impression that with software engineering methods adequate for the development of HPC applications time and effort can be saved. But the knowledge of the right and most beneficial methods is not easily available for HPC developers. The results of the survey confirm that there is only little use of software engineering in HPC and, as outlined in the related work section, there is so far no general approach to spread the use of software engineering in the HPC community. But according to our findings, deploying software engineering to facilitate the development of HPC applications is certainly a matter of interest.

Change and user involvement are two major challenges in agile software projects. As change and user involvement usually arise spontaneously, reaction to change, validation and communication are thereby expected to happen in a continuous way in the project lifecycle. We propose Evolutionary Scenario Based Design, which employs video in fulfilling this goal, and present a new idea that supports video production using SecondLife-like virtual world technology.

Single large project courses (SLPC) with clients from industry have been established as capstone courses in many software engineering curricula. They are considered a good way of teaching industry relevant software engineering practices to students. However they are lacking in two regards. First, the results are often seen as exploratory prototypes by the client and are not intended for productive use. Second, the projects are usually not integrated into the application landscape of the client. Both of these challenges are of great practical importance in real software engineering projects. In this tutorial we cover the key factors for successfully carrying out our teaching approach called SLPC++ to address these issues. First we show how to initiate such a project course with real clients and problems. Then we describe how to carry out the project using a hybrid process model based on a combination of the Unified Process and Scrum. Finally we address the issues instructors face during such courses. Throughout the tutorial we use examples from a series of four project courses carried out in a highly successful collaboration with the Munich Airport.

Many research approaches in software engineering propose models or extensions to existing models. This includes system models, such as UML models, and project management artifacts, such as bug reports or tasks. For evaluating a research approach these models have to be implemented. Existing tools often lack the required extensibility and do not support data collection and analysis. Therefore, many researchers have to spend significant effort on the implementation. In this paper, we identify common requirements for a platform to build research tools on and we evaluate them based on potential use for recent publications. To evaluate the relevancy of the requirements we reviewed 274 research papers from the software engineering category of two major conferences over the last two years. We found 38 research approaches among those that would have benefited from a common platform with the presented requirements.

Global software engineering has gained in importance over the past decade. Many companies today conduct development projects in globally distributed teams. Coordination and communication over distance are key issues of global software engineering. In many cases, this communication is related to requirements. In this work, we try to gain new insights by looking at global requirements engineering from the perspective of "decision making": instead of looking at artifacts (requirements, architectural compontents, etc.), we can look e.g. at how decisions are made, what implications they have, or how they are communicated within globally distributed teams. Equally important, we also see the impact of the organizational form on decision making: the concept of so-called "chaordic" organization, which involves self-organizing teams ("chaos") and a frame organization ("order"). Also the analysis of communication relationships in globally distributed teams (social network analysis) is a proven method to detect problems early on. In this dissertation, these three aspects are combined to introduce a framework for decision support in global requirements engineering. We investigate leaders, followers and their interactions and aim at identifying patterns to better understand and improve decision making in global requirements engineering.

Controlling graphical user interfaces (GUI) by speech is slow, but proves useful for disabled persons with limitations in operating mouse and keyboard. We present conversation-and-control, a new approach for using speech as input modality for GUIs, which facilitates direct manipulation of widget functions by spoken commands. Our approach is based on a command language, which provides a unique command for each specific widget function. For managing the interaction we propose a mixed-initiative dialog model, which can be generated from widget properties. Using heuristics for inferring the meaning of a recognition result and having the ability to ask clarification questions, our approach avoids the rejection of recognition errors. We hypothesized that conversation-and-control allows for shorter task completion times than conventional command-and-control approaches, due to a reduction of the average number of required commands. The results of a user experiment, which we present and discuss, indicate a 16.8% reduction of task completion time achieved by our approach.

Modeling variability is a challenging issue in product line requirements engineering. Particular problems include, the instantiation of variations for individual products, the long-term evolution of the product line, and the support of collaboration between stakeholders. These problems are even more complicated when the product line organization is globally distributed. To address theses problems, this paper identifies four higher-level similarities between rationale management (which focus on knowledge management during software design) and variability management. Furthermore, exploiting the similarities, rationale management is combined with variability management to contribute issue-based variability modeling. Issue-based variability modeling was implemented and empirically evaluated based on a series of case studies with multi-case design. The results of the evaluation show that our approach improves the instantiation and evolution of variability, enables better informal collaboration between distributed stakeholders with different levels of modeling expertise and enhances the longevity of product lines.

Product line evolution is one of the burning issues in product line requirements engineering. It is more complicated than single system requirements engineering because of the conflicting requirements across the product lines, the effect of evolution on the reuse and customization, and the global distribution of product line organizations. As product lines are long-term investments, handling their evolution is critical. This paper proposes a new technique called rationale-based product line evolution. It is based on the Questions, Options and Criteria model and a modified version of EasyWinWin. The technique allows the evaluation of change requests in product line requirements based on the informal collaboration of stakeholders, capturing the forces that cause evolution and using them for the justification of change requests. The technique has been implemented in the Sysiphus tool and was validated using empirical evaluation.

In global software projects, informal communication across sites is severely hampered, making it difficult to disseminate implicit knowledge. Participants have a partial view of the overall organization, do not have access to the complete rationale behind decisions, and when changes arise, participants from other sites are surprised. Consequently, issues that could be clarified almost immediately require days until the relevant stakeholders are identified, the issues are understood, and a resolution is agreed upon. We focus on the specific problem of externalizing issues with their context, stakeholders, and organizational roles in distributed settings. The challenge is to capture sufficient knowledge as a side effect of development, while structuring it for long-term use. We describe Sysiphus, a distributed environment providing a uniform framework for system models, collaboration artifacts, and organizational models. Sysiphus encourages participants to make communication and issues explicit in the context of system models and become aware of relevant stakeholders

Distributed software development is increasingly becoming a common practice in the software industry. The increased complexity of software systems also reflects in the complexity of design documentation, thus requiring a specific tool support for change and configuration management in distributed development settings. We present the fine-grained versioning management approach adopted in the ADAMS artefact management system, focusing on support to high level documentation versioning. We also present the results of experimenting the tool in software development projects developed at the University of Salerno

The dialogue between end-user and developer presents several challenges in requirements development. One issue is the gap between the conceptual models of end-users and formal specification/analysis models of developers. This paper presents a novel technique for the video analysis of scenarios, relating the use of video-based requirements to process models of software development. It uses a knowledge model-an RDF graph-based on a semiotic interpretation of film language, which allows mapping conceptual into formal models. It can be queried with RDQL, a query language for RDF. The technique has been implemented with a tool which lets the analyst annotate objects as well as spatial or temporal relationships in the video, to represent the conceptual model. The video can be arranged in a scenario graph effectively representing a multi-path video. It can be viewed in linear time order to facilitate the review of individual scenarios by end-users. Each multi-path scene from the conceptual model is mapped to a UML use case in the formal model. A UML sequence diagram can also be generated from the annotations, which shows the direct mapping of film language to UML. This sequence diagram can be edited by the analyst, refining the conceptual model to reflect deeper understanding of the application domain. The use of the software cinema technique is demonstrated with several prototypical applications. One example is a loan application scenario for a financial services consulting firm which acted as an end-user

In the past, architectures of augmented reality systems have been widely different and tailored to specific tasks. In this paper, we use the example of the SHEEP game to show how the structural flexibility of DWARF, our component-based distributed wearable augmented reality framework, facilitates a rapid prototyping and online development process for building, debugging and altering a complex, distributed, highly interactive AR system. The SHEEP system was designed to test and demonstrate the potential of tangible user interfaces which dynamically visualize, manipulate and control complex operations of many inter-dependent processes. SHEEP allows the users more freedom of action and forms of interaction and collaboration, following the tool metaphor that bundles software with hardware in units that are easily understandable to the user. We describe how we developed SHEEP, showing the combined evolution of framework and application, as well as the progress from rapid prototype to final demonstration system. The dynamic aspects of DWARF facilitated testing and allowed us to rapidly evaluate new technologies. SHEEP has been shown successfully at various occasions. We describe our experiences with these demos.

Research prototypes in AR usually do not emphasize software architecture. Nevertheless, their architecture is not arbitrary, but results from specific needs. Architectural approaches embodying research contributions are of particular value for reuse at component and architectural levels. We have conducted a study of existing AR software architectures for the ARVIKA project by W. Friedrich et al (2001). This has resulted in a catalog of important desired quality attributes for AR systems, a reference architecture for comparison of AR architectures, and a catalog of architectural approaches used in current AR systems. We believe this lays the foundation for further research in AR software architectures.

We have taught several distributed software engineering project courses with students and real clients. During these projects, students in Pittsburgh and Munich, Germany collaborated in the development of a single system. Our experiences showed that software development is communication intensive and requires the collaboration of many stakeholders. Communication is challenging in distributed contexts: participants do not all know each other and work at different times and locations; the number of participants and their organization change during the project; and participants belong to different communities. Hence, to deal with the global marketplace, it is critical to provide students with distributed collaboration skills. To improve the teaching of collaboration in software engineering, we propose iBistro, an augmented, distributed, and ubiquitous communication space. iBistro aims to overcome problems resulting from miscommunications and information loss in informal or casual meetings. iBistro enables distributed groups to collaborate and cooperate in software projects and therefore provides an environment for learning in diverse aspects such as project management, programming skills, and social skills. With the addition of techniques from artificial intelligence, such as student modeling, and intelligent support mechanisms, such as computer supported group formation, distributed tutoring becomes feasible.

Augmented Reality (AR), mobile computing, and ubiquitous computing have each individually provided technology enablers for new types of applications. Researchers have demonstrated over the years spectacular toy systems that fire researchers' imaginations. However, cross-fertilization between these areas has only just begun. Combining these technology enablers into robust information systems that can be used in the field present many software engineering challenges that have not been taken into account by the toy systems mentioned above. In this paper, we report our efforts at TU Munich to analyze information generation, retrieval, transmission, and visualization in the context of maintenance procedures in nuclear powerplants. The use of AR to present such information online has significant implications on the overall system architecture. This paper focuses on pointing out open questions, discussing options for addressing them, and evaluating them in prototypical implementations.

As a result of globalization, mergers, acquisitions, and scarce skills, software development is becoming increasingly distributed. Distribution, however, introduces major communication barriers, including time zone differences, cultural differences, and most project participants have never met face to face. In this paper, we focus on "knowledge scouts," developers who travel briefly to other sites and report to their home base what they have discovered and learned. With a case study we show how knowledge scouts can overcome many communication issues. We propose that the research focus should be on the simpler problem of supporting a small mobile group of developers as a means of addressing the inherent communication obstacles in distributed software projects.

Communication and collaboration is difficult in geographically distributed settings. As a result of globalization, mergers and acquisitions, and scarce skills, software development projects are increasingly more distributed. Hence, teaching software engineering students how to cope with distribution becomes a critical issue. This paper describes our experience with teaching three distributed software engineering project courses. Students from Carnegie Mellon University in Pittsburgh, USA and from Technische Universita/spl uml/t Mu/spl uml/nchen in Munich, Germany, collaborated to specify, design and realize software for a real client located at a third site. In doing so, students were exposed first hand to distribution issues, encountering challenges introduced by different cultures, languages, standards and time zones, and facing them with tools such as groupware, videoconferencing, distributed repositories and travel. We conclude this paper with the lessons we learned during these three experiences and the improvements we plan for our next distributed project course.

Presents empirical evidence that metrics on communication artifacts generated by groupware tools can be used to gain significant insight into the development process that produced them. We describe a test-bed for developing and testing communication metrics, a senior-level software engineering project course at Carnegie Mellon University, in which we conducted several studies and experiments from 1991-1996 with more than 400 participants. Such a test-bed is an ideal environment for empirical software engineering, providing sufficient realism while allowing for controlled observation of important project parameters. We describe three proof-of-concept experiments to illustrate the value of communication metrics in software development projects. Finally, we propose a statistical framework based on structural equations for validating these communication metrics.

ABSTRACTtWe present empirical evidence that metrics on communication artifacts generated by groupware tools can be used to gain significant insight into the development process that produced them.We describe a testbed for developing and testing communication metrics, a senior level software engineering project course at Carnegie Mellon University, in which we conducted several studies and experiments from 1991 to 1996 with more than 300 participants.Such a testbed is an ideal environment for empirical software engineering, providing sufficient realism while allowing for controlled observation of important project parameters.We illustrate the value of communication metrics with three proof-of-concept experiments and propose a statistical framework based on structural equations for validating communication metrics.

BEE++ is an object-oriented application framework for the dynamic analysis of distributed programs.The main objective of BEE++ is to provide a common platform for monitoring and debugging.BEE++'s class library consists of a rich set of classes for event processing to support a variety of visualization, monitoring and debugging needs.It also provides for customizability of event processing through inheritance.Users can derive customized graphical debugging and visualization systems from a set of base classes.BEE++'s other design goals are the support of dynamic program analysis for distributed heterogenous target applications at runtime with predictable overhead.The design is based a symmetric peer-peer architecture, including the ability to dynamically configure target appli,.cations and monitoring tools.The dynamic analysis tools can be distributed across nodes, which provides significant performance gains for visualization applications.In addition, the framework can be instantiated for a variety of communication protoco1s.A TCP/IP based instance of the framework has been ported to several machine architectures including Sun, Vax and Cray-YMP.BEE++ is based on BEEI 101, a portable platform for monitoring implemented in C but has been completely reengineered in C++ using the object-oriented design methodology OMT.Performance measurements indicate that the runtime overhead of the object-oriented version is not signilicant when compared with the C version.

We describe our experience with the object-oriented design methodology OMT [19] applied to a project in an undergraduate software engineering course at Carnegie Mellon University.The project involved 30 students previously unfamiliar with objectoriented modeling.They designed and implemented a system of 125 classes (27,000 lines of C++ and C code) in the relatively short time of 15 weeks.We describe the overall structure of the project and the system model, the usefulness of OMT and its impact on communication, and discuss some of the problems encountered during the development of the system.

Programmers who want to do network computing face several challenges: the network and attached systems are shared resources with an unpredictable behavior and network communication primitives are often hard to use. The programming environment developed for the Nectar system addresses both problems. It provides simple and efficient communication primitives, and an efficient monitoring kernel that allows both programmers and programming tools to monitor the behavior of the program in the dynamic network environment. Experience shows that monitoring the progress of applications interactively is both desirable and practical.>

The goal of the Warp Programming Environment (WPE) is to provide easy access to the Warp machine, a parallel supercomputer with a peak performance of 100 MFLOPS that is based on the systolic array architecture. The Warp Programming Environment offers a uniform environment for editing, compiling, debugging and executing Warp programs. It is based on an extensible shell written in Common Lisp and a runtime system written in C. It runs on a network of SUN-3 workstations under UNIX 4.2. This paper describes how the program development environment interacts with the Warp machine to support the development and execution of real-time programs on Warp.