Research
Focus Areas
Programming Education at Scale
Instructors can see the code a class turns in, but not how any of it got written. We build tools that make a whole class's problem-solving process visible in time to act on it -- including how students use AI.
People:
Publications:
- Editrail: Understanding AI Usage by Visualizing Student-AI Interaction in Code
- CodeStream: Augmenting Timelines with Code Annotation for Navigating Large Coding Histories
- SPARK: Real-Time Monitoring of Multi-Faceted Programming Exercises
- Co-Advisor: Learning Programming Strategies in Context
- CFlow: Supporting Semantic Flow Analysis of Students' Code in Programming Problems at Scale
- RunEx: Augmenting Regular-Expression Code Search with Runtime Values
- VizProg: Identifying Misunderstandings by Visualizing Students' Coding Progress
- PuzzleMe: Leveraging Peer Assessment for In-Class Programming Exercises
- EdCode: Towards Personalized Support at Scale for Remote Assistance in CS Education
Web Automation and Programming by Demonstration
People want to automate work on websites they do not control. We study what makes that hard, and build tools that let them demonstrate what they want and then see what was inferred from the demonstration.
People:
Publications:
- Multi-Click: Cross-Tab Web Automation via Action Generalization
- ScrapeViz: Hierarchical Representations for Web Scraping Macros
- ParamMacros: Creating UI Automation Leveraging End-User Natural Language Parameterization
- Understanding the Challenges and Needs of Programmers Writing Web Automation Scripts
Building and Testing Interactive Interfaces
Interactive behavior is scattered across event handlers, which makes it hard to write, hard to read, and hard to test. We design notations, editors, and prototyping tools for expressing behavior directly, and techniques for finding where an interface breaks.
People:
Publications:
- Simulating Human Cursor Trajectories for Path-Sensitive GUI Evaluation
- CoCapture: Effectively Communicating UI Behaviors on Existing Websites by Demonstrating and Remixing
- Improving Crowd-Supported GUI Testing with Structural Guidance
- Implementing Multi-Touch Gestures with Touch Groups and Cross Events
- Expresso: Building Responsive Interfaces with Keyframes
- InterState: A Language and Environment for Expressing Interface Behavior
- ConstraintJS: Programming Interactive Behaviors for the Web by Integrating Constraints and States
- Playbook: Revision Control & Comparison for Interactive Mockups
- How to Support Designers in Getting Hold of the Immaterial Material of Software
- FireCrystal: Understanding Interactive Behaviors in Dynamic Web Pages
Explaining Code and Capturing Process
Code records the result of a decision but not the reasoning behind it. We build editors, notebooks, and visualizations that capture the intent, discussion, and process behind an artifact, and keep them attached to it.
People:
Publications:
- ConvoMap: Interactive Visualizations for Exploring Complex Conversations in Multi-Agent Systems
- Colaroid: A Literate Programming Approach for Authoring Explorable Multi-Stage Tutorials
- Think-Aloud Computing: Supporting Rich and Low-Effort Knowledge Capture
- Callisto: Capturing the "Why" by Connecting Conversations with Computational Narratives
- How Data Scientists Use Computational Notebooks for Real-Time Collaboration
- Creating Guided Code Explanations with chat.codes
- Codelets: Linking Interactive Documentation and Example Code in the Editor
Accessibility of Programming and the Web
Programming tools are visual by default, which shapes who can contribute to software and in what role. We study how blind and low-vision developers actually work, alone and on mixed-ability teams, and what their tools would have to change.
People:
Publications:
- Towards Inclusive Source Code Readability Based on the Preferences of Programmers with Visual Impairments
- UI Development in Mixed-Ability Software Engineering Teams
- Accessibility of UI Frameworks and Libraries for Programmers with Visual Impairments
- Understanding Accessibility and Collaboration in Programming for People with Visual Impairments
- Explore, Create, Annotate: Designing Digital Drawing Tools with Visually Impaired People
- Arboretum and Arbility: Improving Web Accessibility Through a Shared Browsing Architecture
Immersive Authoring
Building 3D content means describing spatial things through a 2D screen. We build tools for authoring, versioning, and co-creating scenes with generative models from inside VR.
People:
Publications:
- VRCopilot: Authoring 3D Layouts with Generative Models in VR
- VRGit: A Version Control System for Collaborative Content Creation in Virtual Reality
- FlowMatic: An Immersive Authoring Tool for Creating Interactive Scenes in Virtual Reality
- Studying the Benefits and Challenges of Immersive Dataflow Programming
On-Demand Help for Programmers
A stuck programmer needs a helper who already has their context. We built systems that package that context, route it to an expert, a crowd, or a program synthesizer, and get the answer back into the editor -- mostly between 2016 and 2020.
People:
All Publications
UIST 2026
-
Editrail: Understanding AI Usage by Visualizing Student-AI Interaction in Code
Programming instructors have diverse philosophies about integrating generative AI into their classes. Some encourage students to use AI, while others restrict or forbid it. Regardless of their approach, all instructors benefit from understanding how their students actually use AI while writing code. Such insight hel...
CHI 2026
-
CodeStream: Augmenting Timelines with Code Annotation for Navigating Large Coding Histories
Introduces a visualization system that helps instructors interpret students’ keystroke-level coding histories. While traditional timelines show when and where edits occurred, they do not reveal what changed. CodeStream augments timelines with zoomable code annotations, multi-level structural summaries, and a cumulative effort heatmap, allowing instructors to see both the content and intensity of edits without constant context switching.
VL/HCC 2025
-
Co-Advisor: Learning Programming Strategies in Context
A context-aware learning tool that helps programmers develop strategic problem-solving skills like debugging and program design. Integrated with Visual Studio Code, it analyzes the learner's code, runtime state, and actions to recommend expert strategies tailored to a developer's context. As learners follow these strategies, Co-Advisor provides real-time feedback to make it easier for developers to understand strategic knowledge in context.
-
ConvoMap: Interactive Visualizations for Exploring Complex Conversations in Multi-Agent Systems
A visualization system that helps developers understand and debug large collections of conversations between AI agents in Multi-Agent Systems (MASs). ConvoMap contains visualizations to show the flow of interactions between agents and the topics covered. ConvoMap allows MAS developers to spot behavioral patterns, trace errors, and compare outcomes at scale.
-
SPARK: Real-Time Monitoring of Multi-Faceted Programming Exercises
A dashboard for programming instructors that lets them monitor student progress on complex, multi-step programming exercises. SPARK lets instructors define checkpoints, automatically generates tests for each step, and visualizes progress across students. SPARK also enables inspection of intermediate outputs and runtime states to reveal common challenges and misconceptions.
UIST 2025
-
Multi-Click: Cross-Tab Web Automation via Action Generalization
Proposes "action generalization"---a technique for applying the same action across multiple contexts automatically. Multi-click lets users select a "generalization strategy" to determine which elements a given action (e.g., click or text entry) will apply to within a given page or across multiple tabs. Unlike prior web automation tools, multi-click works at the *interaction* level, rather than requiring a separate script representation of automation macros, which can improve the directness and understandability of bulk actions.
UIST 2024
-
VRCopilot: Authoring 3D Layouts with Generative Models in VR
A mixed-initiative tool for immersive 3D layout design in VR. It integrates generative AI to assist users in co-creating room layouts using voice commands, multimodal interactions, and wireframe-based representations. VRCopilot supports three modes: manual creation, automatic AI generation, and scaffolded creation with wireframes, balancing user control and automation.
VL/HCC 2024
-
ScrapeViz: Hierarchical Representations for Web Scraping Macros
A programming-by-demonstration tool that helps users create and visualize web scraping macros across multiple pages. ScrapeViz offers a visual storyboard of scraping behaviors, making it easier to understand, trace data sources, and identify errors.
L@S 2024
-
CFlow: Supporting Semantic Flow Analysis of Students' Code in Programming Problems at Scale
Introduces CFlow, a system for visualizing and analyzing large numbers of student code submissions to help instructors understand common mistakes and patterns. CFlow uses semantic labeling and code structure analysis to cluster code lines across submissions and present them in a visualization that resembles a single code sample, allowing instructors to see the overall semantic flow while still being able to dive into individual submissions.
CHI 2024
-
Towards Inclusive Source Code Readability Based on the Preferences of Programmers with Visual Impairments
Explores the code readability preferences of blind and visually impaired (BVI) developers and how they differ from sighted developers, through a qualitative study. Contributes an inclusive taxonomy for code readability and recommendations for programming tools, code standards, and languages to better support BVI developers.
VL/HCC 2023
-
RunEx: Augmenting Regular-Expression Code Search with Runtime Values
A system that improves code search by augmenting regular expressions with the ability to specify constraints on runtime values of specific expressions.
CHI 2023
-
Colaroid: A Literate Programming Approach for Authoring Explorable Multi-Stage Tutorials
Colaroid is an extension to the Visual Studio Code IDE that makes it easier to create mutli-step tutorials about a large code sample. Developers can write their code in the IDE and as they are writing their code, Colaroid allows them to divide their work into steps. Colaroid tutorials are augmented computational notebooks, where snippets and outputs represent a snapshot of a project, with source code differences highlighted, complete source code context for each snippet, and the ability to load and tinker with any stage of the project in a linked IDE.
-
VizProg: Identifying Misunderstandings by Visualizing Students' Coding Progress
VizProg is a tool that allows instructors of large programming classes to monitor students' progress at scale. It represents students' code in a 2D map where dots representing students move further to the right as they get closer to a correct solution. VizProg uses vertical space to represent different approaches to solving the problem (so students towards the bottom of the map are using a different approach than students at the top of the map).
-
VRGit: A Version Control System for Collaborative Content Creation in Virtual Reality
A version control system designed especially for Virtual Reality (VR). VRGit allows users to view and navigate the version history of a 3-D scene while immersed in VR. It also allows users to share and discuss history graphs collaboratively.
VL/HCC 2022
-
Accessibility of UI Frameworks and Libraries for Programmers with Visual Impairments
Two studies into the accessibility and challenges of developing interfaces with UI frameworks and libraries. Accessibility barriers in programming tools and UI frameworks can complicate the processes of writing UI code, debugging, testing, and collaborating with sighted colleagues. This paper presents recommendations grounded in empirical findings to improve the accessibility of frameworks and libraries.
-
ParamMacros: Creating UI Automation Leveraging End-User Natural Language Parameterization
ParamMacros is a PBD system where users specify a natural language question about a website. ParamMacros then leverages the DOM structure to help generalize and parameterize to similar natural language questions.
CSCW 2021
-
PuzzleMe: Leveraging Peer Assessment for In-Class Programming Exercises
A tool that enhances in-class programming exercises by (1) enabling students to write unit tests that can be shared with the rest of the class (and used to test other students' code), (2) enables peer code reviews where students are intelligently grouped with other students to perform code reviews. PuzzleMe is intended for introductory classes and also includes a design to make testing more lightweight.
-
Understanding Accessibility and Collaboration in Programming for People with Visual Impairments
A study into how programmers with visual impairments work in the context of programming teams. We describe how some collaborative practices can impede collaboration and required invisible work and articulation work on the part of the programmers with visual impairments.
VL/HCC 2021
-
Understanding the Challenges and Needs of Programmers Writing Web Automation Scripts
Two studies to better understand the challenges of writing web automation code (particularly the kinds of context and feedback that are helpful when writing web automation code).
CHI 2021
-
CoCapture: Effectively Communicating UI Behaviors on Existing Websites by Demonstrating and Remixing
CoCapture is a tool for creating behavior mockups for websites in the later stage of UI development. Unlike most other prototyping tools, CoCapture assumes that a partially functional UI exists and allows designers to describe UI behaviors by creating mockups that modify the existing UI behaviors by demonstrating and remixing.
-
Think-Aloud Computing: Supporting Rich and Low-Effort Knowledge Capture
Introduces "think-aloud computing", an application of think-alouds where users are encourage to speak in order to capture process-related as they work. For example, it might capture design intent, to-do items, problems encountered, and more. We present a formative study of think-aloud computing and a prototype of a tool to support think-aloud computing.
UIST 2020
-
FlowMatic: An Immersive Authoring Tool for Creating Interactive Scenes in Virtual Reality
FlowMatic allows users to users to specify interactive behaviors (how to respond to users) while immersed in Virtual Reality (VR). It adapts dataflow programming to allow programming primitives to be modified through direct manipulation and provides immediate feedback.
VL/HCC 2020
-
A Hybrid Crowd-Machine Workflow for Program Synthesis
BashOn introduces a crowdsourcing approach to help make program synthesis systems more robust, reliable, and trustworthy, and reduces the cost of downstream data collection for training a program synthesis system.
-
EdCode: Towards Personalized Support at Scale for Remote Assistance in CS Education
EdCode applies a semi-asychronous on-demand help seeking model in a learning setting, aiming towards provide more personalized support at scale.
IMX 2020
-
Sifter: A Hybrid Workflow for Theme-based Video Curation at Scale
Sifter improves the video curation process by combining automated techniques with a human-powered two-stage pipeline that browses, selects, and reaches an agreement.
CHI 2020
-
Callisto: Capturing the "Why" by Connecting Conversations with Computational Narratives
We designed Callisto, a Jupyter Notebook extension for better explaining messy notebooks. Callisto captures and stores contextual links between discussion messages and notebook elements with minimal effort from users. Callisto allows notebook readers to better understand the current notebook content and the overall problem-solving process that led to it, by making it possible to browse the discussions and code history relevant to any part of the notebook.
-
Explore, Create, Annotate: Designing Digital Drawing Tools with Visually Impaired People
A study to better understand how visually impaired people explore and create labeled tactile graphics.
-
Improving Crowd-Supported GUI Testing with Structural Guidance
Two techniques, interactive event-flow graphs and GUI-level guidance, that guide GUI testers to discover more test cases and avoid duplicate test cases.
CSCW 2019
-
How Data Scientists Use Computational Notebooks for Real-Time Collaboration
We reported how synchronous editing in computational notebooks changes the way data scientists work together compared to working on individual notebooks through a formative survey and an observational study. Working on the synchronous notebooks improves collaboration by creating a shared context, encouraging more exploration, and reducing communication costs. However, the current synchronous editing features may lead to unbalanced participation and activity interference without strategic coordination.
VL/HCC 2019
-
Studying the Benefits and Challenges of Immersive Dataflow Programming
In this paper, we study the benefits and challenges of immersive dataflow authoring, a paradigm that allows users to build VR applications using dataflow notation while immersed in the VR world.
CHI 2019
-
Implementing Multi-Touch Gestures with Touch Groups and Cross Events
Proposes two primitives to improve multi-touch programming: touch groups (which summarize multiple fingers rather than tracking them manually) and cross events (which summarize the movement of touch groups).
CSCW 2018
-
Creating Guided Code Explanations with chat.codes
Introduces three features to improve textual-based conversations about code: deictic code references (where a message points to a specific region of code), in-line code diffs (to show how code changed throughout a conversation), and conversation version tracking (which allows viewers to view the state of code as it evolves through out the conversation).
UIST 2018
-
Adasa: A Conversational In-Vehicle Digital Assistant for Advanced Driver Assistance Features
A conversational digital assistant to help drivers use and understand Advanced Driver Assistance Systems (ADAS).
-
Arboretum and Arbility: Improving Web Accessibility Through a Shared Browsing Architecture
A system that helps visually impaired web users overcome accessibility barriers through targeted handoffs of tasks that require visual-spatial interaction.
VL/HCC 2018
-
Expresso: Building Responsive Interfaces with Keyframes
A programming-by-demonstration approach for creating responsive UIs, where users create keyframes at a few representative viewport sizes and specify smooth or jump (i.e., linear interpolation) transitions between them.
CHI 2017
-
Codeon: On-Demand Software Development Assistance
CodeOn enables effective task hand-offs between developers and remote helpers by allowing asynchronous responses to on-demand requests.
UIST 2016
-
CodeMend: Assisting Interactive Programming with Bimodal Embedding
A system that helps programmers find appropriate API functions and parameter values from natural language.
CHI 2016
-
Towards Providing On-Demand Expert Support for Software Developers
Two studies that present the opportunities and the design recommendations of on-demand remote support systems for developers.
UIST 2014
-
InterState: A Language and Environment for Expressing Interface Behavior
InterState is a new programming language and environment that addresses the challenges of writing and reusing user interface code. InterState represents interactive behaviors clearly and concisely using a combination of novel forms of state machines and constraints. It also introduces new language features that...
CHI 2013
-
ZoomBoard: A Diminutive QWERTY Soft Keyboard Using Iterative Zooming for Ultra-Small Devices
The proliferation of touchscreen devices has made soft keyboards a routine part of life. However, ultra-small computing platforms like the Sony SmartWatch and Apple iPod Nano lack a means of text entry. This limits their potential, despite the fact they are capable computers. In this work, we present a soft keyboa...
UIST 2012
-
ConstraintJS: Programming Interactive Behaviors for the Web by Integrating Constraints and States
Interactive behaviors in GUIs are often described in terms of states, transitions, and constraints, where the constraints only hold in certain states. These constraints maintain relationships among objects, control the graphical layout, and link the user interface to an underlying data model. However, no existing We...
ICSE 2012
-
Inferring Method Specifications from Natural Language API Descriptions
Application Programming Interface (API) docu-ments are a typical way of describing legal usage of reusablesoftware libraries, thus facilitating software reuse. However,even with such documents, developers often overlook somedocuments and build software systems that are inconsistentw...
CHI 2012
-
Codelets: Linking Interactive Documentation and Example Code in the Editor
A system that helps programmers use examples from the web better by embedding interactive explanations and cutomizers in the programmer's code editor.
IS-EUD 2011
-
Playbook: Revision Control & Comparison for Interactive Mockups
When designing interactive interfaces and behaviors, interface designers compare and contrast multiple design ideas, often creating and testing many intermediate user interface prototypes before deciding on a final design. However, existing interface prototyping and creation tools do not effectively let designers ex...
CHI 2010
-
How to Support Designers in Getting Hold of the Immaterial Material of Software
When designing novel GUI controls, interaction designers are challenged by the “immaterial” materiality of the digital domain; they lack tools that effectively support a reflecting conversation with the material of software as they attempt to conceive, refine, and communicate their ideas. To investigate this situa...
VL/HCC 2009
-
FireCrystal: Understanding Interactive Behaviors in Dynamic Web Pages
FireCrystal is (was) a Firefox extension for inspecting dynamic behaviors in web pages. When a developer wants to understand how some dynamic behavior in a page is implemented, FireCrystal helps them by identifying the code that runs in between DOM changes.