Software maintenance can be quite expensive in practice. Researchers estimate that 60% of the costs of a software is dedicated to its evolution, e.g., enhancements and bug fixes. Therefore, tools and techniques that help developers in better maintaining their software systems are of utmost importance to our society.

To that aim, I focus my research on three topics:

  • Software maintenance, refactoring, and evolution: can we help developers in writing more maintainable and easy-to-evolve code? Can we help developers in better comprehending the source code of complex systems? Can we help developers in detecting problematic pieces of code that need to be refactored? Can we help them in refactor their code?

  • Software testing: Can we help developers in testing their software? Can we help developers in maintaining the large automated test suites they write?

  • Software monitoring and log analysis: Can we help developers in monitoring their systems? How can we leverage log data to give developers insights about how their systems behave in production?

TU Delft MSc students: Are you looking for thesis ideas on these topics? Read my guidelines for MSc students and message me.

(Dutch) industrial partners: If you are interested in partnering up for research in any of these topics, just message me. See my list of publications with industry.

Software maintenance (evolution, refactoring, comprehension)

Lots of research have been focusing on high-level quality measurements, such as coupling and cohesion in object-oriented systems. My research focuses on understanding and detecting what constitutes hard-to-maintain pieces of code in specific architectures, such as web and mobile applications. A key characteristic of my research is that it takes the context of the system as a fundamental part of the model.

Key publications:

Search-Based Software Re-Modularization: A Case Study at Adyen Casper Schröder, Adriaan van der Feltz, Annibale Panichella, Maurício Aniche IEEE/ACM 43rd International Conference on Software Engineering: Software Engineering in Practice (ICSE-SEIP), 2021
Deciding what constitutes a single module, what classes belong to which module or the right set of modules for a specific software system has always been a challenging task. The problem is even harder in large-scale software systems composed of thousands of classes and hundreds of modules. Over the years, researchers have been proposing differen...
The Effectiveness of Supervised Machine Learning Algorithms in Predicting Software Refactoring Maurício Aniche, Erick Maziero, Rafael Durelli, Vinicius Durelli Transactions on Software Engineering (TSE), 2020
Refactoring is the process of changing the internal structure of software to improve its quality without modifying its external behavior. Before carrying out refactoring activities, developers need to identify refactoring opportunities. Currently, refactoring opportunity identification heavily relies on developers’ expertise and intuition. In t...
When Testing Meets Code Review: Why and How Developers Review Tests Davide Spadini, Maurício Aniche, Margaret-Anne Storey, Magiel Bruntink, Alberto Bacchelli 40th International Conference on Software Engineering (ICSE), 2018
Automated testing is considered an essential process for ensuring software quality. However, writing and maintaining high-quality test code is challenging and frequently considered of secondary importance. For production code, many open source and industrial software projects employ code review, a well-established software quality practice, but ...
The Adoption of JavaScript Linters in Practice: A Case Study on ESLint Kristín Fjóla Tómasdóttir, Maurício Aniche, Arie van Deursen Transactions on Software Engineering (TSE), 2018
A linter is a static analysis tool that warns software developers about possible code errors or violations to coding standards. By using such a tool, errors can be surfaced early in the development process when they are cheaper to fix. For a linter to be successful, it is important to understand the needs and challenges of developers when using ...
Code smells for Model-View-Controller architectures Maurício Aniche, Gabriele Bavota, Christoph Treude, Marco Gerosa, Arie van Deursen Empirical Software Engineering Journal (EMSE), 2017
Previous studies have shown the negative effects that low-quality code can have on maintainability proxies, such as code change- and defect-proneness. One of the symptoms for low-quality code are code smells, defined as sub-optimal implementation choices. While this definition is quite general and seems to suggest a wide spectrum of smells that ...

Software testing

In modern software development, testing is code. My research focuses on helping developers in understanding what are the characteristics of a maintainable test code suite.

Key publications:

How Developers Engineer Test Cases: An Observational Study Maurício Aniche, Christoph Treude, Andy Zaidman Non peer-reviewed version (under submission), 2021
One of the main challenges that developers face when testing their systems lies in engineering test cases that are good enough to reveal bugs. And while our body of knowledge on software testing and automated test case generation is already quite significant, in practice, developers are still the ones responsible for engineering test cases manua...
Comprehending Test Code: An Empirical Study Chak Shun Yu, Christoph Treude, Maurício Aniche 35th IEEE International Conference on Software Maintenance and Evolution (ICSME), 2019
Developers spend a large portion of their time and effort on comprehending source code. While many studies have investigated how developers approach these comprehension tasks and what factors influence their success, less is known about how developers comprehend test code specifically, despite the undisputed importance of testing. In this paper...
Mock objects for testing java systems: Why and how developers use them, and how they evolve Davide Spadini, Maurício Aniche, Magiel Bruntink, Alberto Bacchelli Empirical Software Engineering (EMSE), 2018
When testing software artifacts that have several dependencies, one has the possibility of either instantiating these dependencies or using mock objects to simulate the dependencies’ expected behavior. Even though recent quantitative studies showed that mock objects are widely used both in open source and proprietary projects, scientific knowled...
Search-Based Test Data Generation for SQL Queries Jeroen Castelein, Maurício Aniche, Mozhan Soltani, Annibale Panichella, Arie van Deursen 40th International Conference on Software Engineering (ICSE), 2018
Database-centric systems strongly rely on SQL queries to manage and manipulate their data. These SQL commands can range from very simple selections to queries that involve several tables, subqueries, and grouping operations. And, as with any important piece of code, developers should properly test SQL queries. In order to completely test a SQL q...

Software monitoring and log analysis

Testing might not be enough in large-scale complex systems. Thus, monitoring is fundamental to their maintenance. My research focuses on better understanding and providing tools for modern software monitoring.

Key publications:

An Exploratory Study of Log Placement Recommendation in an Enterprise System Jeanderson Cândido, Jan Haesen, Maurício Aniche, Arie van Deursen Mining Software Repositories Conference (MSR), 2021
Logging is a development practice that plays an important role in the operations and monitoring of complex systems. Developers place log statements in the source code and use log data to understand how the system behaves in production. Unfortunately, anticipating where to log during development is challenging. Previous studies show the feasibili...
Monitoring-Aware IDEs Jos Winter, Maurício Aniche, Jürgen Cito, Arie van Deursen 27th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE), 2019
Engineering modern large-scale software requires software developers to not solely focus on writing code, but also to continuously examine monitoring data to reason about the dynamic behavior of their systems. These additional monitoring responsibilities for developers have only emerged recently, in the light of DevOps culture. Interestingly, so...
An Exploratory Study on Faults in Web API Integration in a Large-Scale Payment Company Joop Aué, Maurício Aniche, Maikel Lobbezoo, Arie van Deursen ICSE-SEIP '18: 40th International Conference on Software Engineering: Software Engineering in Practice Track, 2018
Service-oriented architectures are more popular than ever, and increasingly companies and organizations depend on services offered through Web APIs. The capabilities and complexity of Web APIs differ from service to service, and therefore the impact of API errors varies. API problem cases related to Adyen’s payment service were found to have dir...