Practical SMT-based type error localization

Pavlinovic, Zvonimir; King, Tim L.; Wies, Thomas

doi:10.1145/2784731.2784765

Cited by 22 publications

(10 citation statements)

References 29 publications

(70 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Understanding and debugging static type errors is notoriously difficult, particularly for novices. A variety of approaches have been proposed to better localize and explain type errors Erwig 2014, 2018;Lerner et al 2006;Pavlinovic et al 2015;Zhang et al 2017]. One of these approaches, by Seidel et al [2016], uses symbolic execution and program synthesis to generate a dynamic witness that demonstrates a run-time failure that could be caused by the static type error.…”

Section: Type Error Messagesmentioning

confidence: 99%

Live functional programming with typed holes

Omar

Voysey

Chugh

et al. 2019

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

Live programming environments aim to provide programmers (and sometimes audiences) with continuous feedback about a program's dynamic behavior as it is being edited. The problem is that programming languages typically assign dynamic meaning only to programs that are complete, i.e. syntactically well-formed and free of type errors. Consequently, live feedback presented to the programmer exhibits temporal or perceptive gaps. This paper confronts this "gap problem" from type-theoretic first principles by developing a dynamic semantics for incomplete functional programs, starting from the static semantics for incomplete functional programs developed in recent work on Hazelnut. We model incomplete functional programs as expressions with holes, with empty holes standing for missing expressions or types, and non-empty holes operating as membranes around static and dynamic type inconsistencies. Rather than aborting when evaluation encounters any of these holes as in some existing systems, evaluation proceeds around holes, tracking the closure around each hole instance as it flows through the remainder of the program. Editor services can use the information in these hole closures to help the programmer develop and confirm their mental model of the behavior of the complete portions of the program as they decide how to fill the remaining holes. Hole closures also enable a fill-and-resume operation that avoids the need to restart evaluation after edits that amount to hole filling. Formally, the semantics borrows machinery from both gradual type theory (which supplies the basis for handling unfilled type holes) and contextual modal type theory (which supplies a logical basis for hole closures), combining these and developing additional machinery necessary to continue evaluation past holes while maintaining type safety. We have mechanized the metatheory of the core calculus, called Hazelnut Live, using the Agda proof assistant.We have also implemented these ideas into the Hazel programming environment. The implementation inserts holes automatically, following the Hazelnut edit action calculus, to guarantee that every editor state has some (possibly incomplete) type. Taken together with this paper's type safety property, the result is a proof-of-concept live programming environment where rich dynamic feedback is truly available without gaps, i.e. for every reachable editor state.

show abstract

Section: Type Error Messagesmentioning

confidence: 99%

Live functional programming with typed holes

Omar

Voysey

Chugh

et al. 2019

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

show abstract

“…As an application example, Pavlinovic et al [39] propose an approach which considers all possible compiler error sources for statically typed functional programming languages and reports the most useful one subject to some usefulness criterion. The authors formulate this approach as an optimization problem related to SMT and use νZ to compute an optimal error source in a given ill-typed program.…”

Section: Related Workmentioning

confidence: 99%

Counterexample guided inductive optimization based on satisfiability modulo theories

Araujo

Albuquerque

Bessa

et al. 2018

Science of Computer Programming

View full text Add to dashboard Cite

This paper describes three variants of a counterexample guided inductive optimization (CEGIO) approach based on Satisfiability Modulo Theories (SMT) solvers. In particular, CEGIO relies on iterative executions to constrain a verification procedure, in order to perform inductive generalization, based on counterexamples extracted from SMT solvers. CEGIO is able to successfully optimize a wide range of functions, including non-linear and non-convex optimization problems based on SMT solvers, in which data provided by counterexamples are employed to guide the verification engine, thus reducing the optimization domain. The present algorithms are evaluated using a large set of benchmarks typically employed for evaluating optimization techniques. Experimental results show the efficiency and effectiveness of the proposed algorithms, which find the optimal solution in all evaluated benchmarks, while traditional techniques are usually trapped by local minima.

show abstract

“…Zhang et al [41,42] present an algorithm for identifying the most likely culprit using Bayesian reasoning. Pavlinovic et al [29,30] translate the localization problem to a MaxSMT optimization problem, using compiler-provided weights to rank the possible sources.…”

Section: Related Workmentioning

confidence: 99%

Dynamic witnesses for static type errors (or, ill-typed programs usually go wrong)

Seidel¹,

Jhala²,

Weimer³

2016

SIGPLAN Not.

View full text Add to dashboard Cite

Static type errors are a common stumbling block for newcomers to typed functional languages. We present a dynamic approach to explaining type errors by generating counterexample witness inputs that illustrate how an ill-typed program goes wrong. First, given an ill-typed function, we symbolically execute the body to synthesize witness values that make the program go wrong. We prove that our procedure synthesizes general witnesses in that if a witness is found, then for all inhabited input types, there exist values that can make the function go wrong. Second, we show how to extend the above procedure to produce a reduction graph that can be used to interactively visualize and debug witness executions. Third, we evaluate the coverage of our approach on two data sets comprising over 4,500 ill-typed student programs. Our technique is able to generate witnesses for 88% of the programs, and our reduction graph yields small counterexamples for 81% of the witnesses. Finally, we evaluate whether our witnesses help students understand and fix type errors, and find that students presented with our witnesses show a greater understanding of type errors than those presented with a standard error message.

show abstract

Practical SMT-based type error localization

Cited by 22 publications

References 29 publications

Live functional programming with typed holes

Live functional programming with typed holes

Counterexample guided inductive optimization based on satisfiability modulo theories

Dynamic witnesses for static type errors (or, ill-typed programs usually go wrong)

Contact Info

Product

Resources

About