Hello elixir (and otp)

HELLO ELIXIR (AND OTP)
Abel Muiño (@amuino) & Rok Biderman (@RokBiderman)

ULTRA SHORT INTROS
Abel Muiño
Lead developer at Cabify. Works with ruby for a living.
abel.muino@cabify.com / @amuino
Rok Biderman
Senior Go developer at Cabify. Has an interesting past position.
Go ask him.
rok.biderman@cabify.com / @RokBiderman

WE ARE HIRING
Ruby, Go, Javascript, Android, iOS
(Just not for Elixir, yet)

GOALS
➤ Show some code, this is a programming meet up
➤ Share our Elixir learning path
➤ Learn something from feedback and criticism
➤ Hopefully at least one other person will learn one thing

“This is not production code
-Abel Muiño

BUILDING AN
OCR MODULE
Extracting quotes from
memes

TL;DR
http://github.com/amuino/ocr

MIX NEW
$ mix new ocr
* creating README.md
* creating .gitignore
* creating mix.exs
* creating config
* creating config/config.exs
* creating lib
* creating lib/ocr.ex
* creating test
* creating test/test_helper.exs
* creating test/ocr_test.exs
Your Mix project was created successfully.
You can use "mix" to compile it, test it, and more:
cd ocr
mix test
Run "mix help" for more commands.

MIX NEW
$ mix new ocr
* creating mix.exs
* creating config
* creating lib
* creating test
cd ocr
mix test
Project Definition

MIX NEW
$ mix new ocr
* creating mix.exs
* creating config
* creating lib
* creating test
cd ocr
mix test
Project Definition
App config

MIX NEW
$ mix new ocr
* creating mix.exs
* creating config
* creating lib
* creating test
cd ocr
mix test
Project Definition
App config
Main module

MIX NEW
$ mix new ocr
* creating mix.exs
* creating config
* creating lib
* creating test
cd ocr
mix test
Project Definition
App config
Main module
😓Not talking about tests today

THE INTERACTIVE SHELL
$ iex -S mix
Erlang/OTP 18 [erts-7.3] [source] [64-bit] [smp:8:8] [async-
threads:10] [hipe] [kernel-poll:false] [dtrace]
Compiled lib/ocr.ex
Generated ocr app
Consolidated List.Chars
Consolidated Collectable
Consolidated String.Chars
Consolidated Enumerable
Consolidated IEx.Info
Consolidated Inspect
Interactive Elixir (1.2.5) - press Ctrl+C to exit (type h()
ENTER for help)
iex(1)> Ocr
Ocr

$ iex -S mix
Compiled lib/ocr.ex
Generated ocr app
ENTER for help)
iex(1)> Ocr
Ocr
Automatically
compiles new files

$ iex -S mix
Compiled lib/ocr.ex
Generated ocr app
ENTER for help)
iex(1)> Ocr
Ocr
Automatically
compiles new files
Lots of first-run noise

$ iex -S mix
Compiled lib/ocr.ex
Generated ocr app
ENTER for help)
iex(1)> Ocr
Ocr
Automatically
compiles new files
Lots of first-run noise
SUCCESS!
Our module exists

💡TIP: TRAINING WHEELS
➤ We are learning, so getting quick feedback is useful
➤ Credo is a static code analysis tool for the Elixir language with a
focus on teaching and code consistency. 
https://github.com/rrrene/credo
➤ Credo installs as a project dependency
➤ Adds a new task to mix to analyse our code
➤ Excellent, very detailed, feedback

ADD A DEPENDENCY
Find the dependency info in hex.pm
Edit mix.exs
defp deps do
[
{:credo, "~> 0.3", only: [:dev]}
]
end
Install it locally
$ mix geps.get

ADD A DEPENDENCY
Edit mix.exs
defp deps do
[
{:credo, "~> 0.3", only: [:dev]}
]
end
Install it locally
$ mix geps.get
Dependencies are an
array of tuples.

ADD A DEPENDENCY
Edit mix.exs
defp deps do
[
{:credo, "~> 0.3", only: [:dev]}
]
end
Install it locally
$ mix geps.get
Dependencies are an
array of tuples.
Only installs the
dependency in the :dev
environment

TRY IT
$ mix credo
…
Code Readability
[R] ! Modules should have a @moduledoc tag.
lib/ocr.ex:1:11 (Ocr)
$ mix credo lib/ocr.ex:1:11

TRY IT
$ mix credo
…
Code Readability
OMG!

TRY IT
$ mix credo
…
Code Readability
OMG!
Detailed explanation on the
error, how to suppress it,
etc…

NOW WHAT?
➤ Use Google Vision API to perform the actual OCR
➤ Has no client in hex.pm
➤ It is a REST API → {:httpoison, "~> 0.8.3"}
➤ Returns JSON → {:poison, "~> 2.1.0"}
➤ Needs authentication → {:goth, "~> 0.1.2”}
➤ Build a nice façade

MIX.EXS
def application do
[applications: [:logger, :httpoison, :goth]]
end
defp deps do
[
{:httpoison, "~> 0.8.3"},
{:poison, "~> 2.1.0"},
{:goth, "~> 0.1.2"},
{:credo, "~> 0.3", only: [:dev]}
]
end

MIX.EXS
def application do
[applications: [:logger, :httpoison, :goth]]
end
defp deps do
[
{:httpoison, "~> 0.8.3"},
{:poison, "~> 2.1.0"},
{:goth, "~> 0.1.2"},
{:credo, "~> 0.3", only: [:dev]}
]
end
Some deps also need
their app to be started

CONFIG/CONFIG.EXS
use Mix.Config
config :goth,
json: "config/google-creds.json" |> File.read!

CONFIG/CONFIG.EXS
use Mix.Config
config :goth,
json: "config/google-creds.json" |> File.read!
Some deps also have
their own config

NOW WHAT?
➤ We will write 2 modules:
➤ Ocr.GoogleVision for the API client.
➤ Ocr for our façade

💡TIP: MODULE NAMES
➤ Convention:
➤ Ocr ! lib/ocr.ex
➤ Ocr.GoogleVision ! lib/ocr/google_vision.ex
➤ Modules names are just names. Dots in the name do not
represent any parent/child relationship.

LIB/OCR/GOOGLE_VISION.EX
defmodule Ocr.GoogleVision do
def extract_text(image64) do
image64 |> make_request |> read_body
end
# MAGIC!
end

end
# MAGIC!
end
base64
encoded
image

end
# MAGIC!
end
base64
encoded
image
send to
Google

end
# MAGIC!
end
base64
encoded
image
send to
Google
get the text
from the
response

@url "https://vision.googleapis.com/v1/images:annotate"
@feature_text_detection "TEXT_DETECTION"
@auth_scope "https://www.googleapis.com/auth/cloud-platform"
def make_request(image64) do
HTTPoison.post!(@url, payload(image64), headers)
end
defp payload(image64) do
%{requests: [
%{image: %{content: image64},
features: [%{type: @feature_text_detection}]}
]
} |> Poison.encode!
end
defp headers do
{:ok, token} = Goth.Token.for_scope(@auth_scope)
[{"Authorization", "#{token.type} #{token.token}"}]
end

end
%{requests: [
]
} |> Poison.encode!
end
defp headers do
end
Module attributes (used as a constants)

end
%{requests: [
]
} |> Poison.encode!
end
defp headers do
end
HTTP POST some JSON to some URL
with some Headers

end
%{requests: [
]
} |> Poison.encode!
end
defp headers do
end
with some Headers
The JSON Google wants

end
%{requests: [
]
} |> Poison.encode!
end
defp headers do
end
with some Headers
Get a token

end
%{requests: [
]
} |> Poison.encode!
end
defp headers do
end
with some Headers
Get a token
Put the token on the request headers

def read_body(%HTTPoison.Response{body: body, status_code: 200})
do
body |>
Poison.decode! |>
get_in(["responses", &first/3, "textAnnotations",
&first/3, "description"])
end
defp first(:get, nil, _), do: nil
defp first(:get, data, next) do
data |> List.first |> next.()
end

do
body |>
Poison.decode! |>
end
end
Only care about body and success http status

do
body |>
Poison.decode! |>
end
end
Parse JSON response

do
body |>
Poison.decode! |>
end
end
Parse JSON response
Extract the text

do
body |>
Poison.decode! |>
end
end
Parse JSON response
Extract the text
Custom lookup functions

do
body |>
Poison.decode! |>
end
end
Parse JSON response
Extract the text
Custom lookup functions
funky syntax to invoke an
anonymous function

💡TIP: GET_IN IS AWESOME
➤ Navigates nested structures (maps)
iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
iex> get_in(users, ["john", :age])
27
➤ Returns nil on missing keys
iex> get_in(users, ["unknown", :age])
nil
➤ Accepts functions for navigating other types
➤ Elixir 1.3 will have common functions predeﬁned for tuples
and lists
➤ Access.at(0) will replace my custom first (PR #4719)
➤ Also check get_and_update_in, put_in, update_in

LIB/OCR.EX
defmodule Ocr do
def from_base64(b64), do: Ocr.GoogleVision.extract_text(b64)
def from_image(image_data) do
image_data |> Base.encode64 |> from_base64
end
def from_path(path), do: path |> File.read! |> from_image
def from_url(url), do: HTTPoison.get!(url).body |> from_image
end

FUN!
$ iex -S mix
Erlang/OTP 18 [erts-7.3] [source] [64-bit] [smp:8:8] [async-threads:
10] [hipe] [kernel-poll:false] [dtrace]
A new Hex version is available (0.12.0), please update with `mix
local.hex`
Interactive Elixir (1.2.5) - press Ctrl+C to exit (type h() ENTER for
help)
iex(1)> meme_url = "http://ih0.redbubble.net/image.16611809.2383/fc,
550x550,black.jpg"
"http://ih0.redbubble.net/image.16611809.2383/fc,550x550,black.jpg"
iex(2)> IO.puts Ocr.from_url meme_url
GETS ELIKIR PR ACCEPTED
I SAID WHO WANTS TO
FUCKING TOUCH ME?
Suranyami
:ok

STATEFUL? STATELESS?
Cast your vote!

ANSWER: STATEFUL
➤ Auth tokens are not requested every time
➤ Requested on ﬁrst use
➤ Refreshed on the background when about to expire
➤ Goth.TokenStore is a GenServer
➤ Just one of the predeﬁned behaviours to make easier to
work with processes
➤ Starts a process with some state
➤ Receives messages and updates the state
➤ There is more state (like Goth.Config)

DEPS/GOTH/LIB/GOTH/TOKEN_STORE.EX
defmodule Goth.TokenStore do
use Xenserver
alias Goth.Token
def start_link do
GenServer.start_link(__MODULE__, %{}, [name: __MODULE__])
end
def handle_call({:store, scope, token}, _from, state) do
pid_or_timer = Token.queue_for_refresh(token)
{:reply, pid_or_timer, Map.put(state, scope, token)}
end
def handle_call({:find, scope}, _from, state) do
{:reply, Map.fetch(state, scope), state}
end
end

use Xenserver
alias Goth.Token
def start_link do
end
end
end
end
Start the process,

use Xenserver
alias Goth.Token
def start_link do
end
end
end
end
Start the process, Initial state is an empty map

use Xenserver
alias Goth.Token
def start_link do
end
end
end
end
The process has a name

use Xenserver
alias Goth.Token
def start_link do
end
end
end
end
The process has a name
Handle 2 types of messages, returning something

FUN WITH TOKEN STORE
$ iex -S mix
iex(1)> token = %Goth.Token{token: "FAKE",
expires: :os.system_time + 10_000_000}
%Goth.Token{expires: 1464647952951907000, scope: nil,
token: "FAKE", type: nil}
iex(2)> GenServer.call Goth.TokenStore, {:find, "Elixir"}
:error
iex(3)> GenServer.call Goth.TokenStore, {:store, "Elixir",
token}
{:ok, {1464647950910798703208727, #Reference<0.0.7.228>}}
{:ok,
token: “FAKE", type: nil}}

$ iex -S mix
:error
token}
{:ok, {1464647950910798703208727, #Reference<0.0.7.228>}}
{:ok,
The process name

$ iex -S mix
:error
token}
{:ok, {1464647950910798703208727, #Reference<0.0.7.228>}}
{:ok,
The process name
The message

def store(%Token{}=token), do: store(token.scope, token)
def store(scopes, %Token{} = token) do
GenServer.call(__MODULE__, {:store, scopes, token})
end
def find(scope) do
GenServer.call(__MODULE__, {:find, scope})
end
end

def store(%Token{}=token), do: store(token.scope, token)
def store(scopes, %Token{} = token) do
GenServer.call(__MODULE__, {:store, scopes, token})
end
def find(scope) do
GenServer.call(__MODULE__, {:find, scope})
end
end
Provide a client API (usually in the same module)
with nicer methods hiding the use of
Genserver.call

LET’S TALK ABOUT OTP
Processes, state, concurrency, supervisors,… oh my!

RECAP
➤ Erlang is:
➤ general-purpose
➤ concurrent
➤ garbage-collected
➤ programming language
➤ and runtime system
➤ Elixir:
➤ Builds on top of all that

START A PROCESS
➤ Basic concurrency primitive
➤ Simplest way to create, use spawn with a function
defmodule BasicMessagePassing.Call do
def concat(a, b) do
IO.puts("#{a} #{b}")
end
end
iex(2)> BasicMessagePassing.Call.concat "Elixir", "Madrid"
Elixir Madrid
:ok
iex(3)> spawn BasicMessagePassing.Call, :concat, ["Elixir", "Madrid"]
Elixir Madrid
#PID<0.69.0>

START A PROCESS
def concat(a, b) do
end
end
Elixir Madrid
:ok
Elixir Madrid
#PID<0.69.0>
Same process

START A PROCESS
def concat(a, b) do
end
end
Elixir Madrid
:ok
Elixir Madrid
#PID<0.69.0>
Same process
Spawned process id

LISTEN FOR MESSAGES
defmodule BasicMessagePassing.Listen do
def listen do
receive do
{:ok, input} -> IO.puts "#{input} Madrid"
end
end
end
iex(5)> pid = spawn(BasicMessagePassing.Listen, :listen, [])
#PID<0.82.0>
iex(6)> send pid, {:ok, "Elixir"}
Elixir Madrid
{:ok, "Elixir"}
iex(8)> Process.alive? pid
false

FIBONACCI TIME!
defmodule FibSerial do
def calculate(ns) do
ns
|> Enum.map(&(calc(&1)))
|> inspect
|> IO.puts
end
def calc(n) do
calc(n, 1, 0)
end
defp calc(0, _, _) do
0
end
defp calc(1, a, b) do
a + b
end
defp calc(n, a, b) do
calc(n - 1, b, a + b)
end
end
FibSerial.calculate(Enum.to_list(1..10000))

FIBONACCI TIME!
defmodule FibSerial do
ns
|> Enum.map(&(calc(&1)))
|> inspect
|> IO.puts
end
def calc(n) do
calc(n, 1, 0)
end
defp calc(0, _, _) do
0
end
defp calc(1, a, b) do
a + b
end
defp calc(n, a, b) do
calc(n - 1, b, a + b)
end
end
FibSerial.calculate(Enum.to_list(1..10000)) About 6 seconds

PARALLEL FIBONACCI TIME!
defmodule FibParallel do
ns
|> Enum.with_index
|> Enum.map(fn(ni) -> spawn FibParallel, :send_calc, [self, ni] end)
listen(length(ns), [])
end
def send_calc(pid, {n, i}) do
send pid, {calc(n), i}
end
defp listen(lns, result) do
receive do
fib ->
result = [fib | result]
if lns == 1 do
result
|> Enum.sort(fn({_, a}, {_, b}) -> a < b end)
|> Enum.map(fn({f, _}) -> f end)
|> inspect
|> IO.puts
else
listen(lns - 1, result)
end
end
end
end
FibSerial.calculate(Enum.to_list(1..10000))

PARALLEL FIBONACCI TIME!
defmodule FibParallel do
ns
|> Enum.with_index
|> Enum.map(fn(ni) -> spawn FibParallel, :send_calc, [self, ni] end)
listen(length(ns), [])
end
def send_calc(pid, {n, i}) do
send pid, {calc(n), i}
end
defp listen(lns, result) do
receive do
fib ->
result = [fib | result]
if lns == 1 do
result
|> Enum.sort(fn({_, a}, {_, b}) -> a < b end)
|> Enum.map(fn({f, _}) -> f end)
|> inspect
|> IO.puts
else
listen(lns - 1, result)
end
end
end
end
FibSerial.calculate(Enum.to_list(1..10000)) About 2 seconds (4 cores)

LINKING PROCESSES
➤ If child dies, parent dies
defmodule BasicMessagePassing.Linking do
def exit, do: exit(:crash)
def start do
spawn_link(BasicMessagePassing.Linking, :exit, [])
receive do
{:done} -> IO.puts "no more waiting"
end
end
end
iex(13)> BasicMessagePassing.Linking.start
** (EXIT from #PID<0.57.0>) :crash
help)
iex(1)>

LINKING PROCESSES
➤ If child dies, parent dies
def start do
receive do
{:done} -> IO.puts "no more waiting"
end
end
end
** (EXIT from #PID<0.57.0>) :crash
help)
iex(1)>
iex died! and was restarted

LINKING PROCESSES
➤ If child dies, parent dies… unless it handles the dead
def start do
Process.flag(:trap_exit, true)
receive do
{:EXIT, from_pid, reason} -> IO.puts "#{inspect(self)} is
aware #{inspect(from_pid)} exited because of #{reason}"
end
end
end
#PID<0.57.0> is aware #PID<0.157.0> exited because of crash
:ok

LINKING PROCESSES
def start do
receive do
end
end
end
:ok
survive children

LINKING PROCESSES
def start do
receive do
end
end
end
:ok
survive children
handle deads

GENSERVER
➤ Simpliﬁes all this stuﬀ
➤ Is a process like any other Elixir process
➤ Standard set of interface functions, tracing and error reporting
➤ call: request with response
➤ cast: request without response

A STACK
defmodule Stack do
use GenServer
def start_link(state, opts []) do
GenServer.start_link(__MODULE__, state, opts)
end
def handle_call(:pop, _from, [h|t]) do
{:reply, h, t}
end
def handle_cast({:push, h}, t) do
{:noreply, [h|t]}
end
end

A SUPERVISED STACK
iex(7)> import Supervisor.Spec
nil
iex(8)> children = [
...(8)> worker(Stack, [[:first], [name: :stack_name]])
...(8)> ]
[{Stack, {Stack, :start_link, [[:first], [name: :stack_name]]}, :permanent,
5000, :worker, [Stack]}]
iex(9)> {:ok, pid} = Supervisor.start_link(children, strategy: :one_for_one)
{:ok, #PID<0.247.0>}
iex(10)> GenServer.call(:stack_name, :pop)
:first
18:04:35.012 [error] GenServer :stack_name terminating
** (FunctionClauseError) no function clause matching in Stack.handle_call/3
iex:13: Stack.handle_call(:pop, {#PID<0.135.0>, #Reference<0.0.1.317>}, [])
[..]
Last message: :pop
State: []
(elixir) lib/gen_server.ex:564: GenServer.call/3
:first

SUPERVISOR FLAVORS
➤ one_for_one: dead worker is replaced by another one
➤ rest_for_all: after one dies, all others have to be restarted
➤ rest_for_one: all workers started after this one will be
restarted
➤ simple_one_for_one: for dynamically attached children,
Supervisor is required to contain only one child

THANKS!
Abel Muiño (@amuino) & Rok Biderman (@RokBiderman)

Hello elixir (and otp)

More Related Content

What's hot

Viewers also liked

Similar to Hello elixir (and otp)

Recently uploaded

Hello elixir (and otp)