Automated software debugging

Software bugs and failures are inevitable! In 2017 alone, 606 software bugs cost the global economy $1.7 trillion+, with 3.7 billion people affected and 314 companies impacted! While these bugs are ubiquitous, new classes of bugs are emerging due to the adoption of popular but highly complex technologies such as Deep learning, Cloud computing, and Simulation models. Many of these bugs are hidden not only in the software code but also in other artifacts such as configuration files, training data, trained models, deployment modules, and even simulation models. Many of them are also non-deterministic and data-driven whereas the traditional software bugs are commonly logic-driven. Thus, the traditional debugging techniques that have been developed for the last 40+ years might not be enough to tackle these emerging, complex bugs. In the RAISE lab, we study the bugs from various complex software systems including machine learning software and simulation modelling software. We attempt to (a) better understand the challenges of software debugging with a particular focus on bug/fault localization, bug understanding, and bug reproduction that take up ~90% of the debugging time, and (b) design intelligent, explainable, cost-effective software solutions to overcome these challenges.

Automated code search

While finding and correcting bugs in the software is crucial, the majority of the maintenance budget (e.g., 60%) is spent incorporating new features in the existing software. Once a software product is released, requests for new features from the users are very common. To stay competitive in the market, the developers must add new, attractive features to their software at regular intervals. However, modifying an existing software is not always straightforward. A developer must know (a) how to implement a new feature and (b) where to add this feature within the software code. Thus, as a part of feature addition, developers often search for reusable code snippets not only in the local codebase but also in the web. Unfortunately, they often fail to make the right search queries. According to existing surveys, they might even fail up to 73%-88% of the time, which is a significant waste of their valuable development time. With the growing interest in prompt engineering in the context of large language models, search queries have been never more important. In RAISE Lab, we develop state-of-the-art, intelligent tools and techniques that can (a) automatically construct appropriate search queries and (b) find the desired code not only from the local codebase but from the Internet-scale code repositories (e.g., GitHub, SourceForge).

Automated code review

Once software code is modified as a part of bug resolution or feature enhancement, the modified code must be checked for errors or quality issues. Code review has been a vital quality-control practice for the last 30+ years where software code is manually checked by code reviewers (i.e., expert developers) for hidden errors or quality issues. Finding the right reviewers and ensuring the high quality of code reviews are a challenging task. Large software companies typically have large, geographically distributed development teams, which contain a tremendous pool of expertise but are too big and diversified for manual assignment of review tasks. Incorrect selection of code reviewers not only delays the reviewing process but also leads to poor reviews. Poorly written reviews often contain inaccurate suggestions and suffer from a lack of clarity or empathy when pointing out mistakes in the software code, which makes the reviews ineffective. As a result, poor-quality reviews become a waste of valuable development effort. Even at Microsoft Corporation, where 50,000+ professional developers spend six hours every week reviewing each other’s code, ~35% of their code reviews are ineffective in improving software quality. Thus, modern code review needs appropriate tools that can make it more productive and more efficient. In RAISE Lab, we design intelligent tools and techniques to (a) automatically find the right code reviewers, and (b) automatically improve poor-quality code reviews.