Hybrid type checking

Traditional static type systems are very effective for verifying basic interface specifications, but are somewhat limited in the kinds specifications they support. Dynamically-checked contracts can enforce more precise specifications, but these are not checked until run time, resulting in incomplete detection of defects.Hybrid type checking is a synthesis of these two approaches that enforces precise interface specifications, via static analysis where possible, but also via dynamic checks where necessary. This paper explores the key ideas and implications of hybrid type checking, in the context of the simply-typed λ-calculus with arbitrary refinements of base types.

[1]  Luca Cardelli,et al.  Phase Distinctions in Type Theory , 1988 .

[2]  簡聰富,et al.  物件導向軟體之架構(Object-Oriented Software Construction)探討 , 1989 .

[3]  Richard C. Holt,et al.  The Turing programming language , 1988, CACM.

[4]  Rahul Agarwal,et al.  Type Inference for Parameterized Race-Free Java , 2004, VMCAI.

[5]  Giorgio Levi,et al.  Lecture notes in computer science on Foundations of logic and functional programming , 1988 .

[6]  David C. Luckham Programming with Specifications: An Introduction to ANNA, A Language for Specifying Ada Programs , 1990 .

[7]  Robert Cartwright,et al.  Soft typing , 1991, PLDI '91.

[8]  Guy L. Steele,et al.  The Java Language Specification , 1996 .

[9]  Alexander Aiken,et al.  Soft typing with conditional types , 1994, POPL '94.

[10]  David Walker,et al.  An effective theory of type refinements , 2003, ACM SIGPLAN Notices.

[11]  Luca Cardelli,et al.  Typechecking Dependent Types and Subtypes , 1986, Foundations of Logic and Functional Programming.

[12]  Jan Vitek,et al.  A Semantic Framework for Designer Transactions , 2004, ESOP.

[13]  David Walker,et al.  Dynamic Typing with Dependent Types , 2004, IFIP TCS.

[14]  Matthias Felleisen,et al.  Behavioral contracts and behavioral subtyping , 2001, ESEC/FSE-9.

[15]  David Lorge Parnas A technique for software module specification with examples , 1983, CACM.

[16]  Frank Pfenning,et al.  Dependent types in practical programming , 1999, POPL '99.

[17]  Giuseppe Castagna,et al.  Semantic subtyping , 2002, Proceedings 17th Annual IEEE Symposium on Logic in Computer Science.

[18]  Mark Lillibridge,et al.  Extended static checking for Java , 2002, PLDI '02.

[19]  Ewen Denney Refinement types for specification , 1998, PROCOMET.

[20]  Michael Kölling,et al.  Blue - Language Specification, Version 1.0 , 1997 .

[21]  J. Gregory Morrisett,et al.  Composing first-class transactions , 1994, TOPL.

[22]  David A. McAllester,et al.  Sound and complete models of contracts , 2006, Journal of Functional Programming.

[23]  Kenneth Knowles,et al.  Type Reconstruction for General Refinement Types , 2007, ESOP.

[24]  Walid Taha,et al.  Gradual Typing for Objects , 2007, ECOOP.

[25]  Satish R. Thatte Quasi-static typing , 1989, POPL '90.

[26]  Patrick Maxim Rondon,et al.  Liquid types , 2008, PLDI '08.

[27]  Michael D. Ernst,et al.  An overview of JML tools and applications , 2003, International Journal on Software Tools for Technology Transfer.

[28]  Lennart Augustsson,et al.  Cayenne—a language with dependent types , 1998, ICFP '98.

[29]  Matthias Felleisen,et al.  Contracts for higher-order functions , 2002, ICFP '02.

[30]  Matthias Felleisen,et al.  A Syntactic Approach to Type Soundness , 1994, Inf. Comput..

[31]  Jeremy G. Siek Gradual Typing for Functional Languages , 2006 .

[32]  John C. Reynolds,et al.  Definitional Interpreters for Higher-Order Programming Languages , 1972, ACM '72.

[33]  Frank Pfenning,et al.  Refinement types for ML , 1991, PLDI '91.

[34]  Koushik Sen,et al.  DART: directed automated random testing , 2005, PLDI '05.

[35]  Frank Pfenning,et al.  Intersection types and computational effects , 2000, ICFP '00.

[36]  Thierry Coquand,et al.  Inheritance as Implicit Coercion , 1991, Inf. Comput..

[37]  Hongwei Xi,et al.  Imperative programming with dependent types , 2000, Proceedings Fifteenth Annual IEEE Symposium on Logic in Computer Science (Cat. No.99CB36332).

[38]  George C. Necula,et al.  CCured: type-safe retrofitting of legacy code , 2002, POPL '02.

[39]  David Detlefs,et al.  Simplify: a theorem prover for program checking , 2005, JACM.

[40]  Matthias Felleisen,et al.  Catching bugs in the web of program invariants , 1996, PLDI '96.

[41]  Richard Statman,et al.  Logical Relations and the Typed lambda-Calculus , 1985, Inf. Control..

[42]  Thomas R. Gross,et al.  Object race detection , 2001, OOPSLA '01.

[43]  Cormac Flanagan,et al.  Unifying Hybrid Types and Contracts , 2007, Trends in Functional Programming.

[44]  George C. Necula,et al.  Temporal-Safety Proofs for Systems Code , 2002, CAV.

[45]  Gary T. Leavens,et al.  Design by Contract with JML , 2006 .

[46]  Fritz Henglein,et al.  Dynamic Typing: Syntax and Proof Theory , 1994, Sci. Comput. Program..

[47]  David Luckham,et al.  Programming with Specifications , 1990, Texts and Monographs in Computer Science.

[48]  Peter Lee,et al.  TIL: a type-directed, optimizing compiler for ML , 2004, SIGP.

[49]  Robert Cartwright,et al.  Soft typing , 2004, SIGP.

[50]  Martín Abadi,et al.  Dynamic typing in a statically-typed language , 1989, POPL '89.

[51]  Cormac Flanagan,et al.  Space-efficient gradual typing , 2010, High. Order Symb. Comput..

[52]  Jong-Deok Choi,et al.  Hybrid dynamic data race detection , 2003, PPoPP '03.

[53]  James Gosling,et al.  The Java Language Specification, 3rd Edition , 2005 .