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 machine learning, deep learning, cloud computing and Big data analytics. Many of these bugs are hidden not only in the software code but also in other software artifacts such as configuration files, training data, trained models, and deployment modules. Many of them are also non-deterministic and data-driven whereas the bugs are commonly logic-driven. Thus, the traditional debugging techniques that had been developed for the last 40 years might not be enough to tackle these emergent, complex bugs. In the RAISE lab, we study the bugs from various complex software systems including machine learning software. We attempt to (a) better understand the challenges of software debugging with a particular focus on bug/fault localization and bug reproduction that take up ~90% of the debugging time, and (b) design intelligent, explainable, cost-effective software solutions to overcome these challenges.

While finding and fixing 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 cool new features to their software on a regular interval. However, modifying an existing software is not always straight forward. 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 otfen fail to make the right search queries, and 73%--88% of their valuable development time is spent in the trials and errors during code search. 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).

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 thus ensuring the high quality of code reviews is 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 the 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 spent 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 (a) to find the right code reviewers, and (b) to help the reviewers improve their poor-quality code reviews.