Kristina Winbladh

Analysis of user comments: an approach for software requirements evolution

User feedback is imperative in improving software quality. In this paper, we explore the rich set of user feedback available for third party mobile applications as a way to extract new/changed requirements for next versions. A potential problem using this data is its volume and the time commitment involved in extracting new/changed requirements. Our goal is to alleviate part of the process through automatic topic extraction. We process user comments to extract the main topics mentioned as well as some sentences representative of those topics. This information can be useful for requirements engineers to revise the requirements for next releases. Our approach relies on adapting information retrieval techniques including topic modeling and evaluating them on different publicly available data sets. Results show that the automatically extracted topics match the manually extracted ones, while also significantly decreasing the manual effort.

Initial explorations on design pattern energy usage

As the use of computers has grown, so too has concern about the amount of power they consume. Data centers, for example, are limited in scalability as they struggle with soaring energy costs from many large companies relying on fast, reliable, and round-the-clock computing services. On large-scale computing clusters, like data centers, even a small drop in power consumption can have large effects. Across computing contexts, reducing power consumed by computers has become a major focus. In this paper, we present a new approach for mapping software design to power consumption and present empirical results of the approach on different software implementations. In particular, we compare the power profiles of software using design patterns against software not using design patterns as a way to explore how high-level design decisions affect an applications energy usage. We show how mappings between software design and power consumption profiles can provide software designers and developers with useful information about the power behavior of the software they are developing. The goal is for software engineers to use this information in designing and developing more energy efficient solutions.

Investigating the impacts of web servers on web application energy usage

Software engineers make decisions about the design of the software they are creating on a daily basis. These decisions may impact the application in terms of efficiency, usability, flexibility, etc. Different competing design decisions are therefore often evaluated in terms of their projected impact on quality metrics prior to implementation. Recently energy has become a concern for software systems, ranging from mobile devices to large data centers. Additionally, it has been recognized that the software executing on a computing device can have a significant impact on the devices energy consumption. This raises the obvious question of whether or not it is possible to reduce the energy consumption of a software system by the means of software design decisions. This work examines how the use of different servers impacts the energy consumption of a web application. Through a controlled empirical experiment we have discovered several important findings in this regard. The results indicate that the energy consumption of a web application can vary greatly depending on the web server used to handle its requests. Furthermore, different web servers are more or less energy efficient depending on which web application features are being executed. The paper details an analysis of the results of the experiment.

An Automated Approach for Goal-driven, Specification-based Testing

This paper presents a specification-based approach that addresses several known challenges including false positives and domain knowledge errors. Our approach begins with a goal graph and plans. Source code is annotated with goals and events and precompiled to emit those at run time. Plans are automatically translated into a rule-based recognizer. An oracle is produced from the pre- and postconditions associated with the plans goals. When the program is executed, goals and events are emitted and automatically tested against plans and oracles. The concept is demonstrated on a small example and a larger publicly available case study

Eliciting required characteristics for usable requirements engineering approaches

It has been reported that many software companies do not use existing requirements engineering approaches. This indicates that there is room and opportunity for improving the usability of existing requirements engineering approaches. This paper describes a market study intended to elicit a set of characteristics that could improve the usability of requirements engineering approaches. The survey is aimed toward software stakeholders such as developers, designers, customers, and managers at various software companies. The survey results are used to define a set of desirable characteristics for usable requirements engineering approaches and to suggest a set of guidelines that could help achieve the desirable characteristics.

Automatic Detection of Ambiguous Terminology for Software Requirements

Identifying ambiguous requirements is an important aspect of software development, as it prevents design and implementation errors that are costly to correct. Unfortunately, few efforts have been made to automatically solve the problem. In this paper, we study the problem of lexical ambiguity detection and propose methods that can automatically identify potentially ambiguous concepts in software requirement specifications. Specifically, we focus on two types of lexical ambiguities, i.e., Overloaded and Synonymous ambiguity. Experiment results over four real-world software requirement collections show that the proposed methods are effective in detecting ambiguous terminology.

iMuse: interactive model-based use-case and storytelling environment

Requirements specification is an important problem in software engineering. Key challenges in Requirements Engineering (RE) include enabling different stakeholders to understand and validate the requirements, and enabling collaboration among different types of stakeholders with different skills and expertise and potentially conflicting needs and expectations. We contend that collaboration among both technical and non-technical stakeholders is improved by a requirements specification technique that provides both precision and usability - and a better balance of the two. We implement our specification technique in iMuse - Interactive Model-based Use-case and Storytelling Environment. In this demo, we show how iMuse can be used by stakeholders to express and view narrative functional requirements.

Architecture-based testing using goals and plans

This paper presents a specification-based testing approach that compares software specifications defined at different levels of abstraction, e.g. architecture and implementation, against specified system goals. We believe that a goal-driven approach that connects several development artifacts through verification of specified goals provides useful traceability links between those artifacts as well as an efficient testing technique. Our approach begins with a system goal graph in which high-level goals are step-wise refined into low-level functional goals that can be realized as code components. Each of the architectural components is associated with a plan that describes the components functional behavior. Source code is annotated with goals from plans and events that achieve the goals; code is then precompiled to emit those goals and events at run time. Plans are automatically translated into a rule-based recognizer. An oracle is produced from the pre- and post-conditions associated with the plans goals. When the program executes, the goals and events emitted are automatically tested against the plans and expected results. As components achieve their component-level plans, a higher-level plan recognizer, concerned with the integration of components, can verify correct system behavior over the interaction trace of a collection of lower-level plans. A small example illustrates the concept.

Implementation of Imaging Compressive Sensing Algorithms on Mobile Handset Devices

Compressive Sensing (CS) is a remarkable framework that efficiently senses a signal taking a set of random projections from the underlying signal. Using the random projections, a CS reconstruction algorithm is then used to reconstruct the initial signal. Extensive efforts have been made in CS to determine the minimum number of required random projections and to design efficient optimization algorithms for correct signal reconstruction. In practice, the huge number of operations required for these reconstruction algorithms have restricted CS techniques to be implemented on high performance computational architectures, such as personal computers, servers, and Graphical Processing Units (GPU). This work determines the computational requirements to implement CS techniques on a limited memory mobile device. The results show the computational time and the energy consumption of two CS image reconstruction algorithms on a mobile device as a function of the size and sparsity of the underlying image. Results in the quality of the images recovered in smartphones show a Peak Signal to Noise Ratio of about 39 dB. Regarding the energy consumption, both greedy algorithms dissipated the same energy during the compression/reconstruction process.

Clarity for Stakeholders: Empirical Evaluation of ScenarioML, Use Cases, and Sequence Diagrams

We studied the clarity of three requirements forms, operationalized as ease of problem detection, freedom from obstructions to understanding, and understandability by a variety of stakeholders. A set of use cases for an industrial system was translated into ScenarioML scenarios and into sequence diagrams; problems identified during each translation were noted; and all three forms were presented to a range of system stakeholders, who were nterviewed before and after performing tasks using the forms. The data was analyzed, and convergent results were triangulated across data sources and methods. The data indicated that ScenarioML scenarios best support requirements clarity, then sequence diagrams but only for stakeholders experienced with them, and finally use cases as the least clear form.