Dynamic Program Slices Change How Developers Diagnose Gradual Run-Time Type Errors

2025-02-15

The Art, Science, and Engineering of Programming

AI Summary

Runtime type errors in gradually typed languages (e.g., TypeScript) are notoriously difficult to attribute, as conventional blame reports often misidentify irrelevant code. Method: This paper proposes a dynamic program slicing–based debugging approach to replace misleading blame reports. It systematically applies dynamic slicing to localize progressive type errors by precisely capturing the execution dependence paths responsible for type inconsistencies. The approach integrates runtime monitoring, on-the-fly type checking, and a Wizard-of-Oz user study to evaluate human–system collaboration. Contribution/Results: Empirical results demonstrate that developers accurately interpret slice outputs, efficiently identify root causes, and generate effective repairs. Compared to baseline methods, our approach significantly improves both the accuracy of type error attribution and overall debugging efficiency.

Technology Category

• Knowledge Representation and Reasoning: Diagnosis and Abductive Reasoning
• Reasoning under Uncertainty: Probabilistic Programming
• Constraint Satisfaction and Optimization: Satisfiability Modulo Theories

Application Category

• Graph Algorithms and Modeling for the Web: Efficient manipulation of static and dynamic Web-related graphs
• User Modeling, Personalization and Recommendation: Attacks and countermeasures in recommendation systems
• Responsible Web: Data and user privacy-enhancing technologies for the Web

Abstract

A gradual type system allows developers to declare certain types to be enforced by the compiler (i.e., statically typed), while leaving other types to be enforced via runtime checks (i.e., dynamically typed). When runtime checks fail, debugging gradually typed programs becomes cumbersome, because these failures may arise far from the original point where an inconsistent type assumption is made. To ease this burden on developers, some gradually typed languages produce a blame report for a given type inconsistency. However, these reports are sometimes misleading, because they might point to program points that do not need to be changed to stop the error. To overcome the limitations of blame reports, we propose using dynamic program slicing as an alternative approach to help programmers debug run-time type errors. We describe a proof-of-concept for TypeSlicer, a tool that would present dynamic program slices to developers when a runtime check fails. We performed a Wizard-of-Oz user study to investigate how developers respond to dynamic program slices through a set of simulated interactions with TypeScript programs. This formative study shows that developers can understand and apply dynamic slice information to provide change recommendations when debugging runtime type errors.

Problem

• Debugging runtime type errors in gradual typing systems.
• Improving accuracy of blame reports for type inconsistencies.
• Enhancing developer understanding with dynamic program slices.

Innovation

• Dynamic program slicing for debugging
• TypeSlicer tool for runtime errors
• User study with TypeScript programs