Introduction to type systems & Elm

A different introduction to functional programming in Elm through types and type systems.

Transcript

1. Introduction to type systems & ELM
2. $ cat whoami.elm name : Anler twitter: @anler tech : PHP -> Python -> JS -> Scala
3. $ cat whoami.elm name : Anler twitter: @anler tech : PHP -> Python -> JS -> Scala
4. Disclaimer This is not a rant, this is a sales pitch. I don’t want to attack your community, but I do want to steal some brains for mine I love the work you do as a community and I wish we could have the same in ours.
5. The need of a type system
6. History of Programming as seen from JS JavaScript Assembly M aintainability problem s C Java
7. History of Programming as seen from JS JavaScript Assembly M aintainability problem s M em ory m anagem ent
 problem s C Java
8. History of Programming as seen from JS JavaScript Assembly M aintainability problem s M em ory m anagem ent
 problem s Expressivity problem s C Java
9. History of Programming as seen from JS JavaScript Assembly M aintainability problem s M em ory m anagem ent
 problem s Expressivity problem s M aintainability problem s C Java
10. There’s a limit in the amount of things we can handle at a time. In order to increase that limit we need abstractions
11. But with abstractions there come other problems: maintainability, debugging, learning curve
12. Learning curve is solved with familiarity
13. Debugging is solved with tooling
14. But for solving maintainability we need something else…
15. Stop thinking: I don’t need this nonsense
16. Before thinking “Why should I learn yet another language…” let’s keep our minds open.
17. “Technology changes quickly, people’s minds change slowly”
18. Same situation in the past Assembly Binary
19. "why would you want more than machine language?”
20. Same situation in the past Fortran Assembly
21. “Can programming be liberated from the Von Neumann Style?
23. Same situation in the past Functional Imperative Static Types Dynamic Types Types Tests … …
24. Typesystems & Methods for ensuring correctness
25. When writing software, program correctness is an issue of increasing importance because we are living in a world with increasing reliance on computer programs
26. Formal methods Algebraic Specification Languages Denotational Semantics Hoare Logic Modal Logics
27. Lightweight Formal methods (of much more modest power) Model checkers Run-time monitoring Type systems the most popular
28. A type system is a tractable syntactic method for proving the absence of certain program behaviours by classifying phrases according to the kinds of values they compute
29. Strong Weak Static Dynamic The type system is more pedantic and usually forces you to be more explicit. Ex: 
 - 3 + “hola” is not accepted ❌ - if “hola” … ❌ The type system is less strict and usually performs implicit conversions
 for you. Ex: - 3 + “hola” is accepted ✅ - if “hola” … is accepted ✅ The type analysis of expressions is performed at compile time. The type analysis of expressions is performed at run time.
30. Strong Weak Static Dynamic
31. A type system is usually conservative, it has to be because a type system can prove the absence of some bad program behaviours, but they cannot prove their presence!
32. A type system is usually conservative, it has to be because a type system can prove the absence of some bad program behaviours, but they cannot prove their presence! Program testing can be used to prove the presence of bugs, but never show their absence!
33. Type systems and testing complement
34. What type systems are good for?
35. Detecting errors
 Documentation Abstraction Language Safety Efficiency What type systems are good for?
36. Detecting errors
 Documentation Abstraction Language Safety Efficiency What type systems are good for?
37. Detecting errors
 Documentation Abstraction Language Safety Efficiency Those are key for effective Functional Programming What type systems are good for? And here I will talk again about FP :P
38. When I refer to FP I mean constructing the whole program as a composition of referentially transparent functions, not programs where you just use map, filter or lambdas.
39. FP + Type System + Testing
40. Why Functional Programming?
41. What are the advantages of Functional Programming?
42. 1. Functions are very simple Output ➡ Input ➡
43. 2. Functions are declarative Output ➡ Input
44. 3. Functions always compose ➡ ➡ ➡ The same can’t be said of OOP, the answer would be: it depends. Also I don’t refer to JS functions, those are procedures and their composition is not guaranteed
45. Composition is the way of controlling complexity
46. FP problems when used outside functional languages
47. No Tail Call Elimination
 FP langs transform tail-call (mutually-)recursive functions into while loops Performance penalty of using functions FP langs eliminate functions by inlining-them Performance penalty of boxed data types FP langs eliminate those boxes FP problems when used outside functional languages
52. Greenspun’s Tenth Rule: 
 
 Any sufficiently complicated C or Fortran program contains an ad hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp. Steele & Crockford’s Corollary: 
 
 Any sufficiently interesting JavaScript library contains an ad hoc, informally-specified, bug-ridden, slow implementation of half of Haskell.
53. Functional programming outside functional langs is just too expensive.
54. That’s the main selling point of Elm/ PureScript/Haskell
55. Why ELM?
56. Elm is a purely-functional static programming language for frontend web development, that forces the usage of total functions and thus is claimed as a zero- runtime errors language.
57. A total function length : List a -> Int
58. A partial function head : List a -> a
59. What happens if the list if empty? head : List a -> a
60. head : List a -> a If you invent a new value null and treat it as an ‘a’ you are augmenting the set ‘a’ with a new possibility (null) that has to be checked always. What happens if the list if empty?
61. a
62. a ⋃ null This looks like inheritance in OOP
63. A partial (useless) total function because null will never have the same properties as a head : List a -> a someOp = head [] + 3 Nonsense, null with a number has no well defined meaning! This leads to null propagation. null
65. Elm has no null, instead you use the Maybe type to express possibility of a value that might not be there.
66. a Nothing The Maybe a type
67. A partial total function head : List a -> Maybe a someOp = withDefault 0 (head []) + 3 We are forced to contemplate the possibility of failure and act
 accordingly Nothing Maybe
68. ELM 101
69. Introduction to types
70. What is a type?
71. A type is a name for a collection of values : Bool True False The Bool type Inhabitants
72. The singleton or unit type : () () The empty tuple
 type 1 inhabitant
73. The empty or void type : Never The Never type No inhabitants
74. What are the most common types?
75. a -> b String Char Bool number The type of functions from a to b The type of all strings The type of all characters The type of all bool (True and False) The type of all 
 numbers
76. What is a constructor?
77. A constructor is the constant that represents or the function that constructs a value of a type : Bool True False I’m the constant representing the falsy value I’m the constant representing the truthy value
78. What is a data type declaration?
79. It is a way of defining a new type or a shape that represents several types type Bool = True | False > True : Bool > False : Bool Bool type defined Type can be constructed with either True or False constants (product)
80. These are the lego pieces (the primitive data types)
81. It is a way of defining a new type or a shape that represents several types type Duple a b = Duple a b
 
 > Duple True False
 : Duple Bool Bool
 > Duple “hello” ‘h’
 : Duple String Char Shape of all the duple types defined I’m the function that knows how to construct a value of type ‘Duple a b’ Need both: a and b (coproduct or sum)
82. The context provides the info you need: List: non-determinism Maybe: Failure Tuple: Alternation
83. What is a type alias declaration?
84. It is just another name for an existing type or type shape type alias Binary = Bool
85. What is a record type?
86. It is just like a named tuple > r = { x = “foo”, y = False } r : { x : String, y : Bool } > r.x “foo” : String > r.y False : Bool
87. What is pattern matching?
88. It is the way to know which constructor was used for creating a value of a given data type case boolValue of True -> “created by True” False -> “created by False” case stringValue of “hi” -> “created by “hi”” _ -> “dunno”
89. Static html example
94. Dynamic html example
108. Wrapping Up
109. Functional programming combined with a good type system is a very good idea, maximises the advantages of each one (FP & type systems) and gives the developer more grip at controlling a project’s complexity because it makes explicit the side-effects in your application and brings them under control. 109
110. There’s no silver bullet
111. Programming languages are all about tradeoffs. In my case I’m more inclined to give up on a lot of things in exchange of fewer runtime errors.
112. website: elm-lang.org website: pragmaticstudio.com/courses/elm book: The little MLer book: Types and Programming Languages Resources
113. THANK YOU!