Software maintenance can be quite expensive in practice. Researchers actually estimate that 60% of the costs of a software is dedicated to its evolution, e.g., enhancements and bug fixes.

Can we help developers in maintain their software? To that aim, I focus my research on three topics:

  • Code quality: can we help developers in writing more maintainable and easy-to-evolve code? can we help developers in detecting problematic (i.e., hard to read, more prone to changes) pieces of code?
  • Software testing: can we help developers in testing their software? can we help developers in maintaining the large automated test suites they write?
  • Runtime monitoring: can we help developers in monitoring their systems?

TU Delft MSc students: Are you looking for thesis ideas on these topics? Message me.

Code quality

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:

  • 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.
    Proposes a set of smells that can exist in MVC applications. Empirically validates the change- and defect-proneness of classes affected by the smell as well as their evolution over time. Proposes SpringLint, a tool that automatically detects these smells in Spring MVC applications.
    [Video summary] [Vídeo em português]

  • 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
    We examine developers’ perceptions on JavaScript linters. Our results provide practitioners with reasons for using linters in their JavaScript projects as well as several configuration strategies and their advantages. We also provide a list of linter rules that are often enabled and disabled, which can be interpreted as the most important rules to reason about when configuring linters.

  • SATT: Tailoring Code Metric Thresholds for Different Software Architectures
    Maurício Aniche, Christoph Treude, Andy Zaidman, Arie van Deursen, Marco Gerosa.
    16th IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM), 2016.
    Analyzes the distribution of different code metrics as to understand how traditional threshold derivation techniques behave among different architectural roles. Proposes SATT, an approach that derives specific thresholds for specific architectural roles of the system architecture.

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:

  • When Testing Meets Code Review: Why and How Developers Review Tests
    Davide Spadini, Maurício Aniche, Margaret Storey, Magiel Bruntink, Alberto Bacchelli
    40th International Conference on Software Engineering (ICSE), 2018.
    We studied the effort that developers put in reviewing test code (when compared to production code). We observed that developers tend to give more attention to production code when both are on the same patch, that developers mostly point code quality issues in their review (rather than missing tests, as they claim they do), and that review tools do not really help them in reviewing both the test and the class under test.
    [Video summary] [Vídeo em português]

  • 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.
    We propose a search-based algorithm that generates test data for a given SQL query, using MC/DC coverage criteria. Our approach is able to generate test data for more than 90% of our dataset, and it is highly superior to others (as they tend to model the problem as CSP, which fails in most complex queries). The tool is available in our GitHub.
    [Video summary] [Vídeo em português]

  • To Mock or Not To Mock? An Empirical Study on Mocking Practices
    Davide Spadini, Maurício Aniche, Magiel Bruntink, Alberto Bacchelli.
    IEEE 14h International Conference on Mining Software Repositories (MSR), 2017.
    Empirically analyzes the usage of mocks in four different software systems. Discusses strategies taken by developers to decide whether to mock a class as well as challenges they face when mocking.

Runtime monitoring

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. This research is done together with Adyen B.V., a large-scale payment company that provides services for more than 4,500 companies all around the world.

Key publications:

  • 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
    40th International Conference on Software Engineering (ICSE) - Industry Track, 2018.
    We studied and catalogued the common mistakes that developers make when trying to integrate to a (complex) web API after analysis 2MM exception log entries. We hope developers will avoid such mistakes from now on. We also provide suggestions for API developers and researchers on how to facilitate such process.

  • An Experience Report on Applying Passive Learning in a Large-Scale Payment Company
    Rick Wieman, Maurício Aniche, Willem Lobbezoo, Sicco Verwer, Arie van Deursen.
    33rd IEEE International Conference on Software Maintenance and Evolution (ICSME), 2017.
    Describes our experience after applying passive learning techniques in log files to model the behavior of a real-world embedded system. Our industry partner was able to find and fix bugs due to our findings. Proposes a set of lessons learned as well as suggestions on how to apply passive learning in the real world.