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

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.

Authors

Institutions

Publication Details

Journal
The Art Science and Engineering of Programming
Published
2025-02-15
DOI
https://doi.org/10.22152/programming-journal.org/2025/10/8
Primary Topic
Software Engineering Research
Type
article
Field-Weighted Citation Impact
0.00
Controls
|||
ALL TIME
JAN
FEB
MAR
APR
MAY
JUN
JUL
AUG
SEP
OCT
article

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

Reid Holmes, Karim Ali, Ronald Garcia, Felipe Bañados Schwerter
The Art Science and Engineering of Programming
Software Engineering Research
article

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

Reid Holmes, Karim Ali, Ronald Garcia, Felipe Bañados Schwerter
article en

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.

The Art Science and Engineering of ProgrammingVol. 10(1)
New York University Abu Dhabi (AE), University of British Columbia (CA), University of Alberta (CA)
Openalex Percentile: Top 95%
Software Engineering Research
AI Navigator

Ask Laika to Summarize, Analyze, and Connect papers live on the map.

Summarize Papers & Methodologies

Extract key findings, datasets, and comparative methods across publications.

Benchmark Rankings & Visual Analytics

Rank top research institutions, authors, funders, topics, and journals by Field-Weighted Citation Impact (FWCI) and paper volume with instant charts.

Connect Distant Disciplines

Bridge topological clusters on the map to find hidden collaborative intersections.

Dynamic Program Slices Change How Developers Diagnose Gradual Run-Time Type Errors — Reid Holmes, Karim Ali, et al. · The Art Science and Engineering of Programming (2025) | TGRS Research Map | TGRS