Preemptive Type Checking in Dynamically Typed Languages

Grech, Neville; Rathke, Julian; Fischer, Bernd

doi:10.1007/978-3-642-39718-9_12

Cited by 7 publications

(6 citation statements)

References 20 publications

(18 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…This paper is a revised and extended version of an earlier conference contribution that appeared in the proceedings of ICTAC 2013 [6]. The main differences are that we now give full formal proofs for all theorems in Section 3 and Section 4.…”

Section: Implementation and Evaluationmentioning

confidence: 99%

Preemptive type checking

Grech¹,

Fischer²,

Rathke³

2018

Journal of Logical and Algebraic Methods in Programming

Self Cite

View full text Add to dashboard Cite

Dynamically typed languages are very well suited for rapid prototyping, agile programming methodologies and rapidly evolving software. However, programmers can still benefit from the ability to detect type errors in their code early, in particular if this does not impose restrictions on their programming style.In this paper we describe a new type checking system that identifies potential type errors in such languages through a flow-sensitive static analysis. It computes for every expression the variable's present (from the values that it has last been assigned) and future (with which it is used in the further program execution) types, respectively. Using this information, the mechanism inserts type checks at strategic points in the original program. We prove that these checks are inserted as early as possible and preempt type errors earlier than existing type systems. We further show that these checks do not change the semantics of programs that do not raise type errors.Preemptive type checking can be added to existing languages without the need to modify the existing runtime environment. Instead, it can be invoked at a very late stage, after the compilation to bytecode and initialisation of the program. We demonstrate an implementation of this for the Python language, and its effectiveness on a number of standard benchmarks.

show abstract

Section: Implementation and Evaluationmentioning

confidence: 99%

Preemptive type checking

Grech¹,

Fischer²,

Rathke³

2018

Journal of Logical and Algebraic Methods in Programming

Self Cite

View full text Add to dashboard Cite

show abstract

“…Since by definition, dynamic languages lack a built-in static typing discipline, much of the static verification work focuses on either retrofitting rich typing or specification disciplines [11,12,21] or applying whole-program flow analysis for inferring and checking type properties (e.g., for JavaScript [5,27,28] or for Ruby [1]). Researchers have also used static type inference to instrument dynamic programs with assertions that fail preemptively [23]; while similar in spirit to OVV, such approaches are still phasic, since type analysis occurs only once, before program execution begins.…”

Section: Related Workmentioning

confidence: 99%

A vision for online verification-validation

Hammer

Chang

Horn

2016

Proceedings of the 2016 ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences

View full text Add to dashboard Cite

Today's programmers face a false choice between creating software that is extensible and software that is correct. Specifically, dynamic languages permit software that is richly extensible (via dynamic code loading, dynamic object extension, and various forms of reflection), and today's programmers exploit this flexibility to "bring their own language features" to enrich extensible languages (e.g., by using common JavaScript libraries). Meanwhile, such librarybased language extensions generally lack enforcement of their abstractions, leading to programming errors that are complex to avoid and predict.To offer verification for this extensible world, we propose online verification-validation (OVV), which consists of language and VM design that enables a "phaseless" approach to program analysis, in contrast to the standard static-dynamic phase distinction. Phaseless analysis freely interposes abstract interpretation with concrete execution, allowing analyses to use dynamic (concrete) information to prove universal (abstract) properties about future execution.In this paper, we present a conceptual overview of OVV through a motivating example program that uses a hypothetical database library. We present a generic semantics for OVV, and an extension to this semantics that offers a simple gradual type system for the database library primitives. The result of instantiating this gradual type system in an OVV setting is a checker that can progressively type successive continuations of the program until a continuation is fully verified. To evaluate the proposed vision of OVV for this example, we implement the VM semantics (in Rust), and show that this design permits progressive typing in this manner.

show abstract

“…It computes the present type of a variable (value assigned to it) and its future types (values that may be assigned later in the execution of the program). With this type information, dynamic type checks are inserted at strategic points of the original program . These type checks do not change the semantics of programs that do not raise type errors.…”

Section: Related Workmentioning

confidence: 99%

“…The objective of the inserted type checks is preempting all type errors at the earliest possible point for which a type error is inevitable, opposite to the typical runtime error produced at the point that a value of an incorrect type is used. Grech provided an implementation of preemptive type checking for Python .…”

Section: Related Workmentioning

confidence: 99%

See 1 more Smart Citation

Design and implementation of an efficient hybrid dynamic and static typing language

2014

View full text Add to dashboard Cite

Summary Dynamic languages are suitable for developing specific applications where runtime adaptability is an important issue. On the contrary, statically typed languages commonly provide better compile‐time type error detection and more opportunities for compiler optimizations. Because both approaches offer different benefits, there exist programming languages that support hybrid dynamic and static typing. However, the existing hybrid typing languages commonly do not gather type information of dynamic references at compile time, missing opportunities for improving compile‐time error detection and runtime performance. Therefore, we propose some design principles to implement hybrid typing languages that continue gathering type information of dynamically typed references. This type information is used to perform compile‐time type checking of the dynamically typed code and improve its runtime performance. As an example, we have implemented a hybrid typing language following the proposed design principles. We have evaluated the runtime performance and memory consumption of the generated code. The average performance of the dynamic and hybrid typing code is at least 2.53× and 4.51× better than the related approaches for the same platform, consuming less memory resources. Copyright © 2014 John Wiley & Sons, Ltd.

show abstract

Preemptive Type Checking in Dynamically Typed Languages

Cited by 7 publications

References 20 publications

Preemptive type checking

Preemptive type checking

A vision for online verification-validation

Design and implementation of an efficient hybrid dynamic and static typing language

Contact Info

Product

Resources

About