events

On May 14th we’re discussing the second half of this long and dense paper 😃 (starting from 3️⃣ below) Everybody can join to listen & discuss, even if you haven’t read the paper! 😊 Ever wondered how to properly survey literature? Want to avoid these ‘you should have done this differently’ comments on the next one you submit? Or are you an expert in literature surveys and want to share your awesome knowledge with us?

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.

Ever wondered how to properly survey literature? Want to avoid these ‘you should have done this differently’ comments on the next one you submit? Or are you an expert in literature surveys and want to share your awesome knowledge with us? Join the next SERG Reading Club📚📖! On Thursday, May the 7th, 14:00 - 15:00 we come together on Zoom to discuss: “Guidelines for performing Systematic Literature Reviews in Software Engineering” by Barbara Kitchenham (2007 Version).

In this talk, I will be discussing the challenges of logging an enterprise system in the context of Adyen, our industry partner, and talk about my ongoing work. Log data plays a key role in many important analysis tasks that critical for business such as auditing, application performance monitoring (APM), and root cause analysis (RCA). However, developing and maintaining logging code is hard: developers need to choose an appropriate log level, message format, variables that must be logged, and where to place log statements.

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.