The behavior of gradual types: a user study

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.

[1]  Jan Vitek,et al.  KafKa: Gradual Typing for Objects , 2018, ECOOP.

[2]  Stefan Hanenberg,et al.  How do API documentation and static typing affect API usability? , 2014, ICSE.

[3]  Brad A. Myers,et al.  Natural programming languages and environments , 2004, Commun. ACM.

[4]  Sebastian Kleinschmager,et al.  Do static type systems improve the maintainability of software systems? An empirical study , 2012, 2012 20th IEEE International Conference on Program Comprehension (ICPC).

[5]  Robert Bruce Findler,et al.  Operational semantics for multi-language programs , 2009 .

[6]  Martín Abadi,et al.  Understanding TypeScript , 2014, ECOOP.

[7]  Ben Greenman,et al.  On the cost of type-tag soundness , 2017, PEPM.

[8]  Jeremy G. Siek,et al.  Big types in little runtime: open-world soundness and collaborative blame for gradual type systems , 2017, POPL.

[9]  Sam Tobin-Hochstadt,et al.  The design and implementation of typed scheme , 2008, POPL '08.

[10]  Philip Wadler,et al.  Mixed Messages: Measuring Conformance and Non-Interference in TypeScript , 2017, ECOOP.

[11]  Sam Tobin-Hochstadt,et al.  Interlanguage migration: from scripts to programs , 2006, OOPSLA '06.

[12]  Cormac Flanagan,et al.  Hybrid type checking , 2006, POPL '06.

[13]  Jeremy G. Siek,et al.  Automatically generating the dynamic semantics of gradually typed languages , 2017, POPL.

[14]  Sam Tobin-Hochstadt,et al.  Migratory Typing: Ten Years Later , 2017, SNAPL.

[15]  Titus Barik,et al.  Error Messages as Rational Reconstructions. , 2018 .

[16]  Shriram Krishnamurthi,et al.  Error messages are classifiers: a process to design and evaluate error messages , 2017, Onward!.

[17]  Kathi Fisler,et al.  Teaching Programming Languages by Experimental and Adversarial Thinking , 2017, SNAPL.

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

[19]  Jim Baker,et al.  Design and evaluation of gradual typing for python , 2014, DLS.

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

[21]  Anders Møller,et al.  Type unsoundness in practice: an empirical study of Dart , 2016, DLS.

[22]  Gavin M. Bierman,et al.  Adding Dynamic Types to C# , 2010, ECOOP.

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

[24]  Robert Bruce Findler,et al.  Operational semantics for multi-language programs , 2007, POPL '07.

[25]  Stefan Hanenberg,et al.  An empirical study of the influence of static type systems on the usability of undocumented software , 2012, OOPSLA '12.

[26]  Gilad Bracha,et al.  Strongtalk: typechecking Smalltalk in a production environment , 1993, OOPSLA '93.

[27]  Marcus Denker,et al.  Gradual typing for Smalltalk , 2014, Sci. Comput. Program..

[28]  Shriram Krishnamurthi,et al.  Can we crowdsource language design? , 2017, Onward!.

[29]  Jan Vitek,et al.  Integrating typed and untyped code in a scripting language , 2010, POPL '10.

[30]  Matthias Felleisen,et al.  A spectrum of type soundness and performance , 2018, Proc. ACM Program. Lang..

[31]  Ross Tate,et al.  Sound gradual typing is nominally alive and well , 2017, Proc. ACM Program. Lang..

[32]  Sam Tobin-Hochstadt,et al.  Complete Monitors for Behavioral Contracts , 2012, ESOP.

[33]  Jan Vitek,et al.  Is sound gradual typing dead? , 2016, POPL.

[34]  Sebastian Kleinschmager,et al.  An empirical study on the impact of static typing on software maintainability , 2013, Empirical Software Engineering.

[35]  Fabio Mascarenhas,et al.  A formalization of typed lua , 2015, DLS.

[36]  Sam Tobin-Hochstadt,et al.  Practical Optional Types for Clojure , 2016, ESOP.

[37]  Robin Milner,et al.  A Theory of Type Polymorphism in Programming , 1978, J. Comput. Syst. Sci..

[38]  John Tang Boyland,et al.  Refined Criteria for Gradual Typing , 2015, SNAPL.

[39]  Vuk Ercegovac,et al.  Uncanny Valleys in Declarative Language Design , 2017, SNAPL.

[40]  T. Stephen Strickland,et al.  The ruby type checker , 2013, SAC '13.

[41]  Eduardo Figueiredo,et al.  How do programmers use optional typing?: an empirical study , 2014, MODULARITY.