Hybrid Algorithms for the Search of Test Data in SPL – Javier Ferrer

In Software Product Lines (SPLs) it is not possible, in general, to test all products of the family. The number of products denoted by a SPL is very high due to the combinatorial explosion of features. For this reason, some coverage criteria have been proposed which try to test at least all feature interactions without the necessity to test all products, e.g., all pairs of features (pairwise coverage). In addition, it is desirable to first test products composed by a set of priority features. This problem is known as the Prioritized Pairwise Test Data Generation Problem.

In our work we propose hybrid algorithms to generate prioritized test suites. The first one is based on an integer linear formulation and the second one is based on a integer quadratic (nonlinear) formulation. We compare these techniques with two state-of-the-art algorithms, the Parallel Prioritized Genetic Solver (PPGS) and a greedy algorithm called prioritized-ICPL. Our study reveals that our hybrid nonlinear approach is clearly the best in both, solution quality and computation time.

Presentation: ferrer-SS-SBSE2017

Deep Parameter Optimisation on Android Smartphones for Energy Minimisation – Markus Wagner

With power demands of mobile devices rising, it is becoming increasingly important to make mobile software applications more energy efficient. Unfortunately, mobile platforms are diverse and very complex which makes energy behaviours difficult to model. This complexity presents challenges to the effectiveness of off-line optimisation of mobile applications. In this paper, we demonstrate that it is possible to automatically optimise an application for energy on a mobile device by evaluating energy consumption “in-vivo”. In contrast to previous work, we use only the device’s own internal meter. Our approach involves many technical challenges but represents a realistic path toward learning hardware specific energy models for program code features.

Presentation: sbse-deepparameter

Automated Software Development Support through Optimized Code History Models – Francisco Servant

Software developers regularly need to find diverse information to successfully perform their tasks. Some example of software information needs are: “why was this code implemented in this way?”, or “who has expertise in this functionality?” Unfortunately, finding such information requires high effort, and it is often found inaccurately, which not only decreases software development productivity, but it also decreases software quality. In my research, I follow the insight that many of the questions that developers ask can be answered automatically by analyzing the data that they produced in past software development tasks. I will present a series of techniques that automate the multi-revision, fine-grained analysis of source code history. These techniques provide high accuracy by optimizing code similarity over its modeled history. I will also demonstrate how these techniques help software developers to find relevant information about software development tasks efficiently and accurately.

Maintenance of the logical consistency in Cassandra – Pablo Suárez-Ótero

Contrary to the relational databases, in NoSQL databases like Cassandra is very common that duplicity of data in different tables happens. This is because usually tables are query driven (designed based on queries) and there are not any relationships between them, in order to increase the performance of the queries. Therefore, if the data is not updated on a proper way, inconsistencies in the stored information could appear. It is quite easy to introduce defaults that cause inconsistencies of the data in Cassandra, especially during the evolution of a system where new tables are created, being these ones hard to detect using conventional techniques of dynamic testing. The developer is the one responsible for the maintenance of this consistency incorporating and updating the proper procedures. In this session, a preventive approach to these problems is introduced, establishing the procedures required to ensure the quality of data from the point of view of their consistency and thus helping the developer. These procedures include a static analysis using the conceptual model, the queries and the logical model of the application. They also include the determination and execution of the operations that guarantee the consistency of the information.

Discovery of design patterns based on good practices -Rafael Barbudo

The complexity of current software systems obliges software engineers to learn about the good practices employed in previous projects. The use of design patterns is not an exception, as they can provide developers with a tool to improve the reusability and modularisation of their code. In this context, this talk will introduce a three-step prototypical model aimed at supporting software engineers to implement design patterns based on previous examples and successful experiences. This model makes use of machine learning techniques like frequent pattern mining. A suitable representation of this knowledge will allow us to identify potential code chunks which might become a design pattern.

Presentation: 2ss-sbse

Agile Effort Estimation – Natasha Nigar

Software projects that are over-budget, delivered late, and fall short of users’ expectations have been a challenge in software engineering for decades. The success or failure of a software project heavily depends on the accuracy of effort estimation. The software project cost is primarily estimated based on effort which is defined as the time taken by the software development team members for individual tasks completion. Therefore, accurate effort estimation has gained highest importance due to exponential growth of large scale software applications.
This research contributes by presenting a novel approach for effort estimation in ‘Agile Software development’ (ASD). In ASD, changes in customer requirements are proactively incorporated while delivering software projects within budget and time. We shall formulate effort estimation as the search-based problem and use computational intelligence techniques, such as evolutionary algorithms, to address following limitations in the current research for agile effort estimation.

  1. Datasets used for effort estimation contain single company projects data. We will use cross-company data to validate our model.
  2. Other than scrum and XP no other agile method was investigated. We will use KANBAN agile method in our research.
  3. We will be first to use line of code (LOC) as size metric. The benefit of this research is that it will reduce the risk of software project falling behind schedules by providing realistic estimation figures


Participants attending the summer school will have the opportunity to give a host talk on their ongoing research project. They will receive feedback from senior researchers in SBSE during the summer school. Information about talks will be available after the registration deadline.

Talks I

Wednesday, June 28 (12:00 – 13:30)

  • Agile Effort Estimation (Natasha Nigar)
  • Discovery of design patterns based on good practices (Rafael Barbudo)
  • Maintenance of the logical consistency in Cassandra (Pablo Suárez-Ótero)
  • Hybrid Algorithms for the Search of Test Data in SPL (Javier Ferrer)

Talks II

Friday, June 30 (12:00 – 13:00)

  • Automated Software Development Support through Optimized Code History Models (Francisco Servant)
  • Deep Parameter Optimisation on Android Smartphones for Energy Minimisation (Markus Wagner)