Space-Efficient Latent Contracts

Greenberg, Michael

doi:10.1007/978-3-030-14805-8_1

Cited by 3 publications

(3 citation statements)

References 35 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…2019], and Reticulated Python [Vitousek et al 2014], keep some dynamic checking, but give up the full soundness guarantee offered by gradual typing. Yet other systems, such as Safe TypeScript [Rastogi et al 2015], Nom [Muehlboeck and Tate 2017], Thorn [Wrigstad et al 2010], and Dart [Google Inc. 2018], limit interoperability between typed and untyped code to avoid some expensive checks.…”

Section: Static Verification To Avoid Dynamic Costsmentioning

confidence: 99%

See 1 more Smart Citation

Corpse reviver: sound and efficient gradual typing via contract verification

Moy

Nguyen

Tobin-Hochstadt

et al. 2021

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

Gradually typed programming languages permit the incremental addition of static types to untyped programs. To remain sound, languages insert run-time checks at the boundaries between typed and untyped code. Unfortunately, performance studies have shown that the overhead of these checks can be disastrously high, calling into question the viability of sound gradual typing. In this paper, we show that by building on existing work on soft contract verification, we can reduce or eliminate this overhead. Our key insight is that while untyped code cannot be trusted by a gradual type system, there is no need to consider only the worst case when optimizing a gradually typed program. Instead, we statically analyze the untyped portions of a gradually typed program to prove that almost all of the dynamic checks implied by gradual type boundaries cannot fail, and can be eliminated at compile time. Our analysis is modular, and can be applied to any portion of a program. We evaluate this approach on a dozen existing gradually typed programs previously shown to have prohibitive performance overhead—with a median overhead of 2.5× and up to 80.6× in the worst case—and eliminate all overhead in most cases, suffering only 1.5× overhead in the worst case.

show abstract

Section: Static Verification To Avoid Dynamic Costsmentioning

confidence: 99%

“…This includes systems such as Nom [Muehlboeck and Tate 2017] and C# [Bierman et al 2010] that require all data to be created in the typed code and use nominal type tags for dynamic checks. Other systems limit what can flow across boundaries [Google Inc. 2018;Richards et al 2017Richards et al , 2015Swamy et al 2014;Wrigstad et al 2010].…”

Section: Related Workmentioning

confidence: 99%

Corpse reviver: sound and efficient gradual typing via contract verification

Moy

Nguyen

Tobin-Hochstadt

et al. 2021

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

show abstract

“…Highcost types may be a symptom of inefficiencies in the translation from types to dynamic checks. Recent calculi for space-efficient contracts (Herman et al, 2010;Garcia, 2013;Greenberg, 2015Greenberg, , 2016Siek et al, 2015a) may provide insight for eliminating proxies. Storing runtime type information in the heap may prove to be more efficient than encoding it with contracts (Rastogi et al, 2015;Siek et al, 2015b).…”

Section: The Future Of Gradual Typingmentioning

confidence: 99%

How to evaluate the performance of gradual type systems

et al. 2019

View full text Add to dashboard Cite

A sound gradual type system ensures that untyped components of a program can never break the guarantees of statically typed components. This assurance relies on runtime checks, which in turn impose performance overhead in proportion to the frequency and nature of interaction between typed and untyped components. The literature on gradual typing lacks rigorous descriptions of methods for measuring the performance of gradual type systems. This gap has consequences for the implementors of gradual type systems and developers who use such systems. Without systematic evaluation of mixed-typed programs, implementors cannot precisely determine how improvements to a gradual type system affect performance. Developers cannot predict whether adding types to part of a program will significantly degrade (or improve) its performance. This paper presents the first method for evaluating the performance of sound gradual type systems. The method quantifies both the absolute performance of a gradual type system and the relative performance of two implementations of the same gradual type system. To validate the method, the paper reports on its application to 20 programs and 3 implementations of Typed Racket.

show abstract

GTP Benchmarks for Gradual Typing Performance

Greenman

2023

Proceedings of the 2023 ACM Conference on Reproducibility and Replicability

View full text Add to dashboard Cite

Space-Efficient Latent Contracts

Cited by 3 publications

References 35 publications

Corpse reviver: sound and efficient gradual typing via contract verification

Corpse reviver: sound and efficient gradual typing via contract verification

How to evaluate the performance of gradual type systems

GTP Benchmarks for Gradual Typing Performance

Contact Info

Product

Resources

About