Taming your PhD (Invited Talk)

Oscar Nierstrasz, University of Bern, Switzerland

Monday 11.07.2016, 09:00–10:00

Mastering a PhD can feel at times like tangling with a wild beast. It takes creativity, discipline, and care to bring it safely home. We will discuss some of the most common difficulties PhD students may encounter, whether they are just starting their PhD work, or or well along the way to completing it. In particular, we will cover tips and tricks useful for planning PhD research, writing about it, and presenting it, as well for maintaining focus along the way to completion of the PhD.

Slides: slideshare

An Empirical Study on the Use of SQL Trace Visualization for Program Understanding

Nesrine Noughi, University of Namur, Belgium
Stefan Hanenberg, University of Duisburg-Essen, Germany
Anthony Cleve, University of Namur, Belgium

Monday 11.07.2016, 10:30–11:00

Paper: pdf

Representing Component Authorship Using Randomly Generated Glyphs

Alexandre Bergel, University of Chile, Chile

Monday 11.07.2016, 11:00–11:30

Abstract: VisualIDs are randomly generated glyphs. A glyph visually describes an object and is designed to let a human easily recognize similarity between the represented objects.
In this short abstract, we use glyphs to represent code authorship. We have employed VisualID glyphs to represents author collaboration across over 160 classes.

Paper: pdf

An Exploratory Study Into the Prevalence of Botched Code Integrations

Ward Muylaert, Vrije Universiteit Brussel, Belgium
Wolfgang De Meuter, Vrije Universiteit Brussel, Belgium
Coen De Roover, Vrije Universiteit Brussel, Belgium

Monday 11.07.2016, 11:30–12:00

Abstract: Integrating code from different sources can be an error-prone and effort-intensive process. While an integration may appear statically sound, unexpected errors may still surface at run time. The industry practice of continuous delivery aims to detect these and other run-time errors through an extensive pipeline of successive tests. Travis CI is a con- tinuous delivery system that is free to use for open-source projects on GitHub. Of interest to researchers is the fact that Travis CI makes the outcome of each stage in the continuous delivery pipeline available through its API. At the seminar, we will present the initial results of an exploratory study on the prevalence of integration errors. We have linked GitHub’s information about integration efforts with Travis CI’s information about the integration outcome to this end.

Paper: pdf

Against the Mainstream in Bug Prediction

Haidar Osman, University of Bern, Switzerland

Monday 11.07.2016, 12:00–12:30

Abstract: Bug prediction is a technique used to estimate the most bug-prone entities in software systems. Bug prediction approaches vary in many design options, such as dependent variables, independent variables, and machine learning models. Choosing the right combination of design options to build an effective bug predictor is hard. Previous studies do not consider this complexity and draw conclusions based on fewer- than-necessary experiments.
We argue that each software project is unique from the perspective of its development process. Consequently, metrics and AI models perform differently on different projects, in the context of bug prediction.
We confirm our hypothesis empirically by running different bug predictors on different systems. We show that no single bug prediction configuration works globally on all projects and, thus, previous bug prediction findings cannot generalize.

Paper: pdf

Text Retrieval and Natural Language Processing in Software Engineering (Tutorial)

Venera Arnaoudova, Washington State University, USA

Monday 11.07.2016, 14:00–16:00

Abstract: During software evolution many related artifacts are created or modified. Some of these are composed of structured data (e.g., analysis data), some contain semi-structured information (e.g., source code), and many include unstructured information (e.g., natural language text). Software artifacts written in natural language (e.g., requirements, design documents, user manuals, scenarios, bug reports, developers’ messages, etc.), together with the comments and identifiers in the source code encode to a large degree the domain of the software, the developers’ knowledge about the system, capture design decisions, developer information, etc. In many software projects the amount of the unstructured information exceeds the size of the source code by one order of magnitude. Retrieving and analyzing the textual information existing in software are extremely important in supporting program comprehension and a variety of software evolution tasks.

This tutorial aims at providing sufficient information to allow Software Engineering researchers and practitioners to start using Text Retrieval (TR) and Natural Language Processing (NLP) methods in their day-to-day work. The tutorial will first give a background on the main TR and NLP techniques used in Software Engineering and then will give an overview of the application of these techniques to specific SE tasks. We will discuss challenges, advantages, and limitations of the use of TR and NLP in software engineering and lay out future directions for TR and NLP in SE from the practice and research points of view. Finally, the tutorial will conclude with practical examples showing how to use some of the available NLP tools to analyze software artifacts.

Future challenges in software evolution analysis from industrial and academic perspective (Invited Talk)

Aiko Yamashita, Oslo and Akershus University College of Applied Sciences, Norway

Tuesday 12.07.2016, 9:00–10:00

Abstract: This talk presents some of the major findings of a controlled case study conducted for assessing the suitability of code smells as indicators of software maintainability, complemented by additional studies around the topic of inter-smells and refactoring behaviour. The results are not surprising, and not very hopefull either: quality in software is a hairy, chaotic problem. There is still a great challenge for developing adaptable, useful, and accessible quality models and evaluation methodologies that can (really) be used in industry. Based on the major research results; trends and experiences from industry, the talk explores some potential ways to deal with the chaotic facets of software development.

A Study On The Accumulation Of Technical Debt On Framework-based Web Applications

Georgios Digkas, University of Groningen, Netherlands
Alexander Chatzigeorgiou, University of Macedonia, Thessaloniki, Greece
Apostolos Ampatzoglou, University of Groningen, Netherlands

Tuesday 12.07.2016, 10:30–11:00

Paper: pdf

Supporting the evolution of behavioral software models – A Research Vision

Tom Mens, University of Mons, Belgium

Tuesday 12.07.2016, 11:00–11:30

Abstract: This position paper starts by presenting the important research challenges related to model-driven software evolution. We revisit those challenges in the context of executable models of behavioral design (such as statecharts), and outline the research goals we aim to address in this domain.

Paper: pdf

Slides: slideshare

Building Ecosystem-Aware Tools Using the Ecosystem Monitoring Framework

Boris Spasojević University of Bern, Switzerland

Tuesday 12.07.2016, 11:30–12:00

Abstract: Integrating ecosystem data into developer tools can be very beneficial but is usually complicated. By automating the routine parts of this task we can reduce the amount of work needed to develop these tools. We have developed a framework that allows developers to quickly develop new tools that use ecosystem data. This framework automates the execution of user-defined analyses on ecosystem projects, allowing the developer to focus only on what ecosystem data is needed for her tool and how to present it.

Paper: pdf

Generating dependency constraints between packages using static code analysis

Maëlick Claes, University of Mons, Belgium
Tom Mens, University of Mons, Belgium

Tuesday 12.07.2016, 12:00–12:30

Abstract: When developing software components in a software ecosystem, using dependency relationships is a common practice to ease component management and maintenance. An important and well-known challenge is how to deal with these dependencies between components when the system evolves. Version constraints are often used to limit these dependency relationships in order to assure that each component will work with all its dependencies. Still, this information can be missing or inconsistent. The R ecosystem, composed of thousands of statistical software packages suffer from many maintainability issues and the lack of dependency constraints has been pinpointed by the community. In this presentation we present a work in progress technique based on static code analysis we used to detect dependency constraints between R packages and its current limitations.

Paper: pdf

Safer Refactorings with Assertions

Anna Maria Eilertsen, University of Bergen, Norway
Anya Helene Bagge, University of Bergen, Norway
Volker Stolz, Bergen University College, Norway

Tuesday 12.07.2016, 16:30–17:00

Paper: pdf

Slides: slideshare

A Coupled Transformations Chrestomathy Based on Compilable and Executable Megamodels (Technology Showdown)

Ralf Lämmel, University of Koblenz-Landau, Germany

Tuesday 12.07.2016, 17:00–18:00

Abstract: Many software engineering contexts involve a collection of coupled artifacts, i.e., changing one artifact may challenge consistency between artifacts of the collection. A coupled software transformation (CX) is meant to transform one or more artifacts of such a collection while preserving consistency. There are many forms of coupling—depending on technological space and application domain and solution approach. We collect important forms of coupling in an illustrative manner within the Prolog-based software language repository YAS (Yet Another SLR (Software Language Repository)).

Paper: pdf

Slides: pdf

drys: A Version Control System for Rapid Iteration of Serialization Protocols (Technology Showdown)

Jaakko Jarvi, Texas A&M University

Tuesday 12.07.2016, 17:00–18:00

Abstract: Tagged binary formats are fast to load but potentially fragile to main- tain as a software system evolves. This paper presents a tool for gen- erating the code not just for serializing binary file formats, but also for upgrading old versions to newer ones, enabling rapid development of new versions.

Paper: pdf

In Defense of Basic Tools For Software Evolution: Programming Languages (Invited Talk)

Romain Robbes, University of Chile

Wednesday 12.07.2016, 09:00–10:00

Abstract: Programming languages are the most basic tool programmers have at their disposal to write and evolve software. As such, I argue that programming language usage is a very important topic of study in order to get a complete picture of software evolution. I briefly present a handful of empirical studies, before delving in details on a specific example, our study of the infamous goto statement.

Analysing CSS using the M3 model

Nico de Groot, University of Amsterdam, Netherlands

Wednesday 12.07.2016, 10:30–11:00

Abstract: Cascading Style Sheets (CSS) is a language that adds presentation semantics to hyper text documents. Even though CSS has a relatively simple syntax, lots of mistakes are made during the development of style sheets, ranging from small syntactic flaws to duplicate code. In this effort we introduce an M3 front-end for CSS, a simple and extensible model for capturing facts about source code, allowing developers to analyse and transform CSS without much excessive development. During the development of the M3 front-end for CSS, the proclaimed flexibility of the M3 model has also been confirmed since it had only been successfully implemented for the Java and PHP programming languages. The unique characteristics of CSS, such as its cascading abilities, or its dependency on HTML, did not result in any major complications for the M3 model. The M3 front-end for CSS has also been validated by conducting analysis on real-world CSS, from this we can conclude that the M3 model is able to successfully support today’s CSS standard (level 3). By presenting the implementations for some of the conducted analysis, we support our claim stating that the M3 model allows developers to conduct analyses, and manipulations on CSS with little ease.

Paper: pdf

Critical CSS Rules — Decreasing time to first render by inlining CSS rules for over-the-fold elements

Gorjan Jovanovski, University of Amsterdam, Netherlands
Vadim Zaytsev, Raincode, Brussels, Belgium

Wednesday 12.07.2016, 11:00–11:30

Paper: pdf

Towards Efficient Object-Centric Debugging with Declarative Breakpoints

Claudio Corrodi, University of Bern, Switzerland

Wednesday 12.07.2016, 11:30–12:00

Abstract: Debuggers are central tools in IDEs for inspecting and repairing software systems. However, they are often generic tools that operate on a low level of abstraction. Developers need to use simple breakpoint capabilities and interpret the raw data presented by the debugger. They are confronted with a large abstraction gap between application domain and debugger presentations. We propose an approach for debugging object-oriented programs, using expressive and flexible break- points that operate on sets of objects instead of a particular line of source code. This allows developers to adapt the debugger to their domain and work on a higher level of abstraction, which enables them to be more productive. We give an overview of the approach and demonstrate the idea with a simple use case, and we discuss how our approach differs from existing work.

Paper: pdf

Beyond Context-Oriented Software

Kim Mens, UCL, Belgium
Nicolas Cardozo, Universidad de los Andes, Colombia
Bruno Dumas, University of Namur, Belgium
Anthony Cleve, University of Namur, Belgium

Wednesday 12.07.2016, 12:00–12:30

Abstract: The last two decades have seen a lot of research on context- aware and context-oriented software development technologies, in different subfields of computer science. This research area is slowly starting to mature and researchers currently explore how to unify different solutions proposed in these subfields. We envision that within another decade some of these solutions will have made it into mainstream software development approaches, tools and environments. Most end-user software built by that time will be context-aware and able to adapt seamlessly to its context of use (devices, surrounding environment, but also to the user himself). But the transition from traditional to context-oriented software also requires a mindset shift in the heads of its users. If users are to accept adaptive systems, they need systems they feel in control of. Context-orientation should thus evolve to become less technology- and more user-centric, putting the user back in control. A first step is by providing good feedback to the user on when and what adaptations take place, and mechanisms to allow the user to partly control or undo certain adaptations, followed by easily usable and understandable customisation mechanisms dedicated to the end user. Eventually, when adaptive systems have become completely natural and adopted by end users, this will culminate in our vision where the user is fully in control of relevant features or adaptations of applications he is interested in, selected on-demand from online feature clouds, and integrated automatically into the running system.

Paper: pdf

Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License