An intro to Elixir 

A is not a Sandwich 

This talk - About Me - wtf is Elixir - Basics - Cool in Elixir - Phoenix 

I’m Tommy 

I’m Tommy - ~3 years @ Deliveroo 

I’m Tommy - ~3 years @ Deliveroo - Ruby for ~10 years 

I’m Tommy - ~3 years @ Deliveroo - Ruby for ~10 years - Elixir for ~2 years 

I’m Tommy - ~3 years @ Deliveroo - Ruby for ~10 years - Elixir for ~2 years - I know that I look like Tormund Giantsbane 

wtf is Elixir? 

wtf is Elixir? Elixir is a dynamic, functional language designed for building scalable and maintainable applications. 

wtf is Elixir? - Created in 2012 by José Valim (former Rails Core Team) 

wtf is Elixir? - Created in 2012 by José Valim (former Rails Core Team) - Built on top of, and compiles to, Erlang 

wtf is Elixir? - Created in 2012 by José Valim (former Rails Core Team) - Built on top of, and compiles to, Erlang - Functional 

wtf is Elixir? - Created in 2012 by José Valim (former Rails Core Team) - Built on top of, and compiles to, Erlang - Functional - Built with distributed resiliency in mind 

Built on top of Erlang 

Built on top of Erlang - Made by Ericsson in 1986 

Built on top of Erlang - Made by Ericsson in 1986 - Erlang runs: 

Built on top of Erlang - Made by Ericsson in 1986 - Erlang runs: - WhatsApp 

Built on top of Erlang - Made by Ericsson in 1986 - Erlang runs: - WhatsApp - Facebook Messanger 

Built on top of Erlang - Made by Ericsson in 1986 - Erlang runs: - WhatsApp - Facebook Messanger - SMS 

Built on top of Erlang - Made by Ericsson in 1986 - Erlang runs: - WhatsApp - Facebook Messanger - SMS - GPRS and 3G networks 

Built on top of Erlang - Made by Ericsson in 1986 - Erlang runs: - WhatsApp - Facebook Messanger - SMS - GPRS and 3G networks - Lots of Online Gaming 

You’ve probably interacted with Erlang today and didn’t even know it 

Erlang: The Movie 

Erlang: The Moustache 

Erlang’s pretty old, so why isn’t it more popular? 

* OTP means Open Telephony Platform * Erlang/OTP is run by Ericsson * the syntax is prolog-y & not c-y or ruby-y or python-y, its just too damn erlang-y * no package manager * no list of open source packages * no community site * the mailing list is the community * everyone knows each other from Stockholm * it is too hard to get a first working app * lists for strings, aargh! * no for loops, eek! * variables don't vary, whimper! * people don't learn OTP first but start with Erlang * people don't learn Erlang first but start with OTP * no docs * too many docs but it is the wrong sort * not enough teaching materials * doesn't run on the JVM * we used to think that it was because there were no books... * Erlang Solutions isn't a proper internet company * the language develops too slowly * emacs is the IDE 

Elixir fixes these problems 

Basics 

Functional No objects! Modules, functions and arguments. Module.Module.function(arg) 

Distributed resiliency - Elixir is a multi-core language - State is held in lightweight Elixir processes - Processes can start, run, crash and restart easily 

Distributed resiliency Supervisor Process Supervisor Process Supervisor Process Worker Process Worker Process Worker Process Worker Process 

Distributed resiliency Supervisor Process Supervisor Process Supervisor Process Worker Process Worker Process Worker Process Worker Process 

Distributed resiliency Supervisor Process Supervisor Process Supervisor Process Worker Process Worker Process Worker Process 

Distributed resiliency Supervisor Process Supervisor Process Supervisor Process Worker Process Worker Process Worker Process Worker Process 

Let it crash and allow your system to recover 

Cool in Elixir 

Equals is not equals > a = 2 2 

Equals is pattern match > [1, 2, val] = [1, 2, 3] > val 3 

Equals is pattern match > [2, 4, val] = [1, 2, 3] ** (MatchError) no match of right hand side value: [1, 2, 3] 

Pattern matching a Tuple > {:hello, value} = {:hello, "world"} > value “world" 

Pattern matching a Tuple case ApiFetcher.fetch(url) do {:ok, body} -> # Do something with `body` {:error, error} -> # Do something with `error` end 

defmodule Text do def to_upcase(arg) do String.upcase(arg) end end > Text.to_upcase("hello") "HELLO" Defining functions 

defmodule Formatter do def format("up:" <> username) do String.upcase(username) end def format(“reverse:" <> title) do String.reverse(title) end end Defining multiple versions of the same function 

> Formatter.format("up:hello") "HELLO" > Formatter.format(“reverse:world") "dlrow" Defining multiple versions of the same function 

defmodule Numbers do def double(arr) do Enum.map(arr, fn(x) -> x * 2 end) end end > Numbers.double([1, 2, 3]) [2, 4, 6] Loops 

Pipes 

defmodule Formatter do def format(data) do Map.get(data, :warning) |> String.upcase |> String.reverse end end > Formatter.format(%{warning: "murder"}) "REDRUM" Pipes 

defmodule Formatter do def format(data) do Map.get(data, :warning) |> String.upcase |> String.reverse end end Pipes 

defmodule Formatter do def format(data) do data |> Map.get(:warning) |> String.upcase |> String.reverse end end Pipes 

def publish(%Post{status: status}) when status == :draft do # Publish a post end > Publisher.publish(%Post{status: :published}) ** (FunctionClauseError) no function clause matching in Publisher.publish/1 The following arguments were given to Publisher.publish/1: # 1 %Post{status: :published} Guards 

GenServer Concurrently holding state in an Elixir Process 

defmodule Basket do use GenServer def init(items) do {:ok, item} end def handle_call(:pop, _from, [head | tail]) do {:reply, head, tail} end def handle_cast({:push, item}, state) do {:noreply, [item | state]} end end GenServer 

> {:ok, pid} = GenServer.start_link(Basket, [:burger]) {:ok, #PID<0.354.0>} > GenServer.call(pid, :pop) :burger > GenServer.cast(pid, {:push, :fries}) :ok > GenServer.call(pid, :pop) :fries GenServer 

Phoenix 

Phoenix - A Rails like web framework for Elixir - Controllers - Views (like Presenters) - Templates with Embedded Elixir (.eex) - Ecto (for DB interaction, like Active Record) - WebSockets - Contexts 

WebSockets Phoenix has Channels 

defmodule ChatWeb.ChatChannel do use Phoenix.Channel def join("chat:lobby", _message, socket) do {:ok, socket} end def join("chat:" <> room_id, _params, socket) do socket = assign(socket, :room_id, room_id) {:ok, socket} end def handle_in("join_room", %{"username" => username}, socket) do body = %{ new_user: username } broadcast!(socket, “new_user”, %{body: body}) {:noreply, socket} end end Channels 

import {Socket} from "phoenix" let socket = new Socket("ws://localhost:4000/socket") socket.connect() let channel = socket.channel("room:lobby", {}) channel.join() channel.on("new_user", (body) => { console.log("New user!", body.user) }) Channels 

Without models, where do we put our code? 

No content

Contexts help us organise our code 

No content

Conclusion 

Elixir is good Phoenix is good 

No content

No content

{:ok, :finish} 

Further reading - elixir-lang.com - phoenixframework.org - github.com/h4cc/awesome-elixir - #elixir-lang on Deliveroo Slack - We’re hosting London Elixir on Tuesday