Why Static Typing Matters

(or How to Solve All Your Runtime Errors With This One Neat Trick)

Transcript

1. Why Static Typing Matters (or How to Solve All Your Runtime Errors With This One Neat Trick)
2. @eliperkins
4. @_eliperkins
7. Why Static Typing Matters (or How to Solve All Your Runtime Errors With This One Neat Trick)
8. WTF is static typing anyway
9. Static Dynamic vs.
10. Annotating Inferring &
12. Flow TypeScript &
13. Flow TypeScript &
14. const x: number = 0;
15. const x = 0;
16. function sum(x: number, y: number) { return x + y; } const foo = sum(2, 3); number
17. function sum(x: number, y: number) { return x + y; } function multiply(x: number, y: number) { return x * y; } function square(x: number) { return x * x; } const x = square(multiply(sum(2, 3), 2)); number
18. const xs: Array<number> = [1, 2, 3];
19. const greeting: ?string = null;
20. const greeting: ?string = null;
21. function greet(greeting: string) { console.log(greeting + ', world!'); } const greeting: ?string = null; greet(greeting); Error: This type is incompatible
22. type User = { name: string, username: string, email: ?string, }; function sendEmail(email: string) { … } const eli: User = { name: 'Eli', username: 'eliperkins', email: null, }; sendEmail(eli.email); Error: This type is incompatible
23. type User = { name: string, username: string, email: ?string, }; function sendEmail(email: string) { … } const eli: User = { name: 'Eli', username: 'eliperkins', email: null, }; if (eli.email != null) { sendEmail(eli.email); } No errors!
24. function sum(x: number, y: number) { return x + y; } function square(x: number) { return x * x; } const x = s sum (x: number, y: number): number square (x: number): number
25. function sum(x: number, y: number) { return x + y; } const x = summm(2, 3); Error: identifier `summm` Could not resolve name
26. type Props = { id: number, name: string, email: string, }; class UserComponent extends React.Component<Props> { ... } <UserComponent id={123} name={"Eli"} />; Error: property `email` not found in props of React element `UserComponent`
29. Why should I care
30. Bugs are surprises
31. Static types reduce surprises
32. Static types reduce bugs
33. Errors at run-time ❌
34. Errors at compile-time ✅
36. [C]
38. [C]
39. NSArray *x = @[]; NSString *hundreth = x[100];
41. NSNumber *x = @1; [x performSelector:@selector(boom)];
44. [client fetchFriendsFeed:^(NSArray *events) { // lol wtf is `events` // Maybe VENEvent objects? // Maybe VENFeedEvent objects? // Maybe null? }];
45. Errors at run-time ❌
46. Crashes at run-time ❌
51. ❤[] C
52. client.fetchActivityFeed { (events) in ... } Array<Venmo.Event>
53. client.fetchActivityFeed { (events) in let event = events.first } Optional<Venmo.Event> { createdAt: String …
54. let user = User( name: "Eli", username: "eliperkins", email: nil ) setEmail(user.email) Error: value of optional type 'String?' not unwrapped; Did you mean to use '!' or '?'?
57. Types!
58. Types!
59. Super Scientific Chart™ v6.10 v6.14 v6.20 v6.24 % Swift % Users with Crash
60. Super Scientific Chart™ v6.10 v6.14 v6.20 v6.24 % Static Types % Bad Time
68. Selling point to writing safe code
69. Bugs are surprises
70. Static types reduce surprises
71. Static types reduce bugs
73. Flow TypeScript &
74. What’s new in ES2030
75. What’s next
76. Elm
77. Generate JavaScript with great performance and no runtime exceptions. “
78. NoRedInk has 80k+ lines of Elm, and after more than a year in production, it still has not produced a single runtime exception. “
81. increment : Int -> Int increment n = n + 1
82. increment : Int -> Int increment n = n + 1 increment “wat"
83. -- TYPE MISMATCH ---------------------------- The argument to function `increment` is causing a mismatch. 5| increment "wat" ^^^^^ Function `increment` is expecting the argument to be: Int But it is: String
84. type Primary = Red | Green | Blue
85. type Primary = Red | Green | Blue mixedUpCaseBranches primary = case primary of Red -> "red" Green -> "green" Blue -> False
86. type Primary = Red | Green | Blue mixedUpCaseBranches primary = case primary of Red -> "red" Green -> "green" Blue -> False
87. The 2nd and 3rd branches of this `case` produce different types of values. 9| case primary of 10| Red -> 11| "red" 12| 13| Green -> 14| "green" 15| 16| Blue -> 17|> False The 2nd branch has this type: String But the 3rd is: Bool
88. -- TYPE MISMATCH --------------------------------- The right side of (==) is causing a type mismatch. 3| ["Alice"] == [True] ^^^^^^ (==) is expecting the right side to be a: List String But the right side is: List Bool Hint: With operators like (==) I always check the left side first. If it seems fine, I assume it is correct and check the right side. So the problem may be in how the left and right arguments interact.
90. Based on the version number listed in your elm-package.json file, it will run a diff and figure out the magnitude of the changes. It will then tell you your new version number! “
92. Elm
93. OCaml
95. Syntax Toolchain &
96. Reason lets you write simple, fast and quality type safe code “
97. type schoolPerson = | Teacher | Director | Student string;
98. type schoolPerson = | Teacher | Director | Student string; let greeting stranger => switch stranger { | Teacher => "Hey professor!" | Director => "Hello director." | Student anyOtherName => "Hey, " ^ anyOtherName ^ "." };
99. type schoolPerson = | Teacher | Director | Student string; let greeting stranger => switch stranger { | Teacher => "Hey professor!" | Director => "Hello director." | Student anyOtherName => "Hey, " ^ anyOtherName ^ "." }; greeting (Student “Eli”); /* “Hey, Eli.” */
100. type schoolPerson = | Teacher | Director | Student string; let greeting stranger => switch stranger { | Teacher => "Hey professor!" | Director => "Hello director." | Student anyOtherName => "Hey, " ^ anyOtherName ^ "." }; greeting Teacher; /* “Hey professor!.” */
101. type schoolPerson = | Teacher | Director | Student string; let greeting stranger => switch stranger { | Teacher => "Hey professor!" | Director => "Hello director.” | Student "Richard" => "Still here Ricky?" | Student anyOtherName => "Hey, " ^ anyOtherName ^ "." }; greeting (Student “Richard”); /* “Still here Ricky?” */
102. type schoolPerson = | Teacher | Director | Student string; let greeting stranger => switch stranger { | Teacher => "Hey professor!" | Director => "Hello director.” }; Warning 6: this pattern-matching is not exhaustive. Here is an example of a value that is not matched: Student
103. type schoolPerson = | Teacher | Director | Student string; let greeting stranger => switch stranger { | Teacher => "Hey professor!" | Director => "Hello director.” }; Warning 6: this pattern-matching is not exhaustive. Here is an example of a value that is not matched: Student
104. Messenger 50 ~ %
105. Messenger 50 10 ~ % BUGS
107. Bugs are surprises
108. Static types reduce surprises
109. Static types reduce bugs
110. Why Static Typing Matters (or How to Solve All Your Runtime Errors With This One Neat Trick)
111. Flow: https://flow.org TypeScript: https://www.typescriptlang.org/ Swift: https://swift.org/ Elm: http://elm-lang.org/ Reason: https://reasonml.github.io Dan Grossman, Programming Languages course: https://www.coursera.org/learn/ programming-languages Brandon Williams - Proof in Functions: https:// vimeo.com/121953811
112. Thanks! Eli Perkins @_eliperkins https://eliperkins.me https://clubhouse.io