lunch-talks

The Delta-Maintainability Model (DMM) offers a methodology for assessing the way an individual commit affects the maintainability of a system. In a nutshell, the DMM measures the proportion of low-risk change in a commit. The resulting value ranges from 0.0 (all changes are risky) to 1.0 (all changes are low risk). It rewards making methods better, and penalizes making things worse. Recently, we implemented a simple version of the DMM as part of PyDriller, the open source git repository mining tool.

Dynamic programming languages, such as Python and JavaScript, enable fast prototyping. This leads to unexpected runtime behavior, suboptimal IDE support, and type errors. To mitigate these issues, dynamic languages added support for type annotations, which allows developers to specify types for the variables. However, the process of manually annotating codebases is cumbersome and error-prone. Aside from the traditional static analyzers, Machine Learning (ML) models can be employed to aid the type annotation process.

Search-based test data generation approaches have come a long way over the past few years, but these approaches still have some limitations when it comes to exercising specific behavior for triggering particular kinds of faults (e.g., crashes or specific types of integration between classes/modules). In this thesis, we are investigating new fitness functions and evolutionary-based algorithms and techniques to tackle these limitations. We have defined multiple novel approaches for crash reproduction and class integration testing.

In this talk, I will present a technique related to the test of Software Product Lines. This problem is hard due to (i) the high number of variants that are usually considered in SPLs, and (ii) the new dimension added to the tests for the assessment of performances (i.e., providing inputs that may impact the performances of the variants). Thus, it is necessary to try to reduce the number of inputs to assess the performances of the different variants, which, in the end, may have an impact on the choice made by the end-users for choosing one specific variant.

This presentation will be about the FASTEN project and ongoing research that builds the basis of FASTEN. Slides are available here. The main goal of the FASTEN project is to make package management more intelligent. Incidents like leftpad (A significant portion of the Internet has been broken by removing a package from a package manager) proved that the current way of managing packages has some flaws. FASTEN wants to mitigate such flaws by enriching package managers with method-level information.

You will hear the presentation I gave for my master thesis defense in Munich :) Slides are available here. Continuous integration produces detailed logs about the status and results of the various tools involved in the build. These build logs are a valuable data source for developers and researchers to inspect test results, to check the duration of build steps and to understand the cause of a build failure. However, build logs are very verbose, at best semi-structured and their structure differs highly between projects.

Robbert Krebbers discusses his ongoing effort to scale up formal verification techniques to challenging programming paradigms like concurrency in real programmling languages like C and Rust by developing mathematical foundations and usable tool implementations.

“Great software doesn’t come from tools, it comes from people.” During software development and maintenance, companies continually deal with issues related to the management of human resources. Such factors as team dynamics, experience, seniority, training, and office culture could influence the success of a company as well as the quality of software produced. Hence, human factors should be carefully considered and monitored since they are an integral part of the software process and could lead to dangerous consequences (e.

A Critical Comparison of Issue- and Risk-based Approaches to Assess Technical Debt In this lunch talk, we are going to present results from a recent study where we compared issue-based and risk-based measurements approaches to detect technical debt. We performed an empirical study on data gathered over 30,000 commits, both with risk- and issue-based technical debt, over 12 Apache Software Foundation projects. Further, we conducted a qualitative study on a subset of two of the projects to understand the benefits for the end-user when using both approaches together.