Under Review

Journal IEEE Transactions On Software Engineering (TSE)

Description

Debugging is a central yet cognitively demanding part of software development, requiring problem-solving skills, expertise, and appropriate tools. Prior work has documented a variety of debugging strategies—such as hypothesis testing, simplification, and forward or backward reasoning—as well as individual factors that influence their use. However, we still lack an integrated understanding of how expert developers select and adapt these strategies in response to changing contextual factors during real-world challenging debugging.

In this paper, we conducted a three-phase study: we first synthesized prior work on challenging debugging contexts, then used a short survey of 35 web developers to surface up-to-date examples of difficult defects, and finally conducted semi-structured interviews with 16 expert web developers to understand how they select and adapt strategies in these contexts. 

We identified a taxonomy of static and dynamic factors that influence developers' decision making and how these factors interact in complex ways, where a combination of factors, potentially evolving throughout the debugging process, plays a role in strategy selection. We describe  strategy adaptation through a state-transition model that depicts how decisions change as dynamic factors like clarity, reproducibility, and constraints evolve during a debugging scenario. Our findings highlight the need for more contextual design of debugging tools as well as educational decision-making frameworks for choosing effective strategies.

Under Review 

Journal 27th edition of the International Conference on Artificial Intelligence in Education (AIED 2026)

Description

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 helps instructors assess whether AI use aligns with their pedagogical goals, enables timely intervention when they find unproductive usage patterns, and establishes effective policies for AI use. However, our survey with programming instructors found that many instructors lack visibility into how students use AI in their code-writing processes. To address this challenge, we introduce Editrail, an interactive system that enables instructors to track students’ AI usage, create personalized assessments, and provide timely interventions, all within the workflow of monitoring coding histories. We found that Editrail enables instructors to detect AI use that conflicts with pedagogical goals accurately and to determine when and which students require intervention.

Publication date 2026/4

Journal Proceedings of the 2026 CHI Conference on Human Factors in Computing Systems (CHI 2026)

Description

Code edit histories can offer instructors valuable insight into students’ problem-solving processes, revealing unproductive behaviors that final code alone cannot capture. For example, a correct solution may contain large copy-and-pasted segments (suggesting the code originated elsewhere) or unguided trial-and-error (suggesting a lack of clear strategy). Timelines are a common way to visualize code histories, but existing timeline visualizations of code or document histories show only when and where edits occurred, not what changed. Without this context, it is difficult to answer key questions about how students invested effort or to infer their intentions. We present CodeStream, a visualization system that augments timelines with situational code annotations, whose granularity and visibility dynamically adapt to scale and interaction state. A comparison study shows that CodeStream enables context-aware navigation of coding histories, supporting fast and accurate pattern identification, and helping instructors reason about students’ coding behaviors and identify who may need intervention.

Publication date 2025/9

Journal Proceedings of the 38th Annual ACM Symposium on User Interface Software and Technology (UIST '25)

Description

Repetitive actions are a common and frustrating part of using the web. Prior work has proposed automating repetitive actions with natural language descriptions, demonstrations, and pseudocode. However, these approaches introduce abstractions that can be difficult to write, evaluate, and fit within web workflows. We describe a new approach, Multi-Click, for simultaneously performing the same action (e.g., clicking or typing) across multiple pages while maintaining the immediacy and understandability of direct manipulation. Users can intuitively select groups of analogous elements within or across windows/tabs (e.g., equivalent elements in different instantiations of a template) and interact with these elements as if each simultaneously had keyboard or cursor focus (e.g., one click propagates to multiple targets). Multi-Click introduces algorithms for identifying analogous elements from structural and visual attributes; techniques for intuitively selecting and visualizing targets; and uses interactive data grids to manage variation in text entry and retrieval tasks.

Publication date 2025/9

Journal IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC)

Description

Programming instruction often focuses on syntax and algorithms. However, mastering programming also requires building strategic knowledge of skills such as debugging, problem solving, and program design. These critical skills are difficult to teach explicitly because they often involve tacit knowledge, context-specific understanding, and adaptive decision-making. Large Language Models (LLMs) can be effective in helping with syntactic and algorithmic questions but can fail to provide strategic knowledge. This is partly because strategic knowledge involves nuanced contexts that span code and runtime states, requires subjective judgments, and dynamically evolves based on the outcomes of users’ actions. We introduce Co-Advisor, a context-aware strategy recommendation tool that leverages LLM to evaluate problem context and monitor the programmer’s actions to provide personalized constructive feedback. Unlike prior work, Co-Advisor can dynamically align expert strategies with real-time programmer actions and code context, offering actionable, personalized strategic knowledge. In a formative evaluation with 14 programmers involved in two debugging tasks, we found that those using Co-Advisor to receive context-related feedback alongside expert strategies were significantly more successful than those without context-related feedback. They demonstrated greater engagement and had an improved learning experience, gaining insight into the reasons behind their mistakes, correcting them, and understanding the rationale behind their actions. Thus, Co-Advisor enhances conceptual understanding and strategic problem-solving.

Publication date 2023/5

Journal Proceedings of the IEEE/ACM 45th International Conference on Software Engineering (ICSE)

Pages 435-447

Description

Decision-making is a key software engineering skill. Developers constantly make choices throughout the software development process, from requirements to implementation. While prior work has studied developer decision-making, the choices made while choosing what solution to write in code remain understudied. In this mixed-methods study, we examine the phenomenon where developers select one specific way to implement a behavior in code, given many potential alternatives. We call these decisions implementation design decisions. Our mixed-methods study includes 46 survey responses and 14 semi-structured interviews with professional developers about their decision types, considerations, processes, and expertise for implementation design decisions. We find that implementation design decisions, rather than being a natural outcome from higher levels of design, require constant monitoring of higher level design choices, such as requirements and architecture. We also show that developers have a consistent general structure to their implementation decision-making process, but no single process is exactly the same. We discuss the implications of our findings on research, education, and practice, including insights on teaching developers how to make implementation design decisions.

Publication date 2022/4/27

Journal Proceedings of the 2022 CHI Conference on Human Factors in Computing Systems

Pages 1-15

Description

In many domains, strategic knowledge is documented and shared through checklists and handbooks. In software engineering, however, developers rarely share strategic knowledge for approaching programming problems, in contrast to other artifacts and despite its importance to productivity and success. To understand barriers to sharing, we simulated a programming strategy knowledge-sharing platform, asking experienced developers to articulate a programming strategy and others to use these strategies while providing feedback. Throughout, we asked strategy authors and users to reflect on the challenges they faced. Our analysis revealed that developers could share strategic knowledge. However, they struggled in choosing a level of detail and understanding the diversity of the potential audience. While authors required substantial feedback, users struggled to give it and authors to interpret it.

Publication date 2021/10/10

Journal IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC)

Pages 1-9

Description

Developers rely heavily on resources to find technical insights on how to use languages, APIs, and platforms, seeking help from Stack Overflow, GitHub, meetups, blogs, live streams, forums, documentation, and more. However, there is one kind of knowledge for which resources are hard to find: strategic knowledge. In contrast to technical knowledge, strategic knowledge provides insight into how to approach problem-solving. Prior work has demonstrated that developers can make use of written strategies to improve their problem-solving. However, there is currently no way for developers to share, curate, and search for this knowledge at scale. To address this gap, we contribute HowToo, a platform for sharing, finding, and using programming strategies. Its key insight is that there are many different approaches to the same problem, and developers may need different strategies depending on their situation. 

Publication date 2020/7

Journal Empirical Software Engineering (ESE)

Pages 2416-2449

Description

Software developers solve a diverse and wide range of problems. While software engineering research often focuses on tools to support this problem solving, the strategies that developers use to solve problems are at least as important. In this paper, we offer a novel approach for enabling developers to follow explicit programming strategies that describe how an expert tackles a common programming problem. We define explicit programming strategies, grounding our definition in prior work both within software engineering and in other professions which have adopted more explicit procedures for problem solving. We then present a novel notation called Roboto and a novel strategy tracker tool that explicitly represent programming strategies and frame executing strategies as a collaborative effort between human abilities to make decisions and computer abilities to structure process and persist information. In a formative evaluation, 28 software developers of varying expertise completed a design task and a debugging task. We found that, compared to developers who are free to choose their own strategies, developers given explicit strategies experienced their work as more organized, systematic, and predictable, but also more constrained. Developers using explicit strategies were objectively more successful at the design and debugging tasks. We discuss the implications of Roboto and these findings, envisioning a thriving ecosystem of explicit strategies that accelerate and improve developers’ programming problem solving.  

Publication date 2017/6/12

Journal 14th Annual IEEE International Conference on Sensing, Communication, and Networking (SECON)

Pages 1-9

Description

In heavily congested urban areas, the rapid growth of population is becoming more and more of an issue. Affected cities quickly demand solutions to areas such as quality of life, waste management, public transportation, and accessibility to main resources. However, since the number of impacted areas of population growth is endless, we focus on public parking. Studies show that drivers spend a large portion of their travel time locating vacant parking spots. For this reason, we present MagnoPark, a crowdsourced approach to identifying unoccupied spots accessible to the general public, who are typically free. MagnoPark is a smartphone based sensing solution that detects empty parking spots using internal sensors of cellphones. While a pedestrian is walking on the sidewalk, we exploit magnetometer changes near metal objects in identifying where cars are located.

Publication date 2015

Journal Image and Graphics: 8th International Conference, ICIG 2015, Tianjin, China, August 13-16, 2015, Proceedings, Part II 8

Pages 147-155

Description

Protein secondary structures such as α-helices and β-strands are major structural components in most proteins. The position of secondary structures provides important constraints in computing the tertiary structure of a protein. Electron cryomicroscopy is a biophysical technique that produces 3-dimensional images of large molecular complexes. For images at medium resolutions, such as 5–10 Å, major secondary structures may be computationally detected. This paper summarizes our recent work in detection of secondary structures using SSETracer, SSELearner, StrandTwister and StrandRoller. The detection of helices and β-strands is illustrated using SSETracer and StrandTwister with a small dataset.