Dynamic Typing with Dependent Types

Ou, Xinming; Tan, Gang; Mandelbaum, Yitzhak; Walker, David

doi:10.1007/1-4020-8141-3_34

Cited by 74 publications

(74 citation statements)

References 15 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Ou et al [16] present a type system that splits a program into portions that are either dependently or simply typed, using run-time checks at the boundaries. Our type system uses run-time checks for safety everywhere and relies on an optimizer to handle statically verifiable cases.…”

Section: Related Workmentioning

confidence: 99%

Dependent Types for Low-Level Programming

Condit

Harren

Anderson

et al. 2007

Programming Languages and Systems

View full text Add to dashboard Cite

Abstract. In this paper, we describe the key principles of a dependent type system for low-level imperative languages. The major contributions of this work are (1) a sound type system that combines dependent types and mutation for variables and for heap-allocated structures in a more flexible way than before and (2) a technique for automatically inferring dependent types for local variables. We have applied these general principles to design Deputy, a dependent type system for C that allows the user to describe bounded pointers and tagged unions. Deputy has been used to annotate and check a number of real-world C programs.

show abstract

Section: Related Workmentioning

confidence: 99%

Dependent Types for Low-Level Programming

Condit

Harren

Anderson

et al. 2007

Programming Languages and Systems

View full text Add to dashboard Cite

show abstract

“…For example, if the original application contains lock acquire/release operations, one of the possible specifications for update correctness is that after applying the update, the locks are in the same state as they were in the original program. This could be modeled using refinement types [41,71], type qualifiers [39,25], or dependent types [88,112,113].…”

Section: Static Approachesmentioning

confidence: 99%

Practical dynamic software updating for C

et al. 2006

View full text Add to dashboard Cite

This dissertation makes the case that programs can be updated while they run, with modest programmer effort, while providing certain update safety guarantees, and without imposing a significant performance overhead.Few systems are designed with on-the-fly updating in mind. Those systems that permit it support only a very limited class of updates, and generally provide no guarantees that following the update, the system will behave as intended. We tackle the on-the-fly updating problem using a compiler-based approach called dynamic software updating (DSU), in which a program is patched with new code and data while it runs. The challenge is in making DSU practical : it should support changes to programs as they occur in practice, yet be safe, easy to use, and not impose a large overhead.This dissertation makes both theoretical contributions-formalisms for reasoning about, and ensuring update safety-and practical contributions-Ginseng, a DSU implementation for C. Ginseng supports a broad range of changes to C programs, and performs a suite of safety analyses to ensure certain update safety properties. We performed a substantial study of using Ginseng to dynamically update six sizable C server programs, three single-threaded and three multi-threaded. The updates were derived from changes over long periods of time, ranging from 10 months to 4 years-worth of releases. Though the programs changed substantially, the updates were straightforward to generate, and performance measurements show that the overhead of Ginseng is detectable, but modest.In summary, this dissertation shows that DSU can be practical for updating realistic applications as they are written now, and as they evolve in practice.

show abstract

“…Expressibility is not reduced, however, because the assumption about x in the environment gets discharged at subtyping. The rule is borrowed from previous work [32,34,37]. VaF types function-type variables by looking up the environment and selecting a type from the intersection.…”

Section: Dependent Type Systemmentioning

confidence: 99%

Dependent types from counterexamples

Terauchi

2010

Proceedings of the 37th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages

View full text Add to dashboard Cite

Motivated by recent research in abstract model checking, we present a new approach to inferring dependent types. Unlike many of the existing approaches, our approach does not rely on programmers to supply the candidate (or the correct) types for the recursive functions and instead does counterexample-guided refinement to automatically generate the set of candidate dependent types. The main idea is to extend the classical fixed-point type inference routine to return a counterexample if the program is found untypable with the current set of candidate types. Then, an interpolating theorem prover is used to validate the counterexample as a real type error or generate additional candidate dependent types to refute the spurious counterexample. The process is repeated until either a real type error is found or sufficient candidates are generated to prove the program typable. Our system makes non-trivial use of "linear" intersection types in the refinement phase.The paper presents the type inference system and reports on the experience with a prototype implementation that infers dependent types for a subset of the Ocaml language. The implementation infers dependent types containing predicates from the quantifierfree theory of linear arithmetic and equality with uninterpreted function symbols.

show abstract

Dynamic Typing with Dependent Types

Cited by 74 publications

References 15 publications

Dependent Types for Low-Level Programming

Dependent Types for Low-Level Programming

Practical dynamic software updating for C

Dependent types from counterexamples

Contact Info

Product

Resources

About