O documento descreve o processo de envio de notificações em Elixir, incluindo: (1) o cliente cria regras para segmentar usuários e define a mensagem; (2) o serviço busca os dados de envio e envia as notificações para provedores de forma concorrente; (3) Elixir é usado por ser funcional, concorrente e tolerante a falhas, atendendo aos requisitos de escalabilidade, resiliência e manutenibilidade.

1. Envio de notificação
em Elixir

2. O que é o envio de
uma notificação?

3. Algoritmo
• Cliente cria uma regra que define quais dos seus usuários
devem receber a mensagem (segmentação)
• Cliente define a mensagem (e-mail, SMS, browser-push, etc) a
ser enviada para o segmento feito
• Cliente, através plataforma da Dito, inicia o envio da notificação
• O serviço de envio inicia a busca dos dados do envio
(mensagem da notificação, dados dos usuários, etc)
• Concorrentemente ao passo anterior, o serviço de envio, inicia o
envio das notificações para os provedores (Movile, Firebase,
etc)

4. SQS Load
Send
Middleware
Redis
SQS
Serviços Dito
Serviços Dito
Serviços Dito
Firebase
Movile
*Diagrama meramente ilustrativo

5. A complexidade nos trás
algumas preocupações
• Escalabilidade
• Resiliência
• Manutenibilidade
• Extensibilidade
• SLA de uptime

6. Elixir
• Funcional
• Concorrente
• Tolerante a falhas
• Distribuída

7. Tipos básicos

8. Function
sum = fn a, b !->
a + b
end
sum = &(&1 + &2)

9. Integer e Float
def sum(a, b) do
a + b
end
sum(1, 1) !=> 2 # integer
sum(1.5, 2) !=> 3.5 # float

10. Boolean
x = true
y = false
z = x !&& y

11. String
first_name = "Felipe"
last_name = "Rosa"
first_name !<> " " !<> last_name

12. Atom
x = :qualquercoisa

13. List
prices = [19.99, 178.8, 22.13]
List.first(prices) !=> 19.99

14. Tuples
{:error, "algum erro"}
{"Calça Jeans", 399.99}

15. Map
x = %{a: 1, b: 2}
x[:a]
# 1
y = %{:a !=> 1, "b" !=> 2, {1, 2} !=> 3}
y[{1, 2}]
# 3

16. Alguns tipos não
apresentados aqui
• Keyword lists
• Char lists
• Bitstrings
• PID
• Reference

17. Módulos e Funções

18. Funções devem ser
definidas sempre
dentro de módulos

19. # módulos são definidos com defmodule
defmodule M do
# e funções com def
def f(arg1, arg2) do
IO.puts(arg1 + arg2)
end
end
M.f(1, 2) # "3"

20. Podemos sobrecarregar
funções pela quantidade
de argumentos

21. defmodule M do
def f(arg1) do
IO.puts(arg1)
end
def f(arg1, arg2) do
IO.puts(arg1 + arg2)
end
end
M.f(1) # "1"
M.f(1, 2) # "3"

22. Funções podem ter
argumentos com valor
padrão

23. defmodule M do
def f(arg1, arg2 & 0) do
IO.puts(arg1 + arg2)
end
end
M.f(1) # "1"

24. Os nomes das funções
sempre contêm a
quantidade de argumentos
defmodule M do
def f(a) !=> M.f/1
def g(a, b) !=> M.g/2
end

25. Pattern Matching

26. Podemos usar pattern
matching para extrair valores
de estruturas de dados

27. x = 1
# x !=> 1
{:ok, y} = {:ok, 1}
# y !=> 1
%{a: x, b: y} = %{a: 1, b: 2}
# x !=> 1
# y !=> 2

28. Também podemos usar
pattern matching para
verificar valores

29. 1 = 1
# Tudo certo!
2 = 1
# Erro!
1 = 2
# Erro!
{:a, 1} = {:b, 1}
# Erro!

30. case pode ser usado para
executar diferentes fluxos do
programa com pattern matching

31. x = {:a, 1}
case x do
{:a, x} !-> IO.puts(x)
{:b, y} !-> IO.puts(y)
_ !-> IO.puts("!??")
end
# "1"

32. Podemos definir vários
casos para uma função com
pattern matching também

33. defmodule M do
def f(:a), do: 1
def f(:b), do: 2
end
M.f(:a) # 1
M.f(:b) # 2
M.f(:c) # Erro!

34. Processos

35. pid = spawn(fn !->
IO.puts("oi")
end)

36. Processos são isolados. Sua
única forma de comunicação é
através de troca de mensagens.

37. pid1 = spawn(fn !->
receive do
{:a, a} !-> IO.puts("a: !#{a}")
{:b, b} !-> IO.puts("b: !#{b}")
_ !-> IO.puts("unknown message")
end
end)
pid2 = spawn(fn !->
send(pid1, {:a, 1})
end)
# pid1 printa "a: 1"

38. Como processos executam em
ambientes isolados, se ocorrer
um erro, apenas o processo do
erro é afetado.

39. GenServer

40. defmodule S do
use GenServer
def start_link(_args) do
GenServer.start_link(!__MODULE!__, :ok, [])
end
def init(:ok) do
{:ok, 0}
end
def handle_call(:get, _from, state) do
{:reply, state, state}
end
def handle_cast(:inc, state) do
{:noreply, state + 1}
end
end

41. Iniciando o GenServer
def start_link(_args) do
GenServer.start_link(!__MODULE!__, :ok, [])
end
def init(:ok) do
{:ok, 0}
end
# Uso
{:ok, pid} = S.start_link([])

42. Utilizando o GenServer
def handle_call(:get, _from, state) do
{:reply, state, state}
end
def handle_cast(:inc, state) do
{:noreply, state + 1}
end
GenServer.call(pid, :get)
# 0
GenServer.cast(pid, :inc)
# :ok
GenServer.call(pid, :get)
# 1