Augmenting Dynamic Typing with Static-Analysis

Today’s statically-typed functional programming languages give developers great confidence over correctness and an excellent tool during refactoring. With tools like core.typed (Clojure) and Dialyzer (Erlang), dynamically-typed language users are able to take advantage of many of these benefits as well. In this talk, we’ll explore the success typing space. Further, we’ll see some real-world examples where Basho has used Dialyzer to create better assuredness and documentation in their database: Riak.

Transcript

1. Augmenting Dynamic Typing with Static-Analysis Reid Draper @reiddraper
2. Reid Draper @reiddraper
3. takeaways
4. tl;dr
5. JUST USE HASKELL
6. JUST USE IDRIS
7. several modern functional languages have optional type systems
8. they are mature enough to be useful
9. they find real bugs
10. and improve documentation
11. with some work, you can integrate them into your CI system
12. motivation
13. %% Return a list of locators, in our case, we'll use cluster names %% that were saved in the ring cluster_mgr_sites_fun() -> %% get cluster names from cluster manager Ring = riak_core_ring_manager:get_my_ring(), Clusters = riak_repl_ring:get_clusters(Ring), [{?CLUSTER_NAME_LOCATOR_TYPE, Name} || {Name, _Addrs} <- Clusters].
15. static-typing has many benefits
16. prevents many errors during compile-time
17. enhanced documentation
18. %% @doc Return a list of all manifests in the %% `active' or `writing' state active_and_writing_manifests(Dict) -> orddict:to_list(filter_manifests_by_state(Dict, [active, writing])).
19. %% @doc Return a list of all manifests in the %% `active' or `writing' state -spec active_and_writing_manifests(orddict:orddict()) -> [{binary(), lfs_manifest()}]. active_and_writing_manifests(Dict) -> orddict:to_list(filter_manifests_by_state(Dict, [active, writing])).
20. -spec f(orddict:orddict()) -> [{binary(), lfs_manifest()}]. !
21. a guide for structuring programs
22. (potentially) better performance
23. there are many popular dynamically-typed languages in industry
24. JavaScript Java PHP C# Python! C++ Ruby C Objective-C CSS Perl Shell Scala Haskell R Matlab Clojure CoffeeScript Visual Basic Groovy http://redmonk.com/sogrady/2014/01/22/language-rankings-1-14/
25. so what do we do?
26. can we add a type-system?
27. Retrofitting a type system into a language not designed with typechecking in mind can be tricky; ideally, language design should go hand-in-hand with type system design. Benjamin C. Pierce, Types and Programming Languages p. 9
28. history
29. an incomplete and likely wrong history
30. adding dynamic types to a statically-typed language 1989 M. Abadi, L. Cardelli, B. Pierce, G. Plotkin, statically-typed language
31. Cartwright and Fagan introduce Soft-Typing 1991 Robert Cartwright, Mike Fagan,
32. "The key concept of soft typing is that a type checker need not reject programs containing statically 'ill typed' phrases" 1991 Robert Cartwright, Mike Fagan,
33. Soft-Types implemented with Scheme 1994 Andrew K. Wright , Robert Cartwright,
34. Marlow and Wadler add static- types to Erlang* 1997 * with some caveats… Andrew K. Wright , Robert Cartwright,
35. Bracha introduces optional types in Pluggable Type Systems 2004 Gilad Bracha,
36. "In contrast, optional type systems are neither syntactically nor semantically required, and have no effect on the dynamic semantics of the language." 2004 Gilad Bracha,
37. Erlang's Dialyzer becomes viable 2006 Lindahl, Sagonas,
38. overcomes many of the issues Marlow and Wadler had 2004 Lindahl, Sagonas,
39. Gradual typing for functional languages 2006 Siek, Taha,
40. The design and implementation of typed scheme 2008 now called Typed Racket Tobin-Hochstadt, Felleisen,
41. inspiration for typed Clojure 2008 Tobin-Hochstadt, Felleisen,
42. introduces Occurrence typing 2008 Tobin-Hochstadt, Felleisen,
43. (: flexible-length (-> (U String (Listof Any)) Integer)) (define (flexible-length str-or-lst) (if (string? str-or-lst) (string-length str-or-lst) (length str-or-lst)))
44. state of the art
45. Dialyzer for Erlang
46. Typed Racket
47. Typed Clojure
48. Dart
49. Dialyzer at Basho
50. we write a distributed database in Erlang: Riak
51. correctness and fault-tolerance are import
52. bugs are inevitable
53. sometimes embarrassing
54. avoid preventable bugs
55. we use Dialyzer for this
56. recently hooked it up with CI
68. takeaways
69. tl;dr
70. several modern functional languages have optional type systems
71. they are mature enough to be useful
72. they find real bugs
73. and improve documentation
74. with some work, you can integrate them into your CI system
76. Questions? @reiddraper