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

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
6. PARTE I Conhecendo Elixir
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
25. E o Elixir? ELIXIR
26. ELIXIR
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
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
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
66. PARTE II
67. PARTE II Vivendo entre dois mundos
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!
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
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
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
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
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
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"
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
266. Conhecendo novos problemas
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
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
283. Criando "memória muscular"
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
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/
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)
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
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
392. speakerdeck.com/elainenaomi elainenaomi.dev Muito obrigada illustrations from undraw.co