Research

Most of our work comes back to modular reasoning: the idea that you should be able to understand and change one part of a software system without having to understand all of it. We design languages and interfaces that support modular reasoning, and we have built infrastructure that runs a software analysis across very large collections of code. More recently we have been applying the same ideas to AI, studying how software engineering can make deep learning and other AI-enabled systems more reliable.

View our work on Google Scholar →

Modularity and Modular Reasoning

We design languages and interfaces that let developers reason about one part of a program without tracing through the rest. This work includes aspect-oriented design, Classpects, the Ptolemy language with its quantified, typed events, capsule-oriented programming in Panini, and translucid contracts for modular verification.

Projects

• Panini: capsule-oriented programming for modular reasoning about concurrency.
• Ptolemy: an event-based language with quantified, typed events and translucid contracts.
• Eos: an aspect-oriented extension for C# that unifies aspects and objects as classpects.
• Nu: intermediate-language and virtual-machine support for aspect-oriented features.
• Sapha: automatic thread-to-core assignment for heterogeneous multi-core processors.
• Slede: specification and verification of cryptographic protocols for sensor networks.
• Tisa: trustworthy non-functional guarantees for service-oriented architectures.
• Frances: teaching tools for code generation and computer architecture.

Representative and recent publications

• An Experiential Introduction to Principles of Programming Languages (MIT Press, 2022)
• Modular software design with crosscutting interfaces (IEEE Software, 2006)
• Information-hiding interfaces for aspect-oriented design (ESEC/FSE 2005)
• Classpects: unifying aspect- and object-oriented language design (ICSE 2005)
• Ptolemy: a language with quantified, typed events (ECOOP 2008)

More publications

• Eos: instance-level aspects for integrated system design (ESEC/FSE 2003)
• Modular aspect-oriented design with XPIs (ACM TOSEM, 2010)
• Translucid contracts: modular verification for aspect-oriented interfaces (AOSD 2011)
• Nu: a dynamic aspect-oriented intermediate language model and virtual machine (AOSD 2008)
• Capsule-oriented programming (ICSE 2015)
• Panini: a concurrent programming model for pervasive and oblivious interference (Modularity 2015)
• AspectJML: modular specification and runtime checking for crosscutting interfaces (Modularity 2014)
• Aspect language features for concern coverage profiling (AOSD 2005)
• Understanding aspects via implicit invocation (ASE 2004)
• Design pattern implementations in Eos (PLoP 2007)

Selected funding

• NSF CAREER: On Mutualism of Modularity and Concurrency Goals (2009–2016)
• NSF SHF Small: Capsule-oriented Programming (2014–2018)
• NSF SHF Small (Collaborative): Balancing Expressiveness and Modular Reasoning for Aspect-Oriented Programming (2010–2013)

Analyzing Software at Scale, with Boa

With Boa, we wanted a way to write a software-analysis task once and run it across a very large collection of repositories. Boa is a language and the supporting infrastructure for doing this, and researchers have used it to study how software is written and how it changes across hundreds of thousands of projects.

Projects

• Boa: a language and infrastructure that expresses software-analysis tasks modularly so they run across hundreds of thousands of open-source projects.

Representative and recent publications

• Boa: a language and infrastructure for analyzing ultra-large-scale software repositories (ICSE 2013)
• Boa: ultra-large-scale software repository and source-code mining (ACM TOSEM, 2015)
• Are code examples on Stack Overflow reliable? A study of API misuse (ICSE 2018)
• A study of repetitiveness of code changes in software evolution (ASE 2013)
• Mining billions of AST nodes to study Java language features (ICSE 2014)

More publications

• Mining preconditions of APIs in large-scale code corpus (FSE 2014)
• Declarative visitors to ease fine-grained source code mining (GPCE 2013)
• Boa meets Python: a Boa dataset of data science software (MSR 2019)
• Detecting and correcting misclassified sequences in large-scale public sequencing data (Bioinformatics, 2020)

Selected funding

• NSF CI-EN: Boa: Enhancing Infrastructure for Studying Software and its Evolution at a Large Scale (2015–2018)
• NSF CCRI: Boa 2.0: Enhancing Infrastructure for Studying Software and its Evolution at a Large Scale (2021–2024)
• NSF SHF Large (Collaborative): Inferring Software Specifications from Open-Source Repositories (2015–2018)
• NSF EAGER: Boa: A Community Research Infrastructure for Mining Software Repositories (2013–2015)

Modular and Dependable AI

More recently we have been applying these ideas to AI-enabled systems, and this is where most of our current work sits. One thread treats a trained model as something that can be taken apart: we decompose deep neural networks, including convolutional and recurrent networks, into modules that can be tested, reused, or replaced without retraining the whole model, which lowers the cost and energy of building and updating AI. A second thread is trustworthy AI. We study how deep learning systems fail, locate and repair faults in them, check and improve fairness across machine-learning pipelines, bring design-by-contract ideas to model training and inference, and study the dependability of whole data-science lifecycles. The aim is AI software that teams can build and rely on.

Projects

• Modular Deep Learning: decomposing deep neural networks into reusable, replaceable modules.
• Fault Localization for Deep Learning: pinpointing where deep-learning models go wrong and cutting the cost of debugging them; a collaborative award with Mohammad Wardat (Oakland PI).
• Dependable Data Science (D4): understanding and reducing risk across the entire data-science lifecycle.
• LLM-based Program Analysis and Repair: agent-oriented and analysis-driven techniques that localize design issues, repair data-driven errors, and test AI systems.

Representative and recent publications

• RefineAct: automatic runtime verification of LLM agent actions (ASE 2026)
• IRepair: an intent-aware approach to repair data-driven errors in large language models (FSE 2025)
• DeepLocalize: fault localization for deep neural networks (ICSE 2021)
• A comprehensive study on deep learning bug characteristics (ESEC/FSE 2019)
• Fairify: fairness verification of neural networks (ICSE 2023)
• Design by contract for deep learning APIs (ESEC/FSE 2023)

More publications

• Fair preprocessing: compositional fairness of data transformers in ML pipelines (ESEC/FSE 2021)
• Repairing deep neural networks: fix patterns and challenges (ICSE 2020)
• Inferring data preconditions from deep learning models for trustworthy prediction in deployment (ICSE 2024)
• What kinds of contracts do ML APIs need? (EMSE 2023)
• Do the machine learning models on a crowd-sourced platform exhibit bias? (ESEC/FSE 2020)
• On decomposing a deep neural network into modules (ESEC/FSE 2020)
• Decomposing convolutional neural networks into reusable and replaceable modules (ICSE 2022)
• The art and practice of data science pipelines (ICSE 2022)
• DeepDiagnosis: diagnosing faults and recommending fixes in deep learning programs (ICSE 2022)
• Towards understanding fairness and its composition in ensemble machine learning (ICSE 2023)
• 23 shades of self-admitted technical debt in machine learning software (ESEC/FSE 2022)
• Mutation-based fault localization of deep neural networks (ASE 2023)
• An LLM-based agent-oriented approach for automated code design issue localization (ICSE 2025)
• Mock deep testing: toward separate development of data and models for deep learning (ICSE 2025)

Selected funding

• NSF HDR TRIPODS: D4 (Dependable Data-Driven Discovery) Institute (2019–2023)
• NSF SHF Small: More Modular Deep Learning (2022–2025)
• NSF SHF Small (Collaborative): Fault Localization for Deep Learning (2025–2028)