The document discusses concepts in Elixir including pattern matching, processes, global variables, and supervision. It provides examples of spawning processes, sending messages between processes, linking processes, and using the Agent module to implement a global stack data structure. It also shows how to create a supervisor module to restart the stack process if it crashes, providing fault tolerance.

1. ELIXIRTolerância a Falhas para Adultos
Fabio Akita

2. @akitaonrails@akitaonrails

3. Rubyconf Brasil 2016 – 23 e 24 de SetembroRubyconf Brasil 2016 – 23 e 24 de Setembro

4. Rubyconf Brasil 2016 – 23 e 24 de SetembroRubyconf Brasil 2016 – 23 e 24 de Setembro

5. Rubyconf Brasil 2016 – 23 e 24 de SetembroRubyconf Brasil 2016 – 23 e 24 de Setembro

7. Chris McCordChris McCord José ValimJosé Valim

8. Joe Armstrong - EricssonJoe Armstrong - Ericsson

11. defmodule Teste do
def say(name) do
IO.puts("Hello #{name}")
end
end
Teste.say("Fabio")
defmodule Teste do
@spec say(String.t)
def say(name) when is_string(name) do
IO.puts "Hello " <> name
end
end
Teste.say "Fabio"

12. OPTIONAL PARENTHESIS

13. -module(teste).
-export([qsort/1]).
qsort([]) -> [];
qsort([Pivot|T]) ->
qsort([X||X<-T,X =< Pivot]) ++
[Pivot] ++
qsort([X||X<-T,X > Pivot]).
defmodule Teste do
def qsort([]), do: []
def qsort([pivot|t]) do
qsort(for x <- t, x < pivot, do: x) ++
[pivot] ++
qsort(for x <- t, x >= pivot, do: x)
end
end

14. defmodule Teste do
def factorial(n) do
if n == 0 do
1
else
n * factorial(n - 1)
end
end
end
Teste.factorial(10)
# => 3628800
defmodule Teste do
def factorial(0), do: 1
def factorial(n) do
n * factorial(n - 1)
end
end
Teste.factorial(10)
# => 3628800

15. CALL BY PATTERN

16. {:ok, result} = Enum.fetch([1, 2, 3, 4], 3)
IO.puts result
# => 4
registro = {:ok, %{name: "Fabio", last_name: "Akita"}}
{:ok, %{name: name}} = registro
IO.puts name
# => Fabio
registro = %{name: "Fabio", year: 2016, foo: {:ok, [1, 2, 3]}}
%{name: name, foo: {:ok, result}} = registro
IO.puts Enum.join([name|result], ", ")
# => Fabio, 1, 2, 3
%{last_name: name} = registro
# => ** (MatchError) no match of right hand side value: ...

17. PATTERN MATCHING
(“Regex for non-String”)

18. a = 1
a = 2
IO.puts a
# => 2
^a = 3
# => ** (MatchError) no match of right hand side value: 3
message = "Hello"
IO.puts message <> " World!"
# => "Hello World!
IO.puts "#{message} World!"
# => "Hello World!
{:a, "b", 67, true}
[:a, "b", 67, true]
%{a: 1, b: 2, c: 3}
[a: 1, b: 2, c: 3]
# => [{:a, 1}, {:b, 2}, {:c, 3}]

19. range = (1..100)
interval = Enum.slice(range, 30, 10)
evens = Enum.filter(interval, fn(n) -> rem(n, 2) == 0 end)
multiplied = Enum.map(evens, fn(n) -> n * 10 end)
Enum.take(multiplied, 2)
range = (1..100)
# => [1, 2, 3, 4 ... 98, 99, 100]
interval = Enum.slice(range, 30, 10)
# => [31, 32, 33, 34, 35, 36, 37, 38, 39, 40]
evens = Enum.filter(interval, fn(n) -> rem(n, 2) == 0 end)
# => [32, 34, 36, 38, 40]
multiplied = Enum.map(evens, fn(n) -> n * 10 end)
# => [320, 340, 360, 380, 400]
Enum.take(multiplied, 2)
# => [320, 340]

20. range = (1..100)
interval = Enum.slice(range, 30, 10)
evens = Enum.filter(interval, fn(n) -> rem(n, 2) == 0 end)
multiplied = Enum.map(evens, fn(n) -> n * 10 end)
Enum.take(multiplied, 2)
Enum.take(
Enum.map(
Enum.filter(
Enum.slice((1..100), 30, 10),
fn(n) -> rem(n, 2) == 0 end
),
fn(n) -> n * 10 end
), 2
)

21. range = (1..100)
interval = Enum.slice(range, 30, 10)
evens = Enum.filter(interval, fn(n) -> rem(n, 2) == 0 end)
multiplied = Enum.map(evens, fn(n) -> n * 10 end)
Enum.take(multiplied, 2)
(1..100)
|> Enum.slice(30, 10)
|> Enum.filter(fn(n) -> rem(n, 2) end)
|> Enum.map(fn(n) -> n * 10 end)
|> Enum.take(2)

22. (1..100)
|> Enum.slice(30, 10)
|> Enum.filter(&(rem(&1, 2)))
|> Enum.map(&(&1 * 10))
|> Enum.take(2)
(1..100)
|> Enum.slice(30, 10)
|> Enum.filter(fn(n) -> rem(n, 2) end)
|> Enum.map(fn(n) -> n * 10 end)
|> Enum.take(2)

23. PIPE OPERATOR
|>

24. function = fn -> IO.puts("Hello from function") end
function.()
# => Hello from function
pid = spawn(function)
# => Hello from function
Process.alive?(pid)
# => false
Process.alive?(self)
# => true

25. pid = spawn(fn ->
receive do
{:say, from} ->
send(from, "say what?")
_ ->
Process.exit(self, :normal)
end
end)
Process.alive?(pid)
# => true
send(pid, {:say, self})
receive do
message ->
IO.puts("Recebido: " <> message)
end
# => Recebido: say what?
send(pid, "blabla")
Process.alive?(pid)
# => false

26. “PROCESSES”
Lightweight
Isolated
Message passing
Mailbox
Garbage Collected

27. pid = spawn(fn -> ... end)
Process.exit(pid, :kill)

28. pid = spawn_link(fn ->
receive do
{:say, from} ->
send(from, "say what?")
_ ->
Process.exit(self, :normal)
end
end)
send(pid, "blabla")
** (EXIT from #PID<0.47.0>) killed

29. pid = spawn_link(fn -> ... end)
Process.exit(pid, :kill)

30. pid = spawn_link(fn ->
receive do
{:say, from} ->
send(from, "say what?")
_ ->
Process.exit(self, :normal)
end
end)
Process.flag(:trap_exit, true)
send(pid, "blabla")
receive do
{:EXIT, _pid, reason} ->
IO.puts("Motivo do crash: #{reason}")
end
# => Motivo do crash: normal

31. ASYNCHRONOUS
EXCEPTIONS
(spawn_link, flag, exit)

32. “GLOBALS”
Javascript
Scala
Go
Clojure
...

33. defmodule Stack do
def start_link do
Agent.start_link(fn -> [] end,
name: __MODULE__)
end
def pop do
Agent.get_and_update(__MODULE__,
fn(state) ->
[head|tail] = state
{head, tail}
end)
end
def push(new_value) do
Agent.update(__MODULE__,
fn(state) ->
[new_value|state]
end)
end
end

34. Stack.start_link
Stack.push "hello"
Stack.push "world"
Stack.pop
# => world
Stack.pop
# => hello
Process.list |> Enum.reverse |> Enum.at(0) |> Process.exit(:kill)
Stack.push "foo"
# => ** (exit) exited in: GenServer.call(Stack, {:update, ...,
5000)
# ** (EXIT) no process
# (elixir) lib/gen_server.ex:564: GenServer.call/3

35. defmodule Stack.Supervisor do
use Supervisor
def start_link do
Supervisor.start_link(__MODULE__, :ok)
end
def init(:ok) do
children = [
worker(Stack, [])
]
supervise(children, strategy: :one_for_one)
end
end

36. Stack.Supervisor.start_link
Stack.push "hello"
Stack.push "world"
Stack.pop
# => world
Stack.pop
# => hello
Process.list |> Enum.reverse |> Enum.at(0) |> Process.exit(:kill)
Stack.push "foo"
Stack.push "bla"
Stack.pop
# => bla
Stack.pop
# => foo

37. Stack.Supervisor.start_link
Process.list |> Enum.reverse |> Enum.at(0) |> Process.exit(:kill)

46. “YOCTO” SERVICES
(micro > nano > pico > femto > atto > zepto > yocto>

52. APRENDENDO

57. OBRIGADO!
Perguntas?
@akitaonrails