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

TL;DR

This paper introduces TypeSlicer, a tool that uses dynamic program slicing to improve debugging of runtime type errors in gradually typed languages, making error diagnosis more accurate and developer-friendly.

Contribution

The paper presents a novel approach using dynamic program slicing for debugging runtime type errors, addressing limitations of blame reports in gradually typed languages.

Findings

Developers can understand and use dynamic slices for debugging.

Dynamic slices help identify minimal code regions related to runtime errors.

User study shows improved debugging insights with the tool.

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.