2018

  • 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
    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.

  • PyDriller: Python Framework for Mining Software Repositories
    Davide Spadini, Maurício Aniche, Alberto Bacchelli
    26th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE)
    We propose PyDriller, a tool that helps researchers in doing mining software repositories. The tool is freely available on GitHub.

  • How Modern News Aggregators Help Development Communities Shape and Share Knowledge
    Maurício Aniche, Christoph Treude, Igor Steinmacher, Igor Wiese, Gustavo Henrique Lima Pinto, Margaret-Anne Storey, Marco Aurélio Gerosa
    40th International Conference on Software Engineering (ICSE)
    We studied how and why developers have been using modern news aggregators, such as Reddit and HackerNews. Our paper provides cues for developers to maximize their benefits when using such tools, as well as for tool builders on how to improve such aggregators.

  • Understanding Developers’ Needs on Deprecation as a Language Feature
    Anand Ashok Sawant, Maurício Aniche, Arie van Deursen, Alberto Bacchelli
    40th International Conference on Software Engineering (ICSE)
    We investigated how developers perceive the deprecation mechanism and whether the new JEP covers all their needs. We ended up proposing three further enhancements that we believe languages should adopt.

  • 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)
    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)
    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]

  • 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
    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.

  • Unusual Events in GitHub Repositories
    Christoph Treude, Larissa Leite, Maurício Aniche
    Journal of Systems and Software (JSS)
    Several different events may happen in a GitHub repository. Which ones should developers care about? Probably the unusual ones. We devised a comprehensive list of unusual events and validated their usefulness with 140 developers.

  • Where does Google find API documentation?
    Christoph Treude, Maurício Aniche
    2nd International Workshop on API Usage and Evolution
    API documentation are spread everywhere on the internet. We understand the document landscape by analyzing where Google searches for the elements of 10 popular APIs. We found that their documentation is widely dispersed among many sources, that GitHub and Stack Overflow play a prominent role among the search results, and that most sources are quick to document new API functionalities.

2017

  • Code smells for Model-View-Controller architectures
    Maurício Aniche, Gabriele Bavota, Christoph Treude, Marco Gerosa, Arie van Deursen.
    Empirical Software Engineering Journal
    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]

  • Why and How JavaScript Developers Use Linters
    Kristín Fjóla Tómasdóttir, Maurício Aniche, Arie van Deursen.
    32nd IEEE/ACM International Conference on Automated Software Engineering (ASE)
    Discusses the current reasons of why JavaScript developers use linters as well as most common strategies to configure them. Results derived after 15 interviews with developers from known-well large JavaScript systems.

  • 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)
    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.

  • 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)
    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.

  • A Collaborative Approach to Teaching Software Architecture
    Arie van Deursen, Maurício Aniche, Joop Aué, Rogier Slag, Michael de Jong, Alex Nederlof, Eric Bouwers.
    48th ACM Technical Symposium on Computer Science Education (SIGCSE)
    Describes the Software Architecture course given to the MSc students of Computer Science at TU Delft. Students collaboratively write a book about several open source systems that they analyze throughout the course.

2016

  • A Validated Set of Smells in Model-View-Controller Architecture
    Maurício Aniche, Gabriele Bavota, Christoph Treude, Marco Gerosa, Arie van Deursen.
    32th International Conference on Software Maintenance and Evolution (ICSME)
    First step of this research, that was evolved in 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. Proposes SpringLint, a tool that automatically detects these smells in Spring MVC applications.

  • Developers’ Perceptions on Object-Oriented Design and System Architecture
    Maurício Aniche, Christoph Treude, Marco Gerosa.
    30th Brazilian Symposium on Software Engineering (SBES)
    Investigates whether developers from within the same development team perceive differently the responsibilities of each architectural role (e.g., what kind of code should be placed in a Controller class?)

  • 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)
    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.

  • Context-Based Code Quality Assessment
    Maurício Aniche
    PhD thesis at University of São Paulo
    Should metrics and code smells be generic? What happens if we add context to them?

2015

2013

2010