Steve Oney
Pronouns: he/him
Steve Oney is an Associate Professor at the University of Michigan School of Information and Computer Science and Engineering (by courtesy). His research focuses on enabling and encouraging more people to write and customize computer programs by creating new programming tools and exploring usability issues in programming environments. Steve completed his Ph.D in Carnegie Mellon’s Human-Computer Interaction Institute where he was advised by Professor Brad Myers and Dr. Joel Brandt. He also attended MIT (CS & math S.B. in 2007, CS M.Eng in 2008).
Publications
-
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...
-
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.
-
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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).
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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).
-
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).
-
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.
-
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.
-
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.
-
CodeMend: Assisting Interactive Programming with Bimodal Embedding
A system that helps programmers find appropriate API functions and parameter values from natural language.
-
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.
-
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...
-
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...
-
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...
-
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...
-
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.
-
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...
-
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...
-
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.
Teaching
-
Practical JavaScript: From Scratch to React (Coursera Specialization)
-
Co-Instructor – SI 506 (Programming I)
-
Co-Instructor – SI 347 (Human-Computer Interaction)
-
Instructor (and creator) – SI 379 (Building Interactive Applications)
-
Instructor (and creator) – SI 579 (Building Interactive Applications)
-
Instructor – SI 106 (Programs, Information, & People)
-
Python 3 Programming Specialization