Introdução a programação funcional com Elixir v2

Slide 1

Slide 1 text

Introdução a programação funcional com Elixir Arthur Braga Alfredo 1

Slide 2

Slide 2 text

Sobre o que vou falar História da programação funcional História do Elixir Conceitos básicos de programação funcional Livros e recursos para aprofundar 2

Slide 3

Slide 3 text

História 3

Slide 4

Slide 4 text

Teoria da Lógica combinatória - 1927. Base para o design das linguagens de programação funcionais. Higher-order functions. As linguagens funcionais Haskell, Brooks, Curry e o conceito currying foram homenagens a ele. Haskell Curry 4

Slide 5

Slide 5 text

Teoria das funções recursivas - 1931. Considerado um dos mais importantes lógicos que já existiu. Kurt Gödel 5

Slide 6

Slide 6 text

Teoria do cálculo lambda - 1936 Funções anônimas Influenciou o design do LISP e das linguagens de programação funcionais em geral. Conceitos de abstração. Linguagens de alto nível. Alonzo Church 6

Slide 7

Slide 7 text

LISP foi criado no MIT em 1960 ISWIM em 1966 SASL em 1973 Miranda e Erlang em 1986 Haskell em 1992 Primeiras Linguagens 7

Slide 8

Slide 8 text

Quais as vantagens das linguagens funcionais? 8

Slide 9

Slide 9 text

Imutabilidade 9

Slide 10

Slide 10 text

Poucos problemas de concorrência 10

Slide 11

Slide 11 text

Mais fácil de testar 11

Slide 12

Slide 12 text

Menos código = Facilidade de manutenção 12

Slide 13

Slide 13 text

Porque ficou mais nas universidades? 13

Slide 14

Slide 14 text

Criador da linguagem Fortran - 1950. Criada dentro da IBM. Primeira linguagem de alto nível. Dominou a área de programação. Continua sendo usada até hoje em super computadores. . John W. Backus 14

Slide 15

Slide 15 text

John W. Backus Turing award em 1977. “Linguagens de programação convencionais estão ﬁcando cada vez maiores, mas não mais fortes.” 15

Slide 16

Slide 16 text

Memória era muito cara 16

Slide 17

Slide 17 text

Os computadores era lentos 17

Slide 18

Slide 18 text

Programação paralela estava engatinhando 18

Slide 19

Slide 19 text

Multi-processadores também 19

Slide 20

Slide 20 text

E Nem se falava em multi- core 20

Slide 21

Slide 21 text

Mas muita coisa mudou 21

Slide 22

Slide 22 text

Memória 22

Slide 23

Slide 23 text

Multi-core 23

Slide 24

Slide 24 text

Multi-processador 24

Slide 25

Slide 25 text

Mas tem um porém 25

Slide 26

Slide 26 text

The free lunch is over 26

Slide 27

Slide 27 text

Elixir 27

Slide 28

Slide 28 text

Brasileiro. Fez parte do core team do rails. Participou de muitos projetos open source. Decidiu criar a linguagem Elixir em 2012. José Valim 28

Slide 29

Slide 29 text

Objetivo Criar uma linguagem que que possibilitasse alta performance, extensibilidade e produtividade e que rodasse na VM do Erlang. 29

Slide 30

Slide 30 text

Porque Erlang? Criado em 1986 para resolver problemas na área de telefonia. Altamente tolerante a falhas. Altamente concorrente. Fácil de escalar. 30

Slide 31

Slide 31 text

Porque Erlang? https://blog.whatsapp.com/196/1-million-is-so-2011 31

Slide 32

Slide 32 text

Conceitos 32

Slide 33

Slide 33 text

O que é programação funcional? 33

Slide 34

Slide 34 text

É um paradigma de programação que trata a computação como uma avaliação de funções matemáticas e que evita estados ou dados mutáveis 34

Slide 35

Slide 35 text

Imutabilidade Uma vez que uma variável é criada, seu valor não pode mais ser alterado. 35

Slide 36

Slide 36 text

Imutabilidade Eshell V8.0.3 1> A = 10. 10 2> A = 20. ** exception error: no match of right hand side value 20 36

Slide 37

Slide 37 text

Imutabilidade Interactive Elixir (1.3.2) iex(1)> a = 10 10 iex(2)> a = 20 20 37

Slide 38

Slide 38 text

Imutável? 38

Slide 39

Slide 39 text

Single matching A variável não pode mais ser reutilizada. 39

Slide 40

Slide 40 text

Imutabilidade Interactive Elixir (1.3.2) iex(4)> a = 10 10 iex(5)> ^a = 20 ** (MatchError) no match of right hand side value: 20 40

Slide 41

Slide 41 text

Rebinding O valor na memória continua imutável, mas a variável pode ser reutilizada. 41

Slide 42

Slide 42 text

Imutabilidade iex(12)> soma = 25 25 iex(13)> func_soma = fn -> "A soma é #{ soma }" end #Function<20.52032458/0 in :erl_eval.expr/5> iex(14)> soma = 100 100 iex(17)> func_soma.() "A soma é 25" 42

Slide 43

Slide 43 text

Funções anônimas São funções que podem ser tratadas como valores e que podem ser manipuladas ou retornadas por outras funções. 43

Slide 44

Slide 44 text

Funções anônimas soma10 = fn (x) -> x + 10 end soma10.(20) # => 30 multiplica = fn x,y -> x * y end multiplica.(10,10) # => 100 lista = [1,2,3,4,5] Enum.map(lista, soma10) [11, 12, 13, 14, 15, 16] 44

Slide 45

Slide 45 text

Funções puras Funções sem efeitos colaterais Não acessam banco Não acessam arquivos Vão sempre retornar os mesmo valores se os mesmos parâmetros forem passados 45

Slide 46

Slide 46 text

Higher-order functions São funções que recebem ou retornam outras funções. 46

Slide 47

Slide 47 text

Higher-order functions lista = [1,2,3,4,5] [1, 2, 3, 4, 5] Enum.map(lista, fn x -> x * x end) [1, 4, 9, 16, 25] Enum.reduce(lista, 0, fn(x,y) -> x + y end) 15 Enum.reduce(lista, 0, &(&1 + &2)) 15 Enum.filter(lista, fn x -> x > 2 end) [3, 4, 5] 47

Slide 48

Slide 48 text

Pattern Matching iex> {a, b, c} = {:hello, "world", 42} {:hello, "world", 42} iex> a :hello iex> b "world" iex> {a, _, c} = {:hello, "world", 42} {:hello, "world", 42} iex> a :hello iex> c 42 48

Slide 49

Slide 49 text

Pattern Matching iex> {a, b, c} = {:hello, "world"} ** (MatchError) no match of right hand side value: {:hello, "world"} 49

Slide 50

Slide 50 text

Pattern Matching iex> {:ok, user} = %User{name: "john_cusack", email: "[email protected]"} |> Repo.insert iex> user %User{id:1, name: "john_cusack", email: "[email protected]"} iex> {:ok, result} = {:error, :oops} ** (MatchError) no match of right hand side value: {:error, :oops} 50

Slide 51

Slide 51 text

Pattern Matching iex> [head | tail] = [1, 2, 3] [1, 2, 3] iex> head 1 iex> tail [2, 3] 51

Slide 52

Slide 52 text

Pattern Matching defmodule Math do def sum_list([head | tail], accumulator) do sum_list(tail, head + accumulator) end def sum_list([], accumulator) do accumulator end end IO.puts Math.sum_list([1, 2, 3], 0) #=> 6 52

Slide 53

Slide 53 text

Recursão São funções que chamam elas mesmas. 53

Slide 54

Slide 54 text

defmodule Fatorial do def de(1), do: 1 def de(n) when n > 0 do n * de(n-1) end end Recursão 54

Slide 55

Slide 55 text

Pipe operator ( |> ) Usa o valor anterior ao pipe como primeiro argumento da próxima função. 55

Slide 56

Slide 56 text

Operador Pipe (|>) foo(bar(baz(new_function(other_function())))) 56

Slide 57

Slide 57 text

Slide 58

Slide 58 text

Onde aprender mais? 58

Slide 59

Slide 59 text

Onde aprender mais? http://elixir-lang.org/ 59

Slide 60

Slide 60 text

#myelixirstatus 60

Slide 61

Slide 61 text

Onde aprender mais? Y Not- Adventures in Functional Programming by Jim Weirich - https://www.youtube.com/watch?v=FITJMJjASUs Ruby Manor 3 - Programming with Nothing by Tom Stuart - https://www.youtube.com/watch?v=VUhlNx_-wYk https://medium.com/the-many/learning-elixir-at-made-by-many- 557737dafe55#.1hfu0fh8o 61