Size-change termination as a contract: dynamically and statically enforcing termination for higher-order programs

Nguyen, Phuc H.; Gilray, Thomas; Tobin-Hochstadt, Sam; Horn, David Van

doi:10.1145/3314221.3314643

Cited by 7 publications

(4 citation statements)

References 44 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Future work includes supporting implicit arguments and higher-order unification, blame tracking [Wadler and Findler 2009], and efficient runtime semantics with erasure of computationallyirrelevant arguments [Brady et al 2003]. Approximate normalization might be made more precise by exploiting termination contracts [Nguyễn et al 2019].…”

Section: Resultsmentioning

confidence: 99%

Approximate normalization for gradual dependent types

Eremondi

Tanter

García

2019

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

Dependent types help programmers write highly reliable code. However, this reliability comes at a cost: it can be challenging to write new prototypes in (or migrate old code to) dependently-typed programming languages. Gradual typing makes static type disciplines more flexible, so an appropriate notion of gradual dependent types could fruitfully lower this cost. However, dependent types raise unique challenges for gradual typing. Dependent typechecking involves the execution of program code, but gradually-typed code can signal runtime type errors or diverge. These runtime errors threaten the soundness guarantees that make dependent types so attractive, while divergence spoils the type-driven programming experience.This paper presents GDTL, a gradual dependently-typed language that emphasizes pragmatic dependentlytyped programming. GDTL fully embeds both an untyped and dependently-typed language, and allows for smooth transitions between the two. In addition to gradual types we introduce gradual terms, which allow the user to be imprecise in type indices and to omit proof terms; runtime checks ensure type safety. To account for nontermination and failure, we distinguish between compile-time normalization and run-time execution: compile-time normalization is approximate but total, while runtime execution is exact, but may fail or diverge. We prove that GDTL has decidable typechecking and satisfies all the expected properties of gradual languages. In particular, GDTL satisfies the static and dynamic gradual guarantees: reducing type precision preserves typedness, and altering type precision does not change program behavior outside of dynamic type failures. To prove these properties, we were led to establish a novel normalization gradual guarantee that captures the monotonicity of approximate normalization with respect to imprecision.

show abstract

Section: Resultsmentioning

confidence: 99%

Approximate normalization for gradual dependent types

Eremondi

Tanter

García

2019

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

show abstract

“…Static enforcement includes work such as total functional programming [52], primitive recursion [8, Chapter 3], and model checkers such as TERMIN-ATOR [11]. Techniques that dynamically enforce program termination can make use of both static information and run-time values, such as size-change termination [36].…”

Section: Eventual Reactivitymentioning

confidence: 99%

“…Our current implementation of Stella uses size-change termination (SCT) for higher-order programs [36] to ensure at run-time that routines terminate. In a nutshell, this form of SCT dynamically constructs a size-change graph based on the argument values of a routine call (def p1 (new Pair 'initialize-with 1 2)) (set-second!…”

Section: Routines Can Only Invoke Other Routinesmentioning

confidence: 99%

See 1 more Smart Citation

Tackling the Awkward Squad for Reactive Programming: The Actor-Reactor Model (Artifact)

Van den Vonder,

Renaux,

Oeyen

et al. 2020

View full text Add to dashboard Cite

Reactive programming is a programming paradigm whereby programs are internally represented by a dependency graph, which is used to automatically (re)compute parts of a program whenever its input changes. In practice reactive programming can only be used for some parts of an application: a reactive program is usually embedded in an application that is still written in ordinary imperative languages such as JavaScript or Scala. In this paper we investigate this embedding and we distill "the awkward squad for reactive programming" as 3 concerns that are essential for real-world software development, but that do not fit within reactive programming. They are related to long lasting computations, side-effects, and the coordination between imperative and reactive code. To solve these issues we design a new programming model called the Actor-Reactor Model in which programs are split up in a number of actors and reactors. Actors and reactors enforce a strict separation of imperative and reactive code, and they can be composed via a number of composition operators that make use of data streams. We demonstrate the model via our own implementation in a language called Stella. ACM Subject ClassificationSoftware and its engineering → Data flow languages; Software and its engineering → Multiparadigm languages

show abstract

DynamiTe: dynamic termination and non-termination proofs

Antonopoulos

Fathololumi

et al. 2020

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

There is growing interest in termination reasoning for nonlinear programs and, meanwhile, recent dynamic strategies have shown they are able to infer invariants for such challenging programs. These advances led us to hypothesize that perhaps such dynamic strategies for nonlinear invariants could be adapted to learn recurrent sets (for non-termination) and/or ranking functions (for termination). In this paper, we exploit dynamic analysis and draw termination and non-termination as well as static and dynamic strategies closer together in order to tackle nonlinear programs. For termination, our algorithm infers ranking functions from concrete transitive closures, and, for non-termination, the algorithm iteratively collects executions and dynamically learns conditions to refine recurrent sets. Finally, we describe an integrated algorithm that allows these algorithms to mutually inform each other, taking counterexamples from a failed validation in one endeavor and crossing both the static/dynamic and termination/non-termination lines, to create new execution samples for the other one. We have implemented these algorithms in a new tool called DynamiTe. For nonlinear programs, there are currently no SV-COMP termination benchmarks so we created new sets of 38 terminating and 39 non-terminating programs. Our empirical evaluation shows that we can effectively guess (and sometimes even validate) ranking functions and recurrent sets for programs with nonlinear behaviors. Furthermore, we show that counterexamples from one failed validation can be used to generate executions for a dynamic analysis of the opposite property. Although we are focused on nonlinear programs, as a point of comparison, we compare DynamiTe's performance on linear programs with that of the state-of-the-art tool, Ultimate. Although DynamiTe is an order of magnitude slower it is nonetheless somewhat competitive and sometimes finds ranking functions where Ultimate was unable to. Ultimate cannot, however, handle the nonlinear programs in our new benchmark suite.

show abstract

Size-change termination as a contract: dynamically and statically enforcing termination for higher-order programs

Cited by 7 publications

References 44 publications

Approximate normalization for gradual dependent types

Approximate normalization for gradual dependent types

Tackling the Awkward Squad for Reactive Programming: The Actor-Reactor Model (Artifact)

DynamiTe: dynamic termination and non-termination proofs

Contact Info

Product

Resources

About