Tutorial Phoenix framework

Tutorial

Phoenix Framework

Arthur Braga Alfredo

1

O que será ensinado hoje?

2

1ª parte: Elixir

HistóriaConceitos de programação funcionalPattern MatchingTipos de dadosMódulos e funções nomeadasCondicionaisLoopsMix

3

2ª parte: Phoenix

Criação do projetoEstrutura de arquivosRotas e pipelineControllers, Models, Templates e ViewsEctoGeradoresChannels

4

O que não vou falar

OTPNodesSupervisoresMacrosProtocolos

5

História

6

Teoria da Lógica combinatória - 1927.

Base para o design das linguagens deprogramação funcionais.

Higher-order functions.

As linguagens funcionais Haskell, Brooks,Curry e o conceito currying foramhomenagens a ele.

Haskell Curry

7

Teoria das funções recursivas - 1931.

Considerado um dos mais importanteslógicos que já existiu.

Kurt Gödel

8

Teoria do cálculo lambda - 1936

Funções anônimas

Influenciou o design do LISP e daslinguagens de programação funcionaisem geral.

Conceitos de abstração.

Linguagens de alto nível.

Alonzo Church

9

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

Primeiras Linguagens

10

Quais as vantagens daslinguagens funcionais?

11

Imutabilidade

12

Poucos problemas deconcorrência

13

Mais fácil de testar

14

Menos código = Facilidadede manutenção

15

Porque ficou mais nasuniversidades?

16

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

John W. Backus

Turing award em 1977.

“Linguagens de programação convencionais estão ficando

cada vez maiores, mas não mais fortes.”

18

Memória era muito cara

19

Os computadores era lentos

20

Programação paralelaestava engatinhando

21

Multi-processadores também

22

E Nem se falava em multi-core

23

Mas muita coisa mudou

24

Memória

25

Multi-core

26

Multi-processador

27

Mas tem um porém

28

The free lunch is over

29

http://www.gotw.ca/publications/concurrency-ddj.htm

Elixir

30

Brasileiro.

Fez parte do core team do rails.

Participou de muitos projetos open source.

Decidiu criar a linguagem Elixir em 2013.

José Valim

31

Objetivo

Criar uma linguagem que que possibilitasse altaperformance, extensibilidade e produtividade e

que rodasse na VM do Erlang.

32

Porque Erlang?

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

33

Porque Erlang?

https://blog.whatsapp.com/196/1-million-is-so-2011

34

Descobriu Elixir em 2013.Desenvolveu uma biblioteca dewebsockets.Viu a oportunidade de criar umframework com foco em produtividadeno estilo do rails.

Chris McCord

35

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

O que é programaçãofuncional?

37

É um paradigma de programação que trata acomputação como uma avaliação de funções

matemáticas e que evita estados ou dadosmutáveis

38

Conceitos

39

Imutabilidade

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

alterado.

40

Imutabilidade

Eshell V8.0.3

1> A = 10.102> A = 20. ** exception error: no match of right hand side value 20

41

Imutabilidade

Interactive Elixir (1.3.2)

iex(1)> a = 1010iex(2)> a = 2020

42

Imutável?

43

Single matching

A variável não pode mais serreutilizada.

44

Imutabilidade

Interactive Elixir (1.3.2)

iex(4)> a = 1010iex(5)> ^a = 20** (MatchError) no match of right hand side value: 20

45

Rebinding

O valor na memória continuaimutável, mas a variável pode ser

reutilizada.

46

Imutabilidade

iex(12)> soma = 2525

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

iex(14)> soma = 100100

iex(17)> func_soma.()"A soma é 25"

47

Funções anônimas

São funções que podem ser tratadascomo valores e que podem ser

manipuladas ou retornadas por outrasfunções.

48

Funções anônimas

soma10 = fn (x) -> x + 10 endsoma10.(20) # => 30

multiplica = fn x,y -> x * y endmultiplica.(10,10) # => 100

lista = [1,2,3,4,5]

Enum.map(lista, soma10) [11, 12, 13, 14, 15, 16]

49

Funções puras

São aquelas que não causamefeitos colaterais, ou seja, não

interagem com recursos externos.

50

Higher-order functions

São funções que recebem ouretornam outras funções.

51

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

Recursão

São funções que chamam elasmesmas.

53

Recursão

defmodule Fatorial do def de(1), do: 1 def de(n) when n > 0 do n * de(n-1) endend

54

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> c42

55

Pattern Matching

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

56

Pattern Matching

iex> {:ok, result} = {:ok, 13}{:ok, 13}

iex> result13

iex> {:ok, result} = {:error, :oops}** (MatchError) no match of right hand side value: {:error, :oops}

57

Pattern Matching

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

iex> head1

iex> tail[2, 3]

58

Pattern Matching

defmodule Math do def sum_list([head | tail], accumulator) do sum_list(tail, head + accumulator) end

def sum_list([], accumulator) do accumulator endend

IO.puts Math.sum_list([1, 2, 3], 0) #=> 6

59

Pattern Matching - Pin operator

iex> x = 11

iex> ^x = 2** (MatchError) no match of right hand side value: 2

iex> {y, ^x} = {2, 1}{2, 1}

iex> y2

iex> {y, ^x} = {2, 2}** (MatchError) no match of right hand side value: {2, 2}

60

Pipe operator ( |> )

Transforma o valor anterior como primeiroargumento da próxima função.

61

Operador Pipe (|>)

foo(bar(baz(new_function(other_function()))))

62

Elixir

64

Tipos de dados

iex> 1 # integeriex> 0x1F # integeriex> 1.0 # floatiex> true # booleaniex> :atom # atom / symboliex> "elixir" # stringiex> 'elixir' # char listiex> [1, 2, 3] # listiex> {1, 2, 3} # tuple

65

Controles de fluxo

66

If

iex> lang = "Elixir""Elixir"...> if lang do...> IO.puts lang...> endElixir: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

Unless

iex> lang = "Elixir""Elixir"...> unless lang do...> IO.puts lang...> endnil:ok

iex> lang = "Phyton" "Phyton"iex> unless lang == "Elixir" do ...> IO.puts lang ...> end Python:ok

68

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

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

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

Case

calcular = fn expressao -> case expressao do {:+, num1, num2} -> num1 + num2 {:-, num1, num2} -> num1 - num2 {:*, num1, num2} -> num1 * num2 {:/, num1, num2} -> num1 / num2 endend

calcular.({:+, 2 ,2})4calcular.({:-, 2 ,2})0calcular.({:/, 2 ,0})** (ArithmeticError) bad argument in arithmetic expression :erlang./(2, 0)

72

Módulos e funções

73

Módulos

iex> defmodule Math do...> def sum(a, b) do...> a + b...> end...> end

Math.sum(1,2) #=> 3

74

Funções

defmodule Math do def sum(a, b) do do_sum(a, b) end

defp do_sum(a, b) do a + b endend

IO.puts Math.sum(1, 2) #=> 3IO.puts Math.do_sum(1, 2) #=> ** (UndefinedFunctionError)

75

Funções

defmodule Math do def zero?(0), do: true def zero?(x) when is_integer(x), do: falseend

76

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" endend

calcular.({:/, 2, 0})Não é possível dividir por 0:ok

calcular.({:/, 2, 1})2.0

77

Fatorial

defmodule Fatorial do def de(1), do: 1 def de(n) when n > 0 do n * de(n-1) endend

78

Fatorial

defmodule Fatorial do def de(1, acc), do: acc def de(n, acc) when n > 0 do de(n-1, acc * n) endend

79

Tail call optimization

80

Tail call optimization

81

Arquivos ex e exs

.ex: Arquivos que serão compilados.

.exs: Arquivos que serão interpretados.

82

Arquivos ex e exs

Se o arquivo precisar ser muito rápido, use o expois arquivo exs é compilado em tempo deexecução.

Os arquivos de teste normalmente utilizam .exspara não precisar compilar toda vez que os testesrodarem

83

Mix

Fornece ferramentas e utilidades paratrabalhar com Elixir

84

Hex.pm

85

Live coding: Chat com phoenix

86

Onde aprender mais

87

Onde aprender mais

88

Onde aprender mais

#myelixirstatus

89

Onde aprender mais

90

Muito obrigado

91

Tutorial Phoenix framework

Software

Transcript of Tutorial Phoenix framework