On the cost of type-tag soundness

Greenman, Ben; Migeed, Zeina

doi:10.1145/3175493.3162066

Cited by 10 publications

(15 citation statements)

References 5 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Finally, the survey does not suggest any performance consequences for different behaviors, despite evidence that Shallow adds overhead relative to Erasure [13] and that Deep can slow a program by an order of magnitude [30]. We could not think of a way to ask such questions about our hypothetical language in a meaningful manner; thus our results reflect attitudes regarding semantics only, ignoring performance.…”

Section: Threats To Validitymentioning

confidence: 72%

The behavior of gradual types: a user study

et al. 2020

Self Cite

View full text Add to dashboard Cite

There are several different gradual typing semantics, reflecting different trade-offs between performance and type soundness guarantees. Notably absent, however, are any data on which of these semantics developers actually prefer. We begin to rectify this shortcoming by surveying professional developers, computer science students, and Mechanical Turk workers on their preferences between three gradual typing semantics. These semantics reflect important points in the design space, corresponding to the behaviors of Typed Racket, TypeScript, and Reticulated Python. Our most important finding is that our respondents prefer a runtime semantics that fully enforces statically declared types.

show abstract

Section: Threats To Validitymentioning

confidence: 72%

The behavior of gradual types: a user study

et al. 2020

Self Cite

View full text Add to dashboard Cite

show abstract

“…For benchmarks with at most 12 modules, we measure the running time of all of the typed/untyped configurations on both versions of Racket. For the three benchmarks with more than 12 modules, we follow Greenman and Migeed [2018]'s lead and randomly select a subset of configurations to measure. 3 The results for the benchmark Gregor (13 modules) include 1,195 sampled configurations, the results for the benchmark QuadBG (14 modules) include 1,332 sampled configurations, and the results for the benchmark QuadMB (14 modules) include 1,344 sampled configurations.…”

Section: Methodsmentioning

confidence: 99%

“…For Gregor, QuadBG, and QuadMB, the blue and orange lines are actually 95% confidence intervals generated from the slowdowns in each sample [Greenman and Migeed 2018].…”

Section: Overall Cost Of Gradual Typingmentioning

confidence: 99%

Collapsible contracts: fixing a pathology of gradual typing

Feltey¹,

Greenman

Scholliers

et al. 2018

Proc. ACM Program. Lang.

Self Cite

View full text Add to dashboard Cite

The promise of gradual typing is that programmers should get the best of both worlds: the static guarantees of static types, and the dynamic flexibility of untyped programming. This is an enticing benefit, but one that, in practice, may carry significant costs. Significant enough, in fact, to threaten the very practicality of gradual typing; slowdowns as high as 120x are reported as arising from gradual typing. If one examines these results closely, though, it becomes clear that the costs of gradual typing are not evenly distributed. Indeed, while mixing typed and untyped code almost invariably carries non-trivial costs, many truly deal-breaking slowdowns exhibit pathological performance. Unfortunately, the very presence of these pathological casesÐand therefore the possibility of hitting them during developmentÐmakes gradual typing a risky proposition in any setting that even remotely cares about performance. This work attacks one source of large overheads in these pathological cases: an accumulation of contract wrappers that perform redundant checks. The work introduces a novel strategy for contract checkingÐ collapsible contractsÐwhich eliminates this redundancy for function and vector contracts and drastically reduces the overhead of contract wrappers. We implemented this checking strategy as part of the Racket contract system, which is used in the Typed Racket gradual typing system. Our experiments show that our strategy successfully brings a class of pathological cases in line with normal cases, while not introducing an undue overhead to any of the other cases. Our results also show that the performance of gradual typing in Racket remains prohibitive for many programs, but that collapsible contracts are one essential ingredient in reducing the cost of gradual typing.

show abstract

“…Researchers in this area have only recently begun to study the performance of implementations systematically [Bauman et al 2017;Muehlboeck and Tate 2017;. Previous attempts to compare approaches make claims about different programming languages using mostly-unrelated benchmarks [Greenman and Migeed 2018;Muehlboeck and Tate 2017;Vitousek et al 2017].…”

Section: :2 Ben Greenman and Matthias Felleisenmentioning

confidence: 99%

“…As a rule-of-thumb, adding types imposes (at least) a linear-time performance degredation [Greenman and Felleisen 2018; Greenman and Migeed 2018].…”

Section: For the Performance Of Fully-typed Programsmentioning

confidence: 99%

A spectrum of type soundness and performance

Greenman

Felleisen

2018

Proc. ACM Program. Lang.

Self Cite

View full text Add to dashboard Cite

The literature on gradual typing presents three fundamentally different ways of thinking about the integrity of programs that combine statically typed and dynamically typed code. This paper presents a uniform semantic framework that explains all three approaches, illustrates how each approach affects a developer's work, and adds a systematic performance comparison for a single implementation platform.

show abstract

On the cost of type-tag soundness

Cited by 10 publications

References 5 publications

The behavior of gradual types: a user study

The behavior of gradual types: a user study

Collapsible contracts: fixing a pathology of gradual typing

A spectrum of type soundness and performance

Contact Info

Product

Resources

About