defimpl JSON, for: Integer do
def encode(i), do: # ...
end
Slide 30
Slide 30 text
concurrency
Slide 31
Slide 31 text
Any sufficiently complicated
concurrent program in another
language contains an ad hoc
informally-specified bug-ridden
slow implementation of half of
Erlang. Robert Virding
Slide 32
Slide 32 text
spawn fn ->
IO.puts "from another process"
end
Slide 33
Slide 33 text
not OSprocesses
Slide 34
Slide 34 text
lightweight
isolation
message passing
Slide 35
Slide 35 text
for _ <- 1..100_000 do
spawn(fn -> :ok end)
end
lightweight
Slide 36
Slide 36 text
animals = [:dog, :cat]
spawn fn ->
animals # it's a copy
end
isolation
Slide 37
Slide 37 text
isolation
per-process garbage
collection!!!
Slide 38
Slide 38 text
message passing
the only way
processes can
communicate
Slide 39
Slide 39 text
pid = spawn fn ->
# ...
end
send pid, "a message"
message passing
Slide 40
Slide 40 text
spawn fn ->
receive do
msg -> :ok
end
end
message passing
Slide 41
Slide 41 text
spawn_monitor fn ->
raise "die!"
end
receive do m -> m end
#=> {:DOWN, ...}
message passing
Slide 42
Slide 42 text
actor model
Slide 43
Slide 43 text
def loop(state) do
receive do
{from, :get} ->
send(from, state)
loop(state)
{from, :put, new_state} ->
loop(new_state)
end
end
Slide 44
Slide 44 text
def loop(state) do
receive do
{from, :get} ->
send(from, state)
loop(state)
{from, :put, new_state} ->
loop(new_state)
end
end
Slide 45
Slide 45 text
def loop(state) do
receive do
{from, :get} ->
send(from, state)
loop(state)
{from, :put, new_state} ->
loop(new_state)
end
end
Slide 46
Slide 46 text
def loop(state) do
receive do
{from, :get} ->
send(from, state)
loop(state)
{from, :put, new_state} ->
loop(new_state)
end
end
Slide 47
Slide 47 text
def loop(state) do
receive do
{from, :get} ->
send(from, state)
loop(state)
{from, :put, new_state} ->
loop(new_state)
end
end
Slide 48
Slide 48 text
def loop(state) do
receive do
{from, :get} ->
send(from, state)
loop(state)
{from, :put, new_state} ->
loop(new_state)
end
end
Slide 49
Slide 49 text
def loop(state) do
receive do
{from, :get} ->
send(from, state)
loop(state)
{from, :put, new_state} ->
loop(new_state)
end
end
Slide 50
Slide 50 text
def loop(state) do
receive do
{from, :get} ->
send(from, state)
loop(state)
{from, :put, new_state} ->
loop(new_state)
end
end
Slide 51
Slide 51 text
def loop(state) do
receive do
{from, :get} ->
send(from, state)
loop(state)
{from, :put, new_state} ->
loop(new_state)
end
end spawn(&loop/0)
Slide 52
Slide 52 text
Node.spawn(node, fun)
Slide 53
Slide 53 text
interop
Slide 54
Slide 54 text
Elixir data structures
are
Erlang data structures
Slide 55
Slide 55 text
lists:map(fun(X) -> X * 2 end,
[1, 2, 3]).
:lists.map(fn(x) -> x * 2 end,
[1, 2, 3])
Slide 56
Slide 56 text
:queue.in("customer1",
:queue.new())
Slide 57
Slide 57 text
tooling
Slide 58
Slide 58 text
iex> 8 * 2
16
IEx
Slide 59
Slide 59 text
mix new my_app
compile
test
deps.get
Mix
Slide 60
Slide 60 text
test "math works!" do
assert 1 + 1
end
ExUnit
Slide 61
Slide 61 text
Hey there, <%= name %>!
EEx
Slide 62
Slide 62 text
defp deps do
[{:phoenix, "~> 1.0"},
{:ecto, "~> 1.0"}]
end
Hex
Slide 63
Slide 63 text
so
Slide 64
Slide 64 text
lots of companies use Elixir in prod
it's awesome to work with
thriving ecosystem, smart devs
phoenix
metaprogramming