Tweet
Tweet

Slide 1

Slide 1 text

Mantendo sistemas em Ruby & Elixir RubyConf+ 2022

Slide 2

Slide 2 text

Elixir + Ruby

Slide 3

Slide 3 text

Desenvolvedora/Engenheira de Software (desde 2008) Bacharela em Engenharia da Computação Mestra em Ciência da Computação ELAINE NAOMI WATANABE twitter.com/elaine_nw speakerdeck.com/elainenaomi slides disponíveis

Slide 4

Slide 4 text

Parte I Conhecendo Elixir Parte II Vivendo entre dois mundos Parte III Barreiras no caminho

Slide 5

Slide 5 text

No content

Slide 6

Slide 6 text

PARTE I Conhecendo Elixir

Slide 7

Slide 7 text

No content

Slide 8

Slide 8 text

Linguagem de programação ELIXIR

Slide 9

Slide 9 text

Linguagem de programação Muitas pessoas da comunidade Ruby ELIXIR

Slide 10

Slide 10 text

#TRETAS

Slide 11

Slide 11 text

Isso não significa que o Ruby está morrendo RUBY

Slide 12

Slide 12 text

RUBY

Slide 13

Slide 13 text

comunidade bem ativa RUBY

Slide 14

Slide 14 text

Framework web criado em 2004 Criado por David Hansson (DHH) Última versão: 7.0.3.1 Lançada em 12 Julho 2022 Linguagem criada em 1995 Criada por Yukihiro "Matz" Última versão: 3.1.2 Publicada em 12 Abril 2022 +27 anos +18 anos

Slide 15

Slide 15 text

https://rubygems.org RUBY

Slide 16

Slide 16 text

Dados sobre o mercado de trabalho no Brasil em 2021 https://pothix.com/talks/ RUBY

Slide 17

Slide 17 text

RUBY

Slide 18

Slide 18 text

Ruby ainda está entre as linguagens mais populares RUBY

Slide 19

Slide 19 text

#17

Slide 20

Slide 20 text

RUBY

Slide 21

Slide 21 text

Gartner Hype Cycle Acionador de inovação Pico de expectativas infladas Vale da desilusão Ladeira da informação Tempo Visibilidade Planície da produtividade https://www.gartner.com.br/pt-br/metodologias/gartner-hype-cycle

Slide 22

Slide 22 text

Keynote: Beyond Ruby 3.0 - Yukihiro Matsumoto https://www.youtube.com/watch?v=Dp12a3KGNFw RUBY

Slide 23

Slide 23 text

Keynote: The Success of Ruby on Rails by Eileen Uchitelle https://www.youtube.com/watch?v=MbqJzACF-54 RUBY

Slide 24

Slide 24 text

No content

Slide 25

Slide 25 text

E o Elixir? ELIXIR

Slide 26

Slide 26 text

ELIXIR

Slide 27

Slide 27 text

No content

Slide 28

Slide 28 text

Por que falam de Elixir?

Slide 29

Slide 29 text

Aplicações web altamente concorrentes e escaláveis

Slide 30

Slide 30 text

5 milhões de usuários concorrentes ELIXIR

Slide 31

Slide 31 text

ELIXIR 8x mais tráfego, com menos servidores (de 150 para 5 servidores)

Slide 32

Slide 32 text

Aplicações web altamente concorrentes e escaláveis BEAM + Erlang/OTP

Slide 33

Slide 33 text

Linguagem criada em 2012 Criada por José Valim Última versão: 1.14.0 Publicada em 01 Setembro 2022 +10 anos Linguagem + Plataforma + VM criada em 1986 Criada por Joe Armstrong, Robert Virding e Mike Williams Última versão: 25.0 Publicada em 18 Maio 2022 +36 anos

Slide 34

Slide 34 text

Erlang foi criado para ser escalável, distribuído e tolerante a falhas 1986

Slide 35

Slide 35 text

Por que Elixir?

Slide 36

Slide 36 text

Concorrência / Distribuição Tolerância a falhas Baixa latência Escalabilidade Programação funcional Imutabilidade etc

Slide 37

Slide 37 text

Polimorfismo Metaprogramação Nova organização de código Documentação +++++++ Tooling

Slide 38

Slide 38 text

Polimorfismo Metaprogramação Nova organização de código Documentação +++++++ Tooling

Slide 39

Slide 39 text

COMPATIBILIDADE EXTENSIBILIDADE PRODUTIVIDADE ELIXIR

Slide 40

Slide 40 text

Compilação Carregamento Testes Tarefas execução paralela

Slide 41

Slide 41 text

ELIXIR defmodule Hello do def world do IO.puts "Hello, world" end end jeitinho de Ruby mas não é Ruby

Slide 42

Slide 42 text

ELIXIR

Slide 43

Slide 43 text

ELIXIR

Slide 44

Slide 44 text

hex.pm ELIXIR

Slide 45

Slide 45 text

ELIXIR

Slide 46

Slide 46 text

No content

Slide 47

Slide 47 text

2020

Slide 48

Slide 48 text

criadora das gems: RUBY

Slide 49

Slide 49 text

José Valim Brasileiro Co-fundador da Plataformatec Criador do Elixir

Slide 50

Slide 50 text

https://github.com/rails/rails RUBY

Slide 51

Slide 51 text

O case da Plataformatec com o Elixir - Hugo Baraúna https://www.youtube.com/watch?v=XnEAllPTNWw 2010

Slide 52

Slide 52 text

gotw.ca/publications/concurrency-ddj.htm 2005

Slide 53

Slide 53 text

Free lunch O software ficava mais rápido com o avanço das CPUs Não era necessário fazer nada além de atualizar o hardware

Slide 54

Slide 54 text

Free lunch is over A partir de ~2003, o clock speed parou de crescer como antes. Se continuasse, seria comum ter CPUs com 10GHz, por ex. Em 2005, surgiu o primeiro processador dual-core 2005

Slide 55

Slide 55 text

processadores multi-cores

Slide 56

Slide 56 text

concorrência e distribuição

Slide 57

Slide 57 text

No content

Slide 58

Slide 58 text

BEAM + Erlang/OTP

Slide 59

Slide 59 text

https://www.infoq.com/presentations/Elixir-Erlang-VM/ ELIXIR

Slide 60

Slide 60 text

2 milhões de conexões em um único nó phoenixframework.org/blog/the-road-to-2-million-websocket-connections ELIXIR

Slide 61

Slide 61 text

Framework web criado em 2014 Criado por Chris McCord Última versão: 1.6.12 Lançada em 06 Setembro 2022 +8 anos Linguagem criada em 2012 Criada por José Valim Última versão: 1.14.0 Publicada em 01 Setembro 2022 +10 anos

Slide 62

Slide 62 text

ELIXIR

Slide 63

Slide 63 text

#3

Slide 64

Slide 64 text

ELIXIR Celebrating the 10 Years of Elixir | José Valim | ElixirConf EU 2022 https://www.youtube.com/watch?v=Jf5Hsa1KOc8

Slide 65

Slide 65 text

No content

Slide 66

Slide 66 text

PARTE II

Slide 67

Slide 67 text

PARTE II Vivendo entre dois mundos

Slide 68

Slide 68 text

No content

Slide 69

Slide 69 text

Programação Funcional

Slide 70

Slide 70 text

soma_um = fn x -> x + 1 end Enum.map([1, 2, 3], soma_um) # [2, 3, 4] ELIXIR

Slide 71

Slide 71 text

soma_um = fn x -> x + 1 end Enum.map([1, 2, 3], soma_um) # [2, 3, 4] função anônima ELIXIR

Slide 72

Slide 72 text

soma_um = fn x -> x + 1 end Enum.map([1, 2, 3], soma_um) # [2, 3, 4] ELIXIR

Slide 73

Slide 73 text

soma_um = fn x -> x + 1 end Enum.map([1, 2, 3], soma_um) # [2, 3, 4] ELIXIR

Slide 74

Slide 74 text

soma_um = & &1 + 1 Enum.map([1, 2, 3], soma_um) # [2, 3, 4] ELIXIR

Slide 75

Slide 75 text

Enum.map([1, 2, 3], & &1 + 1) # [2, 3, 4] ELIXIR

Slide 76

Slide 76 text

Enum.map(["oi", "mundo"], &String.upcase/1) #["OI", "MUNDO"] ELIXIR

Slide 77

Slide 77 text

Enum.map(["oi", "mundo"], &String.upcase/1) #["OI", "MUNDO"] ELIXIR

Slide 78

Slide 78 text

String.upcase(Enum.join(["oi", "mundo"], " ")) # "OI MUNDO" ELIXIR

Slide 79

Slide 79 text

String.upcase(Enum.join(["oi", "mundo"], " ")) # "OI MUNDO" ELIXIR

Slide 80

Slide 80 text

String.upcase(Enum.join(["oi", "mundo"], " ")) # "OI MUNDO" ELIXIR

Slide 81

Slide 81 text

String.upcase(Enum.join(["oi", "mundo"], " ")) # "OI MUNDO" ELIXIR

Slide 82

Slide 82 text

Pipelines ELIXIR

Slide 83

Slide 83 text

["oi", "mundo"] |> Enum.join(" ") # "oi mundo" |> String.upcase() # "OI MUNDO" ELIXIR

Slide 84

Slide 84 text

["oi", "mundo"] |> Enum.join(" ") # "oi mundo" |> String.upcase() # "OI MUNDO" ELIXIR

Slide 85

Slide 85 text

["oi", "mundo"] |> Enum.join(" ") # "oi mundo" |> String.upcase() # "OI MUNDO" ELIXIR

Slide 86

Slide 86 text

["oi", "mundo"] |> Enum.join(" ") # "oi mundo" |> String.upcase() # "OI MUNDO" ELIXIR

Slide 87

Slide 87 text

["oi", "mundo"] |> Enum.join(" ") # "oi mundo" |> String.upcase() # "OI MUNDO" ELIXIR

Slide 88

Slide 88 text

olhar para as transformações de dados

Slide 89

Slide 89 text

#

Slide 90

Slide 90 text

#TRETAS

Slide 91

Slide 91 text

https://bugs.ruby-lang.org/issues/15799 RUBY pipeline no ruby

Slide 92

Slide 92 text

https://bugs.ruby-lang.org/issues/15799 RUBY pipeline no ruby foi revertido

Slide 93

Slide 93 text

#TRETAS

Slide 94

Slide 94 text

Recursão ELIXIR

Slide 95

Slide 95 text

defmodule Matematica do def fatorial(0), do: 1 def fatorial(1), do: 1 def fatorial(n) do n * fatorial(n-1) end end ELIXIR

Slide 96

Slide 96 text

defmodule Matematica do def fatorial(0), do: 1 def fatorial(1), do: 1 def fatorial(n) do n * fatorial(n-1) end end ELIXIR

Slide 97

Slide 97 text

defmodule Matematica do def fatorial(0), do: 1 def fatorial(1), do: 1 def fatorial(n) do n * fatorial(n-1) end end ELIXIR

Slide 98

Slide 98 text

!!Con 2019- Tail Call Optimization: The Musical!! by Anjana Vakil & Natalia Margolis https://www.youtube.com/watch?v=-PX0BV9hGZY

Slide 99

Slide 99 text

No dia a dia você vai usar mais o Enum

Slide 100

Slide 100 text

ELIXIR Ao invés de escrever isso 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

Slide 101

Slide 101 text

Enum.reduce([1, 2, 3], 0, fn x, acc -> x + acc end) ELIXIR A gente escreve isso

Slide 102

Slide 102 text

Enum.sum([1, 2, 3]) ELIXIR ou só isso

Slide 103

Slide 103 text

[1, 2, 3].sum RUBY

Slide 104

Slide 104 text

Programação funcional que funciona por Rodrigo Serradura https://www.youtube.com/watch?v=w1OwYWe4UFo RUBY

Slide 105

Slide 105 text

e agora começa a parte divertida!

Slide 106

Slide 106 text

No content

Slide 107

Slide 107 text

Lidando com múltiplas sintaxes e linguagens

Slide 108

Slide 108 text

puts "Hello World" RUBY

Slide 109

Slide 109 text

IO.puts "Hello World" Ruby puts "Hello World" ELIXIR

Slide 110

Slide 110 text

IO.puts "Hello World" puts "Hello World" ELIXIR RUBY

Slide 111

Slide 111 text

ELIXIR RUBY

Slide 112

Slide 112 text

puts "Hello World" CompileError NoMethodError ELIXIR RUBY

Slide 113

Slide 113 text

ELIXIR RUBY

Slide 114

Slide 114 text

class Calculadora def soma(a, b) a + b end end RUBY

Slide 115

Slide 115 text

defmodule Calculadora do def soma(a, b) do a + b end end Ruby puts "Hello World" ELIXIR

Slide 116

Slide 116 text

class Calculadora def soma(a, b) a + b end end defmodule Calculadora do def soma(a, b) do a + b end end ELIXIR RUBY

Slide 117

Slide 117 text

ELIXIR RUBY

Slide 118

Slide 118 text

SyntaxError SyntaxError ELIXIR RUBY

Slide 119

Slide 119 text

ELIXIR RUBY

Slide 120

Slide 120 text

ELIXIR RUBY

Slide 121

Slide 121 text

{oi: "mundo"} RUBY

Slide 122

Slide 122 text

Ruby puts "Hello World" %{oi: "mundo"} ELIXIR

Slide 123

Slide 123 text

{oi: "mundo"} ELIXIR %{oi: "mundo"} RUBY

Slide 124

Slide 124 text

ELIXIR RUBY

Slide 125

Slide 125 text

SyntaxError ELIXIR RUBY

Slide 126

Slide 126 text

SyntaxError ELIXIR RUBY

Slide 127

Slide 127 text

Nenhum erro ELIXIR RUBY

Slide 128

Slide 128 text

É um comando válido ELIXIR RUBY

Slide 129

Slide 129 text

Tem mais exemplos

Slide 130

Slide 130 text

Mas vamos parar por aqui

Slide 131

Slide 131 text

Não quero sair triste do evento

Slide 132

Slide 132 text

Pattern matching

Slide 133

Slide 133 text

Pattern matching casamento de padrões

Slide 134

Slide 134 text

case {:ok, "Hello World"} do {:ok, result} -> result {:error, _} -> "Oh no!" _ -> "Catch all" end ELIXIR

Slide 135

Slide 135 text

case {:ok, "Hello World"} do {:ok, result} -> result {:error, _} -> "Oh no!" _ -> "Catch all" end ELIXIR

Slide 136

Slide 136 text

case {:ok, "Hello World"} do {:ok, result} -> result {:error, _} -> "Oh no!" _ -> "Catch all" end ELIXIR

Slide 137

Slide 137 text

case {:ok, "Hello World"} do {:ok, result} -> result {:error, _} -> "Oh no!" _ -> "Catch all" end ELIXIR

Slide 138

Slide 138 text

case {:error, "Invalid credit card"} do {:ok, result} -> result {:error, _} -> "Oh no!" _ -> "Catch all" end ELIXIR

Slide 139

Slide 139 text

case {:error, "Invalid credit card"} do {:ok, result} -> result {:error, _} -> "Oh no!" _ -> "Catch all" end ELIXIR

Slide 140

Slide 140 text

case {:error, "Invalid credit card"} do {:ok, result} -> result {:error, _} -> "Oh no!" _ -> "Catch all" end ELIXIR

Slide 141

Slide 141 text

case {:error, "Invalid credit card"} do {:ok, result} -> result {:error, _} -> "Oh no!" _ -> "Catch all" end ELIXIR

Slide 142

Slide 142 text

case {"unexpected error"} do {:ok, result} -> result {:error, _} -> "Oh no!" _ -> "Catch all" end ELIXIR

Slide 143

Slide 143 text

case {"unexpected error"} do {:ok, result} -> result {:error, _} -> "Oh no!" _ -> "Catch all" end ELIXIR

Slide 144

Slide 144 text

case {"unexpected error"} do {:ok, result} -> result {:error, _} -> "Oh no!" _ -> "Catch all" end ELIXIR

Slide 145

Slide 145 text

case {"unexpected error"} do {:ok, result} -> result {:error, _} -> "Oh no!" _ -> "Catch all" end ELIXIR

Slide 146

Slide 146 text

case {"unexpected error"} do {:ok, result} -> result {:error, _} -> "Oh no!" _ -> "Catch all" end ELIXIR

Slide 147

Slide 147 text

Pattern matching como fluxo de controle

Slide 148

Slide 148 text

Minha alegria e meu pesadelo

Slide 149

Slide 149 text

Fácil de escrever

Slide 150

Slide 150 text

Fácil de escrever Difícil de debugar se forem function clauses complexas

Slide 151

Slide 151 text

AVISO Exemplos meramente ilustrativos

Slide 152

Slide 152 text

AVISO Exemplos meramente ilustrativos Não façam isso em casa

Slide 153

Slide 153 text

AVISO Exemplos meramente ilustrativos Não façam isso em casa ou no trabalho

Slide 154

Slide 154 text

defmodule Mensagem do def olar(nome) do nome |> criar_messagem() |> String.upcase() end defp criar_messagem(%{evento: "Rubyconf Brasil" <> ano}) do "Que bom encontrar vocês em #{ano}" end defp criar_messagem(%{participante: participante}) do "Olá, #{participante}" end defp criar_messagem(_) do "Hey! 🎉" end end ELIXIR

Slide 155

Slide 155 text

defmodule Mensagem do def olar(nome) do nome |> criar_messagem() |> String.upcase() end defp criar_messagem(%{evento: "Rubyconf Brasil" <> ano}) do "Que bom encontrar vocês em #{ano}" end defp criar_messagem(%{participante: participante}) do "Olá, #{participante}" end defp criar_messagem(_) do "Hey! 🎉" end end pública ELIXIR

Slide 156

Slide 156 text

defmodule Mensagem do def olar(nome) do nome |> criar_messagem() |> String.upcase() end defp criar_messagem(%{evento: "Rubyconf Brasil" <> ano}) do "Que bom encontrar vocês em #{ano}" end defp criar_messagem(%{participante: participante}) do "Olá, #{participante}" end defp criar_messagem(_) do "Hey! 🎉" end end privada ELIXIR

Slide 157

Slide 157 text

defmodule Mensagem do def olar(nome) do nome |> criar_messagem() |> String.upcase() end defp criar_messagem(%{evento: "Rubyconf Brasil" <> ano}) do "Que bom encontrar vocês em #{ano}" end defp criar_messagem(%{participante: participante}) do "Olá, #{participante}" end defp criar_messagem(_) do "Hey! 🎉" end end ELIXIR dando um zoom…

Slide 158

Slide 158 text

defp criar_messagem(%{evento: "Rubyconf Brasil" <> ano}) do "Que bom encontrar vocês em #{ano}" end defp criar_messagem(%{participante: participante}) do "Olá, #{participante}" end defp criar_messagem(_) do "Hey! 🎉" end ELIXIR

Slide 159

Slide 159 text

defp criar_messagem(%{evento: "Rubyconf Brasil" <> ano}) do "Que bom encontrar vocês em #{ano}" end defp criar_messagem(%{participante: participante}) do "Olá, #{participante}" end defp criar_messagem(_) do "Hey! 🎉" end ELIXIR 3 funções com o mesmo nome e mesma quantidade de argumentos

Slide 160

Slide 160 text

defp criar_messagem(%{evento: "Rubyconf Brasil" <> ano}) do "Que bom encontrar vocês em #{ano}" end defp criar_messagem(%{participante: participante}) do "Olá, #{participante}" end defp criar_messagem(_) do "Hey! 🎉" end ELIXIR function clauses

Slide 161

Slide 161 text

defp criar_messagem(%{evento: "Rubyconf Brasil" <> ano}) do "Que bom encontrar vocês em #{ano}" end defp criar_messagem(%{participante: participante}) do "Olá, #{participante}" end defp criar_messagem(_) do "Hey! 🎉" end ELIXIR pattern matching vai definir qual função será utilizada

Slide 162

Slide 162 text

defmodule Mensagem do def olar(nome) do nome |> criar_messagem() |> String.upcase() end defp criar_messagem(%{evento: "Rubyconf Brasil" <> ano}) do "Que bom encontrar vocês em #{ano}" end defp criar_messagem(%{participante: participante}) do "Olá, #{participante}" end defp criar_messagem(_) do "Hey! 🎉" end end ELIXIR

Slide 163

Slide 163 text

defmodule Mensagem do def olar(nome) do nome |> criar_messagem() |> String.upcase() end defp criar_messagem(%{evento: "Rubyconf Brasil" <> ano}) do "Que bom encontrar vocês em #{ano}" end defp criar_messagem(%{participante: participante}) do "Olá, #{participante}" end defp criar_messagem(_) do "Hey! 🎉" end end ELIXIR

Slide 164

Slide 164 text

iex(1)> Mensagem.olar("Elaine")

Slide 165

Slide 165 text

iex(1)> Mensagem.olar("Elaine") "HEY! 🎉"

Slide 166

Slide 166 text

defp criar_messagem(%{evento: "Rubyconf Brasil" <> ano}) do "Que bom encontrar vocês em #{ano}" end defp criar_messagem(%{participante: participante}) do "Olá, #{participante}" end defp criar_messagem(_) do "Hey! 🎉" end

Slide 167

Slide 167 text

iex(2)> Mensagem.olar(%{participante: "Elaine"}) iex(7)>

Slide 168

Slide 168 text

iex(2)> Mensagem.olar(%{participante: "Elaine"}) iex(7)>

Slide 169

Slide 169 text

defp criar_messagem(%{evento: "Rubyconf Brasil" <> ano}) do "Que bom encontrar vocês em #{ano}" end defp criar_messagem(%{participante: participante}) do "Olá, #{participante}" end defp criar_messagem(_) do "Hey! 🎉" end

Slide 170

Slide 170 text

iex(2)> Mensagem.olar(%{participante: "Elaine"}) "OLÁ, ELAINE" iex(7)>

Slide 171

Slide 171 text

iex(4)> Mensagem.olar(%{evento: "Rubyconf Brasil 2022"}) iex(7)>

Slide 172

Slide 172 text

iex(4)> Mensagem.olar(%{evento: "Rubyconf Brasil 2022"}) iex(7)>

Slide 173

Slide 173 text

defp criar_messagem(%{evento: "Rubyconf Brasil" <> ano}) do "Que bom encontrar vocês em #{ano}" end defp criar_messagem(%{participante: participante}) do "Olá, #{participante}" end defp criar_messagem(_) do "Hey! 🎉" end

Slide 174

Slide 174 text

iex(4)> Mensagem.olar(%{evento: "Rubyconf Brasil 2022"}) iex(7)>

Slide 175

Slide 175 text

iex(4)> Mensagem.olar(%{evento: "Rubyconf Brasil"})

Slide 176

Slide 176 text

iex(4)> Mensagem.olar(%{evento: "Rubyconf Brasil"}) "QUE BOM ENCONTRAR VOCÊS EM "

Slide 177

Slide 177 text

defp criar_messagem(%{evento: "Rubyconf Brasil" <> ano}) do "Que bom encontrar vocês em #{ano}" end defp criar_messagem(%{participante: participante}) do "Olá, #{participante}" end defp criar_messagem(_) do "Hey! 🎉" end

Slide 178

Slide 178 text

defp criar_messagem(%{evento: "Rubyconf Brasil" <> ano}) do "Que bom encontrar vocês em #{ano}" end defp criar_messagem(%{participante: participante}) do "Olá, #{participante}" end defp criar_messagem(_) do "Hey! 🎉" end

Slide 179

Slide 179 text

defp criar_messagem(%{evento: "Rubyconf Brasil" <> ano}) when ano != "" do "Que bom encontrar vocês em #{ano}" end defp criar_messagem(%{participante: participante}) do "Olá, #{participante}" end defp criar_messagem(_) do "Hey! 🎉" end guard clause

Slide 180

Slide 180 text

iex(5)> Mensagem.olar(%{evento: "Rubyconf Brasil"}) iex(7)>

Slide 181

Slide 181 text

iex(5)> Mensagem.olar(%{evento: "Rubyconf Brasil"}) "HEY! 🎉" iex(7)>

Slide 182

Slide 182 text

defp criar_messagem(%{evento: "Rubyconf Brasil" <> ano}) when ano != "" do "Que bom encontrar vocês em #{ano}" end defp criar_messagem(%{participante: participante}) do "Olá, #{participante}" end defp criar_messagem(_) do "Hey! 🎉" end resposta padrão porque o ano não está definido

Slide 183

Slide 183 text

iex(5)> Mensagem.olar(%{evento: "Rubyconf Brasil"}) iex(7)> e se a gente quiser uma resposta diferente?

Slide 184

Slide 184 text

iex(5)> Mensagem.olar(%{evento: "Rubyconf Brasil"}) "QUE BOM ENCONTRAR VOCÊS AQUI!" iex(7)> e se a gente quiser uma resposta diferente?

Slide 185

Slide 185 text

defp criar_messagem(%{evento: "Rubyconf Brasil" <> ano}) when ano != "" do "Que bom encontrar vocês em #{ano}" end defp criar_messagem(%{participante: participante}) do "Olá, #{participante}" end defp criar_messagem(_) do "Hey! 🎉" end

Slide 186

Slide 186 text

defp criar_messagem(%{evento: "Rubyconf Brasil" <> ano}) do "Que bom encontrar vocês em #{ano}" end defp criar_messagem(%{evento: "Rubyconf Brasil"}) do "Que bom encontrar vocês aqui!" end defp criar_messagem(%{participante: participante}) do "Olá, #{participante}" end defp criar_messagem(_) do "Hey! 🎉" end + uma function clause

Slide 187

Slide 187 text

iex(5)> Mensagem.olar(%{evento: "Rubyconf Brasil"}) "QUE BOM ENCONTRAR VOCÊS EM " iex(7)>

Slide 188

Slide 188 text

iex(5)> Mensagem.olar(%{evento: "Rubyconf Brasil"}) "QUE BOM ENCONTRAR VOCÊS EM " iex(7)>

Slide 189

Slide 189 text

defp criar_messagem(%{evento: "Rubyconf Brasil" <> ano}) do "Que bom encontrar vocês em #{ano}" end defp criar_messagem(%{evento: "Rubyconf Brasil"}) do "Que bom encontrar vocês aqui!" end defp criar_messagem(%{participante: participante}) do "Olá, #{participante}" end defp criar_messagem(_) do "Hey! 🎉" end depende da ordem

Slide 190

Slide 190 text

defp criar_messagem(%{evento: "Rubyconf Brasil"}) do "Que bom encontrar vocês aqui!" end defp criar_messagem(%{evento: "Rubyconf Brasil" <> ano}) do "Que bom encontrar vocês em #{ano}" end defp criar_messagem(%{participante: participante}) do "Olá, #{participante}" end defp criar_messagem(_) do "Hey! 🎉" end

Slide 191

Slide 191 text

iex(5)> Mensagem.olar(%{evento: "Rubyconf Brasil"}) "QUE BOM ENCONTRAR VOCÊS AQUI!" iex(7)>

Slide 192

Slide 192 text

iex(5)> Mensagem.olar(%{evento: "Rubyconf Brasil"}) "QUE BOM ENCONTRAR VOCÊS AQUI!" iex(6)> Mensagem.olar(%{"evento" => "Rubyconf Brasil 2022"}) iex(7)>

Slide 193

Slide 193 text

iex(5)> Mensagem.olar(%{evento: "Rubyconf Brasil"}) "QUE BOM ENCONTRAR VOCÊS AQUI!" iex(6)> Mensagem.olar(%{"evento" => "Rubyconf Brasil 2022"}) "HEY! 🎉" iex(7)>

Slide 194

Slide 194 text

iex(5)> Mensagem.olar(%{evento: "Rubyconf Brasil"}) "QUE BOM ENCONTRAR VOCÊS AQUI!" iex(6)> Mensagem.olar(%{"evento" => "Rubyconf Brasil 2022"}) "HEY! 🎉" iex(7)>

Slide 195

Slide 195 text

iex(5)> Mensagem.olar(%{evento: "Rubyconf Brasil"}) "QUE BOM ENCONTRAR VOCÊS AQUI!" iex(6)> Mensagem.olar(%{"evento" => "Rubyconf Brasil 2022"}) "HEY! 🎉" iex(7)> Ok, vamos parar por aqui! papo para outro dia

Slide 196

Slide 196 text

No content

Slide 197

Slide 197 text

code smells também existem em programação funcional

Slide 198

Slide 198 text

Code smells, refatoração e Elixir Por Elaine Watanabe https://www.youtube.com/watch?v=3-1PCurON4Q

Slide 199

Slide 199 text

Writing extensible functional code - Renan Ranelli https://www.youtube.com/watch?v=1HXMUI7tiCQ

Slide 200

Slide 200 text

SOLID Elixir • Georgina McFadyen • GOTO 2018 https://www.youtube.com/watch?v=rmftOs2BzgU

Slide 201

Slide 201 text

#

Slide 202

Slide 202 text

Lidando com estado explícito

Slide 203

Slide 203 text

POO class Counter def initialize @count = 0 end def increment @count = @count + 1 end end c = Counter.new c.increment # @count = 1 c.increment # @count = 2 c.increment # @count = 3 RUBY

Slide 204

Slide 204 text

POO class Counter def initialize @count = 0 end def increment @count = @count + 1 end end c = Counter.new c.increment # @count = 1 c.increment # @count = 2 c.increment # @count = 3 RUBY estado interno do objeto estado implícito um valor diferente para cada chamada

Slide 205

Slide 205 text

Imutabilidade

Slide 206

Slide 206 text

PF defmodule Counter do def increment(count) do count + 1 end end Counter.increment(1) # 2 Counter.increment(1) # 2 Counter.increment(1) # 2 estado interno do objeto ELIXIR

Slide 207

Slide 207 text

PF defmodule Counter do def increment(count) do count + 1 end end Counter.increment(1) # 2 Counter.increment(1) # 2 Counter.increment(1) # 2 estado interno do objeto ELIXIR a mesma resposta para a mesma entrada

Slide 208

Slide 208 text

entrada -> função -> saída

Slide 209

Slide 209 text

entrada -> função -> saída mesma entrada -> mesma saída

Slide 210

Slide 210 text

entrada -> função -> saída funções puras -> efeitos previsíveis

Slide 211

Slide 211 text

No content

Slide 212

Slide 212 text

funções impuras -> efeitos imprevisíveis funções impuras em elixir

Slide 213

Slide 213 text

funções impuras em elixir chamadas de APIs, banco de dados, etc

Slide 214

Slide 214 text

O essencial da programação funcional em Elixir, com Ulisses Almeida https://pt-br.eventials.com/locaweb/o-essencial-da-programacao-funcional-em-elixir-com-ulisses-almeida/

Slide 215

Slide 215 text

#

Slide 216

Slide 216 text

Um novo vocabulário

Slide 217

Slide 217 text

Erlang Erlang VM Erlang/OTP Processos Supervisors

Slide 218

Slide 218 text

No content

Slide 219

Slide 219 text

Idioms for Building Distributed Fault-tolerant Applications with Elixir • José Valim • GOTO 2014 https://www.youtube.com/watch?v=B4rOG9Bc65Q

Slide 220

Slide 220 text

Como concorrência funciona em Elixir? Com Amanda Sposito https://pt-br.eventials.com/locaweb/como-concorrencia-funciona-em-elixir-com-amanda-sposito/

Slide 221

Slide 221 text

Erlang: linguagem Erlang: máquina virtual Erlang: plataforma

Slide 222

Slide 222 text

No content

Slide 223

Slide 223 text

BEAM bytecode

Slide 224

Slide 224 text

BEAM bytecode

Slide 225

Slide 225 text

BEAM bytecode

Slide 226

Slide 226 text

BEAM bytecode

Slide 227

Slide 227 text

BEAM: Björn's Erlang Abstract Machine Erlang VM (máquina virtual)

Slide 228

Slide 228 text

BEAM BEAM bytecode processes scheduler CPU Core processes scheduler CPU Core

Slide 229

Slide 229 text

Erlang / Elixir BEAM process scheduler core process scheduler core Erlang/OTP + Bibliotecas + Princípios de design

Slide 230

Slide 230 text

ElixirConf 2018 - Erlang OTP What's in the Box - João Britto youtube.com/watch?v=CozSfI-Zepw

Slide 231

Slide 231 text

BEAM process process process process process process process process process

Slide 232

Slide 232 text

supervisor BEAM process process process process process process process process process supervisor

Slide 233

Slide 233 text

supervisor BEAM process process process process process process process process process supervisor

Slide 234

Slide 234 text

supervisor BEAM process process process process process process process process supervisor

Slide 235

Slide 235 text

supervisor BEAM process process process process process process process process process supervisor

Slide 236

Slide 236 text

let it crash

Slide 237

Slide 237 text

let it crash mas com parcimônia

Slide 238

Slide 238 text

Organização do código

Slide 239

Slide 239 text

Eu queria criar classes e objetos

Slide 240

Slide 240 text

Eu queria criar classes e objetos mas não podia

Slide 241

Slide 241 text

Eu queria criar classes e objetos nem deveria

Slide 242

Slide 242 text

No content

Slide 243

Slide 243 text

Phoenix Contexts https://hexdocs.pm/phoenix/contexts.html

Slide 244

Slide 244 text

Phoenix Plug https://hexdocs.pm/phoenix/plug.html

Slide 245

Slide 245 text

https://medium.com/very-big-things Clarity | Saša Jurić | ElixirConf EU 2021 https://www.youtube.com/watch?v=6sNmJtoKDCo

Slide 246

Slide 246 text

https://ulisses.dev/

Slide 247

Slide 247 text

#

Slide 248

Slide 248 text

Um novo framework

Slide 249

Slide 249 text

ELIXIR

Slide 250

Slide 250 text

Menos mágicas que o Rails!

Slide 251

Slide 251 text

Ecto != ORM

Slide 252

Slide 252 text

Erlang/OTP

Slide 253

Slide 253 text

"Elixir avançado"

Slide 254

Slide 254 text

No content

Slide 255

Slide 255 text

You ain't gonna need write a GenServer - Ulisses Almeida (ENG) | Elixir Club Ukraine https://www.youtube.com/watch?v=AZcxoYB9keI

Slide 256

Slide 256 text

https://2019.elixirbrasil.com/

Slide 257

Slide 257 text

Mantendo sistemas Seja legado ou não

Slide 258

Slide 258 text

Atualize suas dependências no código!

Slide 259

Slide 259 text

Atualize suas dependências no código!

Slide 260

Slide 260 text

Atualize suas dependências no código!

Slide 261

Slide 261 text

Dívida Técnica Valor de negócio Custo da mudança Tempo How to Monetize Application Technical Debt, Gartner, 2011

Slide 262

Slide 262 text

Lidar com novas features vs migrações Feature Toggles/ Feature Flags Código morto (unused code) Context switching

Slide 263

Slide 263 text

Revisão de código (code review) Documentação Treinamentos Dev syncs (guild meetings)

Slide 264

Slide 264 text

atenção aos silos de conhecimento http://blog.plataformatec.com.br/2018/07/como-evitar-silos-de-conhecimento-na-sua-c odebase-e-levar-seus-code-reviews-para-o-proximo-nivel/ bus factor

Slide 265

Slide 265 text

No content

Slide 266

Slide 266 text

Conhecendo novos problemas

Slide 267

Slide 267 text

No content

Slide 268

Slide 268 text

You ain't gonna need write a GenServer - Ulisses Almeida (ENG) | Elixir Club Ukraine https://www.youtube.com/watch?v=AZcxoYB9keI

Slide 269

Slide 269 text

You ain't gonna need write a GenServer - Ulisses Almeida (ENG) | Elixir Club Ukraine https://www.youtube.com/watch?v=AZcxoYB9keI

Slide 270

Slide 270 text

No content

Slide 271

Slide 271 text

#

Slide 272

Slide 272 text

PARTE III

Slide 273

Slide 273 text

PARTE III Barreiras no caminho

Slide 274

Slide 274 text

Não-proficiência em Elixir

Slide 275

Slide 275 text

Entender o Elixir e seu ecossistema pode ser levar um bom tempo

Slide 276

Slide 276 text

Ter uma equipe com experiência pode te ajudar (e muito!)

Slide 277

Slide 277 text

Bons pull requests

Slide 278

Slide 278 text

https://sourcelevel.io/code-review-ebook

Slide 279

Slide 279 text

Boa cobertura de testes automatizados

Slide 280

Slide 280 text

Pirâmide de Testes

Slide 281

Slide 281 text

Code standards / code consistency

Slide 282

Slide 282 text

No content

Slide 283

Slide 283 text

Criando "memória muscular"

Slide 284

Slide 284 text

No content

Slide 285

Slide 285 text

Criando mental chunks

Slide 286

Slide 286 text

Reading code as a beginner defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end ELIXIR

Slide 287

Slide 287 text

Reading code as a beginner defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end ELIXIR

Slide 288

Slide 288 text

Reading code as a beginner defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end ELIXIR

Slide 289

Slide 289 text

Reading code as a beginner defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end ELIXIR

Slide 290

Slide 290 text

Reading code as a beginner defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end ELIXIR

Slide 291

Slide 291 text

Reading code as a beginner defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end ELIXIR

Slide 292

Slide 292 text

Reading code as a beginner defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end ELIXIR

Slide 293

Slide 293 text

Reading code as a beginner defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end ELIXIR

Slide 294

Slide 294 text

Reading code as a beginner defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end ELIXIR

Slide 295

Slide 295 text

Reading code as a beginner defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end ELIXIR

Slide 296

Slide 296 text

Reading code as a beginner defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end ELIXIR

Slide 297

Slide 297 text

Reading code as a beginner defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end ELIXIR

Slide 298

Slide 298 text

Reading code as a beginner defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end ELIXIR

Slide 299

Slide 299 text

defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end Wait! Where is the function body? Reading code as a beginner ELIXIR

Slide 300

Slide 300 text

defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end Wait! Where is the function body? Ah, ok! It's a protocol Reading code as a beginner ELIXIR

Slide 301

Slide 301 text

defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end Wait! Where is the function body? Ah, ok! It's a protocol But, how do we normally use it? Reading code as a beginner ELIXIR

Slide 302

Slide 302 text

Reading code as an experienced Elixir programmer defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end ELIXIR

Slide 303

Slide 303 text

Reading code as an experienced Elixir programmer defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end ELIXIR

Slide 304

Slide 304 text

Reading code as an experienced Elixir programmer defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end Ok, it's a protocol ELIXIR

Slide 305

Slide 305 text

Reading code as an experienced Elixir programmer defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end Computing some size stuff ELIXIR

Slide 306

Slide 306 text

Reading code as an experienced Elixir programmer defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end ELIXIR

Slide 307

Slide 307 text

Reading code as an experienced Elixir programmer defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end ELIXIR

Slide 308

Slide 308 text

Reading code as an experienced Elixir programmer defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end For strings and maps ELIXIR

Slide 309

Slide 309 text

Reading code as an experienced Elixir programmer defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end Ah, ok! It's size and not the length ELIXIR

Slide 310

Slide 310 text

Como a gente chega lá?

Slide 311

Slide 311 text

Try, fail, learn, repeat

Slide 312

Slide 312 text

Lessons Learned from Elixir Learning Paths https://www.youtube.com/watch?v=I1jUWz1RP2U https://speakerdeck.com/elainenaomi/elixir-conf-eu-lessons-learned-from-elixir-learning-paths

Slide 313

Slide 313 text

O Elixir além do Phoenix

Slide 314

Slide 314 text

Real Time Web

Slide 315

Slide 315 text

BYE, JS!

Slide 316

Slide 316 text

Exemplo do LiveView

Slide 317

Slide 317 text

Sistemas embarcados IoT

Slide 318

Slide 318 text

M L

Slide 319

Slide 319 text

O que o Elixir não resolve

Slide 320

Slide 320 text

Aplicações intensivas em CPU Hard real-time GUI applications (Scenic?) Machine Learning (Elixir NX?)

Slide 321

Slide 321 text

Nem sempre seu código vai ser paralelizável

Slide 322

Slide 322 text

O essencial da programação funcional em Elixir, com Ulisses Almeida https://pt-br.eventials.com/locaweb/o-essencial-da-programacao-funcional-em-elixir-com-ulisses-almeida/

Slide 323

Slide 323 text

E nem sempre a culpa é da linguagem

Slide 324

Slide 324 text

Lessons Learned From an Elixir/OTP Project - Amanda Sposito youtube.com/watch?v=VaratZ_5154

Slide 325

Slide 325 text

Ecossistema

Slide 326

Slide 326 text

No content

Slide 327

Slide 327 text

Ainda tem poucas bibliotecas

Slide 328

Slide 328 text

Você pode acabar encontrando bibliotecas inativas ou pouco mantidas

Slide 329

Slide 329 text

Você pode ter que criar a sua própria biblioteca

Slide 330

Slide 330 text

RailsConf 2019 - Maintaining a big open source project: lessons learned by Leonardo Tegon https://www.youtube.com/watch?v=rnOcDH_sgxg RUBY

Slide 331

Slide 331 text

Contratação

Slide 332

Slide 332 text

Tenha um bom onboarding

Slide 333

Slide 333 text

https://claudio-ortolina.org/posts/teaching-elixir/

Slide 334

Slide 334 text

Lessons Learned from Elixir Learning Paths https://www.youtube.com/watch?v=I1jUWz1RP2U https://speakerdeck.com/elainenaomi/elixir-conf-eu-lessons-learned-from-elixir-learning-paths

Slide 335

Slide 335 text

https://smartlogic.io/blog/hire-junior-engineers/

Slide 336

Slide 336 text

No content

Slide 337

Slide 337 text

Rock star vs Superstar modes

Slide 338

Slide 338 text

https://twitter.com/redrapids/status/1372185755397857291

Slide 339

Slide 339 text

Phoenix não tem um getting started guide oficial tão divertido que nem o do Rails

Slide 340

Slide 340 text

E como não tem menos mágica, você precisa entender mais conceitos (por ex. ecto)

Slide 341

Slide 341 text

No content

Slide 342

Slide 342 text

Infelizmente, iniciantes em programação ainda precisam de muito suporte

Slide 343

Slide 343 text

Não tem muitas opções de materiais de introdução à programação com Elixir

Slide 344

Slide 344 text

Ainda mais em português

Slide 345

Slide 345 text

ELIXIR DO FUTURO

Slide 346

Slide 346 text

Celebrating the 10 Years of Elixir | José Valim | ElixirConf EU 2022 https://www.youtube.com/watch?v=Jf5Hsa1KOc8 ELIXIR

Slide 347

Slide 347 text

COMUNIDADE

Slide 348

Slide 348 text

O Elixir do futuro, com Charlotte Lorelei Oliveira https://pt-br.eventials.com/locaweb/o-elixir-do-futuro-com-charlotte-lorelei-oliveira/ ELIXIR

Slide 349

Slide 349 text

Importância da diversidade e inclusão

Slide 350

Slide 350 text

Criação de materiais para iniciantes

Slide 351

Slide 351 text

Aprender programação funcional não deveria ser diferente de aprender programação orientada a objeto minha opinião

Slide 352

Slide 352 text

Criação de conteúdo em português

Slide 353

Slide 353 text

Contribuições não-técnicas +++

Slide 354

Slide 354 text

Fórums

Slide 355

Slide 355 text

https://elixirforum.com/ ELIXIR

Slide 356

Slide 356 text

Grupos do Telegram

Slide 357

Slide 357 text

t.me/elixirbr

Slide 358

Slide 358 text

Newsletters

Slide 359

Slide 359 text

Blog posts

Slide 360

Slide 360 text

Conferências/Meetups

Slide 361

Slide 361 text

ELUGs pelo Brasil Elixir User Groups

Slide 362

Slide 362 text

ELUG SP - 2020

Slide 363

Slide 363 text

Traduções

Slide 364

Slide 364 text

No content

Slide 365

Slide 365 text

Podcasts

Slide 366

Slide 366 text

ELIXIR EM FOCO

Slide 367

Slide 367 text

ELIXIR

Slide 368

Slide 368 text

ELIXIR

Slide 369

Slide 369 text

Live streams

Slide 370

Slide 370 text

ELIXIR

Slide 371

Slide 371 text

ELIXIR

Slide 372

Slide 372 text

ELIXIR

Slide 373

Slide 373 text

CARNIVAL EDITION ELIXIR

Slide 374

Slide 374 text

ELIXIR

Slide 375

Slide 375 text

Comunidade + Universidades

Slide 376

Slide 376 text

https://pesquisecomelixir.com.br/

Slide 377

Slide 377 text

RUBY DO PASSADO E RUBY DO PRESENTE

Slide 378

Slide 378 text

GURU SP - Grupo de Usuários de Ruby SP https://www.gurusp.org/ RUBY

Slide 379

Slide 379 text

RUBY

Slide 380

Slide 380 text

t.me/rubybrasil RUBY

Slide 381

Slide 381 text

#RubySummitBR https://ruby.com.br/ RUBY

Slide 382

Slide 382 text

2016 RUBY

Slide 383

Slide 383 text

Pessoas saindo Pessoas entrando RUBY

Slide 384

Slide 384 text

Diversidade e Inclusão RUBY

Slide 385

Slide 385 text

2016 RUBY

Slide 386

Slide 386 text

2017 RUBY

Slide 387

Slide 387 text

2019 2018 2017 RUBY

Slide 388

Slide 388 text

O Rails Girls é só um dos recortes RUBY RUBY

Slide 389

Slide 389 text

Como podemos trazer mais pessoas para a comunidade? RUBY RUBY

Slide 390

Slide 390 text

RUBY DO FUTURO

Slide 391

Slide 391 text

No content

Slide 392

Slide 392 text

speakerdeck.com/elainenaomi elainenaomi.dev Muito obrigada illustrations from undraw.co