Tutorial Phoenix framework

Workshop realizado no evento Python sudeste no dia 03/09/2016.
Foram mostrados os conceitos básicos de programação funcional e o básico do Elixir como tipos de dados, condicionais e loops. Depois expliquei como funciona o framework Phoenix e fizemos juntos um pequeno aplicativo de chat usando channels.
Repositório do chat: https://github.com/arthurbragaa/phoenix-chat-pyse

Transcript

1. Tutorial Phoenix Framework Arthur Braga Alfredo 1
2. O que será ensinado hoje? 2
3. 1ª parte: Elixir História Conceitos de programação funcional Pattern Matching Tipos de dados Módulos e funções nomeadas Condicionais Loops Mix 3
4. 2ª parte: Phoenix Criação do projeto Estrutura de arquivos Rotas e pipeline Controllers, Models, Templates e Views Ecto Geradores Channels 4
5. O que não vou falar OTP Nodes Supervisores Macros Protocolos 5
6. História 6
7. 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 7
8. Teoria das funções recursivas - 1931. Considerado um dos mais importantes lógicos que já existiu. Kurt Gödel 8
9. 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 9
10. LISP foi criado no MIT em 1960 ISWIM em 1966 SASL em 1973 Miranda e Erlang em 1986 Haskell em 1992 Primeiras Linguagens 10
11. Quais as vantagens das linguagens funcionais? 11
12. Imutabilidade 12
13. Poucos problemas de concorrência 13
14. Mais fácil de testar 14
15. Menos código = Facilidade de manutenção 15
16. Porque ficou mais nas universidades? 16
17. 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 17
18. John W. Backus Turing award em 1977. “Linguagens de programação convencionais estão ficando cada vez maiores, mas não mais fortes.” 18
19. Memória era muito cara 19
20. Os computadores era lentos 20
21. Programação paralela estava engatinhando 21
22. Multi-processadores também 22
23. E Nem se falava em multi- core 23
24. Mas muita coisa mudou 24
25. Memória 25
26. Multi-core 26
27. Multi-processador 27
28. Mas tem um porém 28
29. The free lunch is over 29
30. Elixir 30
31. Brasileiro. Fez parte do core team do rails. Participou de muitos projetos open source. Decidiu criar a linguagem Elixir em 2013. José Valim 31
32. Objetivo Criar uma linguagem que que possibilitasse alta performance, extensibilidade e produtividade e que rodasse na VM do Erlang. 32
33. Porque Erlang? Criado em 1986 para resolver problemas na área de telefonia. Altamente tolerante a falhas. Altamente concorrente. Fácil de escalar. 33
34. Porque Erlang? https://blog.whatsapp.com/196/1-million-is-so-2011 34
35. Descobriu Elixir em 2013. Desenvolveu uma biblioteca de websockets. Viu a oportunidade de criar um framework com foco em produtividade no estilo do rails. Chris McCord 35
36. Timeline Dezembro de 2013: Início do desenvolvimento do Phoenix. Setembro de 2014: José Valim entra para o Core Team. Agosto de 2015: Lançada versão 1.0 36
37. O que é programação funcional? 37
38. É 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 38
39. Conceitos 39
40. Imutabilidade Uma vez que uma variável é criada, seu valor não pode mais ser alterado. 40
41. Imutabilidade Eshell V8.0.3 1> A = 10. 10 2> A = 20. ** exception error: no match of right hand side value 20 41
42. Imutabilidade Interactive Elixir (1.3.2) iex(1)> a = 10 10 iex(2)> a = 20 20 42
43. Imutável? 43
44. Single matching A variável não pode mais ser reutilizada. 44
45. Imutabilidade Interactive Elixir (1.3.2) iex(4)> a = 10 10 iex(5)> ^a = 20 ** (MatchError) no match of right hand side value: 20 45
46. Rebinding O valor na memória continua imutável, mas a variável pode ser reutilizada. 46
47. 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" 47
48. 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. 48
49. 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] 49
50. Funções puras São aquelas que não causam efeitos colaterais, ou seja, não interagem com recursos externos. 50
51. Higher-order functions São funções que recebem ou retornam outras funções. 51
52. 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] 52
53. Recursão São funções que chamam elas mesmas. 53
54. Recursão defmodule Fatorial do def de(1), do: 1 def de(n) when n > 0 do n * de(n-1) end end 54
55. 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 55
56. Pattern Matching iex> {a, b, c} = {:hello, "world"} ** (MatchError) no match of right hand side value: {:hello, "world"} 56
57. Pattern Matching iex> {:ok, result} = {:ok, 13} {:ok, 13} iex> result 13 iex> {:ok, result} = {:error, :oops} ** (MatchError) no match of right hand side value: {:error, :oops} 57
58. Pattern Matching iex> [head | tail] = [1, 2, 3] [1, 2, 3] iex> head 1 iex> tail [2, 3] 58
59. 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 59
60. Pattern Matching - Pin operator iex> x = 1 1 iex> ^x = 2 ** (MatchError) no match of right hand side value: 2 iex> {y, ^x} = {2, 1} {2, 1} iex> y 2 iex> {y, ^x} = {2, 2} ** (MatchError) no match of right hand side value: {2, 2} 60
61. Pipe operator ( |> ) Transforma o valor anterior como primeiro argumento da próxima função. 61
62. Operador Pipe (|>) foo(bar(baz(new_function(other_function())))) 62
63. Operador Pipe (|>) other_function() |> new_function() |> baz() |> bar() |> foo() "Elixir rocks" |> String.upcase |> String.split ["ELIXIR", "ROCKS"] "elixir" |> String.ends_with?("ixir") true 63
64. Elixir 64
65. Tipos de dados iex> 1 # integer iex> 0x1F # integer iex> 1.0 # float iex> true # boolean iex> :atom # atom / symbol iex> "elixir" # string iex> 'elixir' # char list iex> [1, 2, 3] # list iex> {1, 2, 3} # tuple 65
66. Controles de fluxo 66
67. If iex> lang = "Elixir" "Elixir" ...> if lang do ...> IO.puts lang ...> end Elixir :ok iex> lang = "Phyton" "Phyton" iex> if lang == "Elixir" do ...> IO.puts lang ...> else ...> IO.puts "Não é elixir" ...> end Não é elixir :ok 67
68. Unless iex> lang = "Elixir" "Elixir" ...> unless lang do ...> IO.puts lang ...> end nil :ok iex> lang = "Phyton" "Phyton" iex> unless lang == "Elixir" do ...> IO.puts lang ...> end Python :ok 68
69. Cond iex> cond do ...> 2 + 2 == 5 -> ...> "Falso" ...> 2 * 2 == 3 -> ...> "Falso" ...> 1 + 1 == 2 -> ...> "Verdadeiro" ...> true -> ...> "Se nada der certo chega aqui" ...> end "Verdadeiro" 69
70. Case case {1, 2, 3} do {4, 5, 6} -> "Não vai dar match" {1, x, 3} -> "Vai dar match e o x vai receber o valor 2" _ -> "Essa clausula vai dar match em qualquer valor" end "Vai dar match e o x vai receber o valor 2" 70
71. Case case {1, 2, 3} do {4, 5, 6} -> "Não vai dar match" {1, ^x, 3} -> "Vai dar match e o x vai receber o valor 2" _ -> "Essa clausula vai dar match em qualquer valor" end "Essa clausula vai dar match em qualquer valor" 71
72. Case calcular = fn expressao -> case expressao do {:+, num1, num2} -> num1 + num2 {:-, num1, num2} -> num1 - num2 {:*, num1, num2} -> num1 * num2 {:/, num1, num2} -> num1 / num2 end end calcular.({:+, 2 ,2}) 4 calcular.({:-, 2 ,2}) 0 calcular.({:/, 2 ,0}) ** (ArithmeticError) bad argument in arithmetic expression :erlang./(2, 0) 72
73. Módulos e funções 73
74. Módulos iex> defmodule Math do ...> def sum(a, b) do ...> a + b ...> end ...> end Math.sum(1,2) #=> 3 74
75. Funções defmodule Math do def sum(a, b) do do_sum(a, b) end defp do_sum(a, b) do a + b end end IO.puts Math.sum(1, 2) #=> 3 IO.puts Math.do_sum(1, 2) #=> ** (UndefinedFunctionError) 75
76. Funções defmodule Math do def zero?(0), do: true def zero?(x) when is_integer(x), do: false end 76
77. Guard clauses calcular = fn expressao -> case expressao do {:+, num1, num2} -> num1 + num2 {:-, num1, num2} -> num1 - num2 {:*, num1, num2} -> num1 * num2 {:/, num1, num2} when num2 != 0 -> num1 / num2 {:/, num1, num2} when num2 == 0 -> IO.puts "Não é possível dividir por 0" end end calcular.({:/, 2, 0}) Não é possível dividir por 0 :ok calcular.({:/, 2, 1}) 2.0 77
78. Fatorial defmodule Fatorial do def de(1), do: 1 def de(n) when n > 0 do n * de(n-1) end end 78
79. Fatorial defmodule Fatorial do def de(1, acc), do: acc def de(n, acc) when n > 0 do de(n-1, acc * n) end end 79
80. Tail call optimization 80
81. Tail call optimization 81
82. Arquivos ex e exs .ex: Arquivos que serão compilados. .exs: Arquivos que serão interpretados. 82
83. Arquivos ex e exs Se o arquivo precisar ser muito rápido, use o ex pois arquivo exs é compilado em tempo de execução. Os arquivos de teste normalmente utilizam .exs para não precisar compilar toda vez que os testes rodarem 83
84. Mix Fornece ferramentas e utilidades para trabalhar com Elixir 84
85. Hex.pm 85
86. Live coding: Chat com phoenix 86
87. Onde aprender mais 87
88. Onde aprender mais 88
89. Onde aprender mais #myelixirstatus 89
90. Onde aprender mais 90
91. Muito obrigado 91