The document discusses concurrency and fault tolerance in Elixir and Erlang. Some key points include: 1) Erlang was designed for concurrency and high availability from the start, with lightweight processes and supervision trees that restart failed processes. 2) Elixir builds on Erlang's concurrency primitives like processes, message passing, and links to provide robust fault tolerance. 3) The document covers various Elixir and Erlang concurrency features like processes, message passing, supervision trees, links, and more.

1. ELIXIRTolerância a Falhas para Adultos
@akitaonrails

2. @akitaonrails

7. 23 e 24 de
Setembro
@rubyconfbr

9. FIM DA LEI DE
MOORE

10. THREADS!
(NÃO USE)

11. THREADS!
(NÃO USE)

13. EVENTOS!
(NÃO USE)

14. EVENTOS!
(NÃO USE)

17. BAIXA LATÊNCIA

18. CO-ROTINAS
(SUBROTINAS, FIBRAS)

19. CASOS REAIS

23. “Since cut-over of the first nodes in British Telecom's network
in January 2002 only one minor fault has occurred, resulting in
99.9999999% availability.”
“The network performance has been so reliable that there is
almost a risk that our field engineers do not learn maintenance
skills.”
Bernt Nilsson - director of Ericsson’s Next Generation Systems program

33. BÁSICO …

36. PEER-TO-PEER
NETWORKING

39. [a, b, c] = [a, 2, 3]
{:ok, message} = {:ok, “world"}
{:ok, [hello: message]} = {:ok, [hello: “world”]}
[hello: message, world: message2]
#=> [{:hello, message}, {:world, message2}]

40. [a, b, c] = [a, 2, 3]
{:ok, message} = {:ok, “world"}
{:ok, [hello: message]} = {:ok, [hello: “world”]}
[hello: message, world: message2]
#=> [{:hello, message}, {:world, message2}]

41. [a, b, c] = [a, 2, 3]
{:ok, message} = {:ok, “world"}
{:ok, [hello: message]} = {:ok, [hello: “world”]}
[hello: message, world: message2]
#=> [{:hello, message}, {:world, message2}]

42. [a, b, c] = [a, 2, 3]
{:ok, message} = {:ok, “world"}
{:ok, [hello: message]} = {:ok, [hello: “world”]}
[hello: message, world: message2]
#=> [{:hello, message}, {:world, message2}]

43. PATTERN
MATCHING

46. CALL BY
PATTERN

47. Spawn, Send,
Receive

48. "PID"
(Process ID)

63. PROCESSOS
(GREEN THREADS)

64. List/Kill

94. ASYNCHRONOUS
EXCEPTIONS

95. ASYNCHRONOUS
EXCEPTIONS

96. Link, Flag

113. ACTORS!

114. GenServer

115. [h, t] = [1, 2, 3]
#=> h = 1, t = [2,3]
Process.list |> Enum.reverse
#=> Enum.reverse(Process.list())

116. [h, t] = [1, 2, 3]
#=> h = 1, t = [2,3]
Process.list |> Enum.reverse
#=> Enum.reverse(Process.list())

168. SUPERVISOR TREE
(supervisor - supervisees/workers)

169. OTP
(Open Telecom Platform)

172. MICRO
“YOCTO”
SERVICES
(Micro > Nano > Pico > Femto > Atto > Zepto > Yocto)

173. MICRO
“YOCTO”
SERVICES
(Micro > Nano > Pico > Femto > Atto > Zepto > Yocto)

174. MICRO
“YOCTO”
SERVICES
(Micro > Nano > Pico > Femto > Atto > Zepto > Yocto)

179. • Keywords, Maps, Comprehensions

180. • Keywords, Maps, Comprehensions
• Documentação testável/executável

181. • Keywords, Maps, Comprehensions
• Documentação testável/executável
• TypeSpecs, Behaviors

182. • Keywords, Maps, Comprehensions
• Documentação testável/executável
• TypeSpecs, Behaviors
• Agents, Tasks, GenEvent

183. • Keywords, Maps, Comprehensions
• Documentação testável/executável
• TypeSpecs, Behaviors
• Agents, Tasks, GenEvent
• Macros, Sigils

184. • Keywords, Maps, Comprehensions
• Documentação testável/executável
• TypeSpecs, Behaviors
• Agents, Tasks, GenEvent
• Macros, Sigils
• Armazenamento: ETS, DETS, Mnesia

185. Javascript -
shared mutable global state
Blocking Event Loop
Rust -
Low Level
Async in progress
No coroutines
Go
Suture
(OTP Clone)
goroutines sem ID
shared mutable state
static signatures
Scala
Akka
(OTP Clone)
shared mutable state
static signatures
Clojure Pulsar / Quasar
Almost Erlang-like Process
JVM limitations

186. “quase” …

187. Erlang:
PRONTO!
(30 anos)

190. APRENDENDO

202. OBRIGADO!
www.akitaonrails.com/elixir
@akitaonrails