$30 off During Our Annual Pro Sale. View Details »

Mantendo sistemas Ruby e Elixir: lições aprendidas

Elaine Naomi
September 09, 2022

Mantendo sistemas Ruby e Elixir: lições aprendidas

Se você acompanha notícias e discussões da comunidade de desenvolvimento de software há algum tempo, provavelmente já lidou com perguntas como:
Ruby está morrendo? Vale a pena aprender Elixir em 2022? Devemos migrar todos os sistemas Ruby para Elixir o quanto antes? Ou Elixir está morrendo também?

Com tantas opiniões divergentes, como podemos encontrar as nossas próprias respostas para essas perguntas e dilemas? Entender o ciclo do hype é o primeiro passo.
O segundo é entender como explorar novos universos e como adaptá-los a cada contexto.

Nessa palestra, vou apresentar a estratégia que eu utilizo para analisar ambos ecossistemas, compartilhando aprendizados e desafios que eu encontrei em sistemas Ruby e Elixir nos últimos anos,
incluindo a época em que trabalhei para a Plataformatec como desenvolvedora de software.

RubyConf+ 2022 Brasil

Elaine Naomi

September 09, 2022
Tweet

More Decks by Elaine Naomi

Other Decks in Programming

Transcript

  1. Mantendo sistemas em Ruby & Elixir RubyConf+ 2022

  2. Elixir + Ruby

  3. 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
  4. Parte I Conhecendo Elixir Parte II Vivendo entre dois mundos

    Parte III Barreiras no caminho
  5. None
  6. PARTE I Conhecendo Elixir

  7. None
  8. Linguagem de programação ELIXIR

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

  10. #TRETAS

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

  12. RUBY

  13. comunidade bem ativa RUBY

  14. 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
  15. https://rubygems.org RUBY

  16. Dados sobre o mercado de trabalho no Brasil em 2021

    https://pothix.com/talks/ RUBY
  17. RUBY

  18. Ruby ainda está entre as linguagens mais populares RUBY

  19. #17

  20. RUBY

  21. 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
  22. Keynote: Beyond Ruby 3.0 - Yukihiro Matsumoto https://www.youtube.com/watch?v=Dp12a3KGNFw RUBY

  23. Keynote: The Success of Ruby on Rails by Eileen Uchitelle

    https://www.youtube.com/watch?v=MbqJzACF-54 RUBY
  24. None
  25. E o Elixir? ELIXIR

  26. ELIXIR

  27. None
  28. Por que falam de Elixir?

  29. Aplicações web altamente concorrentes e escaláveis

  30. 5 milhões de usuários concorrentes ELIXIR

  31. ELIXIR 8x mais tráfego, com menos servidores (de 150 para

    5 servidores)
  32. Aplicações web altamente concorrentes e escaláveis BEAM + Erlang/OTP

  33. 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
  34. Erlang foi criado para ser escalável, distribuído e tolerante a

    falhas 1986
  35. Por que Elixir?

  36. Concorrência / Distribuição Tolerância a falhas Baixa latência Escalabilidade Programação

    funcional Imutabilidade etc
  37. Polimorfismo Metaprogramação Nova organização de código Documentação +++++++ Tooling

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

  39. COMPATIBILIDADE EXTENSIBILIDADE PRODUTIVIDADE ELIXIR

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

  41. ELIXIR defmodule Hello do def world do IO.puts "Hello, world"

    end end jeitinho de Ruby mas não é Ruby
  42. ELIXIR

  43. ELIXIR

  44. hex.pm ELIXIR

  45. ELIXIR

  46. None
  47. 2020

  48. criadora das gems: RUBY

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

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

  51. O case da Plataformatec com o Elixir - Hugo Baraúna

    https://www.youtube.com/watch?v=XnEAllPTNWw 2010
  52. gotw.ca/publications/concurrency-ddj.htm 2005

  53. 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
  54. 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
  55. processadores multi-cores

  56. concorrência e distribuição

  57. None
  58. BEAM + Erlang/OTP

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

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

  61. 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
  62. ELIXIR

  63. #3

  64. ELIXIR Celebrating the 10 Years of Elixir | José Valim

    | ElixirConf EU 2022 https://www.youtube.com/watch?v=Jf5Hsa1KOc8
  65. None
  66. PARTE II

  67. PARTE II Vivendo entre dois mundos

  68. None
  69. Programação Funcional

  70. soma_um = fn x -> x + 1 end Enum.map([1,

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

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

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

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

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

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

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

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

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

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

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

  82. Pipelines ELIXIR

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

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

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

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

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

    # "OI MUNDO" ELIXIR
  88. olhar para as transformações de dados

  89. #

  90. #TRETAS

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

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

  93. #TRETAS

  94. Recursão ELIXIR

  95. defmodule Matematica do def fatorial(0), do: 1 def fatorial(1), do:

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

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

    1 def fatorial(n) do n * fatorial(n-1) end end ELIXIR
  98. !!Con 2019- Tail Call Optimization: The Musical!! by Anjana Vakil

    & Natalia Margolis https://www.youtube.com/watch?v=-PX0BV9hGZY
  99. No dia a dia você vai usar mais o Enum

  100. 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
  101. Enum.reduce([1, 2, 3], 0, fn x, acc -> x +

    acc end) ELIXIR A gente escreve isso
  102. Enum.sum([1, 2, 3]) ELIXIR ou só isso

  103. [1, 2, 3].sum RUBY

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

  105. e agora começa a parte divertida!

  106. None
  107. Lidando com múltiplas sintaxes e linguagens

  108. puts "Hello World" RUBY

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

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

  111. ELIXIR RUBY

  112. puts "Hello World" CompileError NoMethodError ELIXIR RUBY

  113. ELIXIR RUBY

  114. class Calculadora def soma(a, b) a + b end end

    RUBY
  115. defmodule Calculadora do def soma(a, b) do a + b

    end end Ruby puts "Hello World" ELIXIR
  116. class Calculadora def soma(a, b) a + b end end

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

  118. SyntaxError SyntaxError ELIXIR RUBY

  119. ELIXIR RUBY

  120. ELIXIR RUBY

  121. {oi: "mundo"} RUBY

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

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

  124. ELIXIR RUBY

  125. SyntaxError ELIXIR RUBY

  126. SyntaxError ELIXIR RUBY

  127. Nenhum erro ELIXIR RUBY

  128. É um comando válido ELIXIR RUBY

  129. Tem mais exemplos

  130. Mas vamos parar por aqui

  131. Não quero sair triste do evento

  132. Pattern matching

  133. Pattern matching casamento de padrões

  134. case {:ok, "Hello World"} do {:ok, result} -> result {:error,

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

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

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

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

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

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

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

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

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

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

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

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

    -> "Oh no!" _ -> "Catch all" end ELIXIR
  147. Pattern matching como fluxo de controle

  148. Minha alegria e meu pesadelo

  149. Fácil de escrever

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

    complexas
  151. AVISO Exemplos meramente ilustrativos

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

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

    no trabalho
  154. 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
  155. 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
  156. 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
  157. 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…
  158. 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
  159. 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
  160. 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
  161. 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
  162. 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
  163. 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
  164. iex(1)> Mensagem.olar("Elaine")

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

  166. 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
  167. iex(2)> Mensagem.olar(%{participante: "Elaine"}) iex(7)>

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

  169. 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
  170. iex(2)> Mensagem.olar(%{participante: "Elaine"}) "OLÁ, ELAINE" iex(7)>

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

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

  173. 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
  174. iex(4)> Mensagem.olar(%{evento: "Rubyconf Brasil 2022"}) iex(7)>

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

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

  177. 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
  178. 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
  179. 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
  180. iex(5)> Mensagem.olar(%{evento: "Rubyconf Brasil"}) iex(7)>

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

  182. 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
  183. iex(5)> Mensagem.olar(%{evento: "Rubyconf Brasil"}) iex(7)> e se a gente quiser

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

    e se a gente quiser uma resposta diferente?
  185. 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
  186. 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
  187. iex(5)> Mensagem.olar(%{evento: "Rubyconf Brasil"}) "QUE BOM ENCONTRAR VOCÊS EM "

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

    iex(7)>
  189. 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
  190. 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
  191. iex(5)> Mensagem.olar(%{evento: "Rubyconf Brasil"}) "QUE BOM ENCONTRAR VOCÊS AQUI!" iex(7)>

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

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

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

    Mensagem.olar(%{"evento" => "Rubyconf Brasil 2022"}) "HEY! 🎉" iex(7)>
  195. 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
  196. None
  197. code smells também existem em programação funcional

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

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

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

  201. #

  202. Lidando com estado explícito

  203. 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
  204. 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
  205. Imutabilidade

  206. 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
  207. 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
  208. entrada -> função -> saída

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

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

  211. None
  212. funções impuras -> efeitos imprevisíveis funções impuras em elixir

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

    etc
  214. 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/
  215. #

  216. Um novo vocabulário

  217. Erlang Erlang VM Erlang/OTP Processos Supervisors

  218. None
  219. Idioms for Building Distributed Fault-tolerant Applications with Elixir • José

    Valim • GOTO 2014 https://www.youtube.com/watch?v=B4rOG9Bc65Q
  220. Como concorrência funciona em Elixir? Com Amanda Sposito https://pt-br.eventials.com/locaweb/como-concorrencia-funciona-em-elixir-com-amanda-sposito/

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

  222. None
  223. BEAM bytecode

  224. BEAM bytecode

  225. BEAM bytecode

  226. BEAM bytecode

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

  228. BEAM BEAM bytecode processes scheduler CPU Core processes scheduler CPU

    Core
  229. Erlang / Elixir BEAM process scheduler core process scheduler core

    Erlang/OTP + Bibliotecas + Princípios de design
  230. ElixirConf 2018 - Erlang OTP What's in the Box -

    João Britto youtube.com/watch?v=CozSfI-Zepw
  231. BEAM process process process process process process process process process

  232. supervisor BEAM process process process process process process process process

    process supervisor
  233. supervisor BEAM process process process process process process process process

    process supervisor
  234. supervisor BEAM process process process process process process process process

    supervisor
  235. supervisor BEAM process process process process process process process process

    process supervisor
  236. let it crash

  237. let it crash mas com parcimônia

  238. Organização do código

  239. Eu queria criar classes e objetos

  240. Eu queria criar classes e objetos mas não podia

  241. Eu queria criar classes e objetos nem deveria

  242. None
  243. Phoenix Contexts https://hexdocs.pm/phoenix/contexts.html

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

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

  246. https://ulisses.dev/

  247. #

  248. Um novo framework

  249. ELIXIR

  250. Menos mágicas que o Rails!

  251. Ecto != ORM

  252. Erlang/OTP

  253. "Elixir avançado"

  254. None
  255. You ain't gonna need write a GenServer - Ulisses Almeida

    (ENG) | Elixir Club Ukraine https://www.youtube.com/watch?v=AZcxoYB9keI
  256. https://2019.elixirbrasil.com/

  257. Mantendo sistemas Seja legado ou não

  258. Atualize suas dependências no código!

  259. Atualize suas dependências no código!

  260. Atualize suas dependências no código!

  261. Dívida Técnica Valor de negócio Custo da mudança Tempo How

    to Monetize Application Technical Debt, Gartner, 2011
  262. Lidar com novas features vs migrações Feature Toggles/ Feature Flags

    Código morto (unused code) Context switching
  263. Revisão de código (code review) Documentação Treinamentos Dev syncs (guild

    meetings)
  264. 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

  265. None
  266. Conhecendo novos problemas

  267. None
  268. You ain't gonna need write a GenServer - Ulisses Almeida

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

    (ENG) | Elixir Club Ukraine https://www.youtube.com/watch?v=AZcxoYB9keI
  270. None
  271. #

  272. PARTE III

  273. PARTE III Barreiras no caminho

  274. Não-proficiência em Elixir

  275. Entender o Elixir e seu ecossistema pode ser levar um

    bom tempo
  276. Ter uma equipe com experiência pode te ajudar (e muito!)

  277. Bons pull requests

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

  279. Boa cobertura de testes automatizados

  280. Pirâmide de Testes

  281. Code standards / code consistency

  282. None
  283. Criando "memória muscular"

  284. None
  285. Criando mental chunks

  286. 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
  287. 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
  288. 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
  289. 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
  290. 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
  291. 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
  292. 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
  293. 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
  294. 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
  295. 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
  296. 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
  297. 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
  298. 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
  299. 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
  300. 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
  301. 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
  302. 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
  303. 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
  304. 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
  305. 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
  306. 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
  307. 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
  308. 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
  309. 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
  310. Como a gente chega lá?

  311. Try, fail, learn, repeat

  312. 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

  313. O Elixir além do Phoenix

  314. Real Time Web

  315. BYE, JS!

  316. Exemplo do LiveView

  317. Sistemas embarcados IoT

  318. M L

  319. O que o Elixir não resolve

  320. Aplicações intensivas em CPU Hard real-time GUI applications (Scenic?) Machine

    Learning (Elixir NX?)
  321. Nem sempre seu código vai ser paralelizável

  322. 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/
  323. E nem sempre a culpa é da linguagem

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

  325. Ecossistema

  326. None
  327. Ainda tem poucas bibliotecas

  328. Você pode acabar encontrando bibliotecas inativas ou pouco mantidas

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

  330. RailsConf 2019 - Maintaining a big open source project: lessons

    learned by Leonardo Tegon https://www.youtube.com/watch?v=rnOcDH_sgxg RUBY
  331. Contratação

  332. Tenha um bom onboarding

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

  334. 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

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

  336. None
  337. Rock star vs Superstar modes

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

  339. Phoenix não tem um getting started guide oficial tão divertido

    que nem o do Rails
  340. E como não tem menos mágica, você precisa entender mais

    conceitos (por ex. ecto)
  341. None
  342. Infelizmente, iniciantes em programação ainda precisam de muito suporte

  343. Não tem muitas opções de materiais de introdução à programação

    com Elixir
  344. Ainda mais em português

  345. ELIXIR DO FUTURO

  346. Celebrating the 10 Years of Elixir | José Valim |

    ElixirConf EU 2022 https://www.youtube.com/watch?v=Jf5Hsa1KOc8 ELIXIR
  347. COMUNIDADE

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

  349. Importância da diversidade e inclusão

  350. Criação de materiais para iniciantes

  351. Aprender programação funcional não deveria ser diferente de aprender programação

    orientada a objeto minha opinião
  352. Criação de conteúdo em português

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

  354. Fórums

  355. https://elixirforum.com/ ELIXIR

  356. Grupos do Telegram

  357. t.me/elixirbr

  358. Newsletters

  359. Blog posts

  360. Conferências/Meetups

  361. ELUGs pelo Brasil Elixir User Groups

  362. ELUG SP - 2020

  363. Traduções

  364. None
  365. Podcasts

  366. ELIXIR EM FOCO

  367. ELIXIR

  368. ELIXIR

  369. Live streams

  370. ELIXIR

  371. ELIXIR

  372. ELIXIR

  373. CARNIVAL EDITION ELIXIR

  374. ELIXIR

  375. Comunidade + Universidades

  376. https://pesquisecomelixir.com.br/

  377. RUBY DO PASSADO E RUBY DO PRESENTE

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

    RUBY
  379. RUBY

  380. t.me/rubybrasil RUBY

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

  382. 2016 RUBY

  383. Pessoas saindo Pessoas entrando RUBY

  384. Diversidade e Inclusão RUBY

  385. 2016 RUBY

  386. 2017 RUBY

  387. 2019 2018 2017 RUBY

  388. O Rails Girls é só um dos recortes RUBY RUBY

  389. Como podemos trazer mais pessoas para a comunidade? RUBY RUBY

  390. RUBY DO FUTURO

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