Introduction to the Elixir programming language by Javier Cuevas. Madrid |> Elixir meetup.

1. INTRODUCTION
TO ELIXIR
Madrid |> Elixir
29/03/2016
Offered by

2. RUBY ON RAILS SHOP
EMBRACING ELIXIR
About me:
Javier Cuevas
@javier_dev
P2P MARKETPLACE
FOR DOG OWNERS

3. About
Javier
Cuevas
Victor
Viruete
Ricardo
Garcia
Bruno
Bayón
Artur
Chruszc

4. WHAT IS
ELIXIR?

5. Elixir is a dynamic, functional language
designed for building scalable and
maintainable applications.
Elixir leverages the Erlang VM, known
for running low-latency, distributed and
fault-tolerant systems.

6. Created by José Valim circa 2012.
Former Rails Core Team member.
He was trying to make Rails really thread
safe but... ended up creating a new
programming language. Ops!

7. Elixir:
• Compiles to Erlang bytecode.
• It is not Ruby compiling to Erlang.
• Can call to any Erlang library with no performance
penalty.
• Enables developers’ productivity by offering
amazing tooling and beautiful documentation.

8. • WhatsApp
• Facebook (Chat backend)
• Amazon (SimpleDB)
• AdRoll
• Heroku
• Yahoo (Delicious)
• Ericsson (mobile networks)
• T-Mobile (SMS)
• World of Warcra!
• ....
Erlang is that ugly language from 1996 used in production
by some “small” guys such as:
2 million connections in a single node

9. WHY SHOULD I
CARE ABOUT
ELIXIR?

10. • CPUs today have gazillion of transistors (more than
ever), and a lot of cores.
• There is no way we can keep them busy by trying to
get them do all something at once.
• The only way to keep them busy is diving the work.
• In other words:
The future is functional and concurrent.

11. • Elixir proves that functional programming does not
need to be mathematical or complex.
• With Elixir we can do concurrency programming
without having to use abstractions such as locks or
semaphores.

12. How do we program without
GOTO state?
– Computer Science, 1968
How do we program without
mutable state?
– Computer Science, 2016

13. SHOW ME
THAT
ELIXIR

14. Value Types
• Integers
(arbitrary precision)
• Floats
0.12346
• Atoms (aka symbols)
:my_atom
true, false and nil are atoms
• Ranges
start..end
start & end can by any type
• Regular expresions
~r{regexp}

15. Collection Types
• Tuples (not arrays)
{:ok, 42, "next"}
• Linked Lists
(closest to arrays)
list = [1,2,3,4]
hd(list) # 1
tl(list) # [2, 3, 4]
• Binaries
<<1,2>>
Strings are UTF-8 encoded binaries.
• Maps
%{ key => value, key => value }
countries = %{"ES" => "Spain",
"Fr" => "France"}
countries["ES"] # Spain

16. System Types
• PIDs:
Reference to local or remote process.
A new PID is created when you spawn a new
process
• Ports:
Reference to a port ^_^

17. Anonymous Functions
• AKA unnamed functions.
• Can be passed as arguments (they’re also a type)
• Parenthesis are optional.
iex> add = fn (a, b) -> a + b end
#Function<12.71889879/2 in :erl_eval.expr/5>
iex> add.(1, 2)
3 that dot before parenthesis is only for calling anonymous functions

18. Named Functions
defmodule MyModule do
def say_hello(name) do
IO.puts “Hello #{name}”
end
end
iex> MyModule.say_hello("Madrid Elixir")
Hello Madrid Elixir

19. Pattern Matching
• In Elixir: a = 1
does not mean we are assigning 1 to the variable a.
• The equal signs means we are asserting that the le! hand side
(LHS) is equal to the right one (RHS).
It’s like basic algebra.
iex> a = 1
1
iex> 1 = a
1
you can’t do that in non functional languages

20. Pattern Matching
• Instead of assigning a variable, in Elixir we talk about
binding a variable.
• In contrasts to Erlang, Elixir does allow rebinding a
variable.
iex> a = 1
1
iex> a = 2
2

21. Pattern Matching
Let’s do some magic:
iex> [1, a, 3] = [1, 2, 3]
[1, 2, 3]
iex> a
2

22. Pattern Matching
You can ignore values with “_”
iex> [a, _, _] = [1, 2, 3]
[1, 2, 3]
iex> a
1

23. Pattern Matching
You can reuse the previous bind value with
the pin operator “^”
iex> a = 1
1
iex> [^a, 2, 3 ] = [ 1, 2, 3 ]
[1, 2, 3]

24. Pattern Matching &
Function Signatures
Function signatures use pattern matching.
Therefore we can have more than one signature.
defmodule Factorial do
def of(0), do: 1
def of(x), do: x * of(x-1)
end
look mum! programing without if - else

25. Guards
When pattern matching is not sufficient to select the
signature to use, we can use guards.
defmodule Factorial
do def of(0), do: 1
def of(n) when n > 0 do
n * of(n-1)
end
end

26. Guards
defmodule MyModule do
def what_is(x) when is_number(x) do
IO.puts "#{x} is a number”
end
def what_is(x) when is_list(x) do
IO.puts "#{inspect(x)} is a list"
end
end
MyModule.what_is(99) # => 99 is a number
MyModule.what_is([1,2,3]) # => [1,2,3] is a list
you can use guards with “case” too

27. Macros
• Macros enable to extend the language and to create
DSLs (domain specific languages), in order to remove
boilerplate and make code more readable.
• You won’t probably create new macros unless you’re
writing a library. They should be written responsible.

28. Macros
• Did you know that Erlang has no “if” (as the one we
have in OOP languages)?
• Elixir does have “if”, “else” and even “unless” (because
Mr. Valim is a kind person), however it is actually a
macro.
• These 3 macros rely on “case” which... (surprise!) it uses
Pattern Matching.

29. Macros
http://elixir-lang.org/docs/stable/elixir/Kernel.html#if

30. Macros
Another cool example for a DSL created with
Macros is ExUnit, the test library that comes
with Elixir:
defmodule MathTest do
use ExUnit.Case
test "basic operations" do
assert 1 + 1 == 2
end
end
macro! macro! macro!

31. Exceptions?
No! Pattern Matching!
case File.open("chain.exs") do
{ :ok, file } -> # something
{ :error, reason } -> # uh oh
end

32. Pipe Operator |>
Typical code in OOP / imperative programming:
people = DB.find_customers
orders = Orders.for_customers(people)
tax = sales_tax(orders, 2013)
filing = prepare_filing(tax)
We could rewrite it as...
filing = prepare_filing(
sales_tax(Orders.for_customers(
DB.find_customers), 2013))

33. Pipe Operator |>
With Elixir pipe operator we can do just
filing = DB.find_customers
|> Orders.for_customers
|> sales_tax(2013)
|> prepare_filing
“|>” passes the result from the le! expression as the
first argument to the right expression. Kinda like the
Unix pipe “|”. It’s just useful syntax sugar.

34. Mix
• Mix is a build tool that ships with Elixir that provides
tasks for creating, compiling, testing your application,
managing its dependencies and much more.
• Kind of like rake (Ruby) on steroids.

35. Mix
➜ ~ mix --help
mix # Runs the default task (current: "mix
run")
mix app.start # Starts all registered apps
mix archive # Lists all archives
mix archive.build # Archives this project into a .ez file
mix archive.install # Installs an archive locally
mix archive.uninstall # Uninstalls archives
mix clean # Deletes generated application files
mix cmd # Executes the given command
mix compile # Compiles source files
mix deps # Lists dependencies and their status
mix deps.clean # Deletes the given dependencies' files
mix deps.compile # Compiles dependencies
mix deps.get # Gets all out of date dependencies
mix deps.unlock # Unlocks the given dependencies
mix deps.update # Updates the given dependencies
mix do # Executes the tasks separated by comma
mix escript.build # Builds an escript for the project
mix help # Prints help information for tasks
mix hex # Prints Hex help information
mix hex.build # Builds a new package version locally
mix hex.config # Reads or updates Hex config
mix hex.docs # Publishes docs for package
mix hex.info # Prints Hex information
mix hex.key # Hex API key tasks
mix hex.outdated # Shows outdated Hex deps for the
current project
mix hex.owner # Hex package ownership tasks
mix hex.public_keys # Manages Hex public keys
mix hex.publish # Publishes a new package version
mix hex.registry # Hex registry tasks
mix hex.search # Searches for package names
mix hex.user # Hex user tasks
mix loadconfig # Loads and persists the given
configuration
mix local # Lists local tasks
mix local.hex # Installs Hex locally
mix local.phoenix # Updates Phoenix locally
mix local.public_keys # Manages public keys
mix local.rebar # Installs rebar locally
mix new # Creates a new Elixir project
mix phoenix.new # Creates a new Phoenix v1.1.4
application
mix profile.fprof # Profiles the given file or expression
with fprof
mix run # Runs the given file or expression
mix test # Runs a project's tests
iex -S mix # Starts IEx and run the default task

36. Mixfile
defmodule MyCoolProject.Mixfile do
use Mix.Project
def project do
[ app: :my_cool_projet,
version: "0.0.1",
deps: deps ]
end
# Configuration for the OTP application
def application do
[mod: { MyCoolProject, [] }]
end
# Returns the list of dependencies in the format:
# { :foobar, git: "https://github.com/elixir-lang/foobar.git", tag: "0.1" }
#
# To specify particular versions, regardless of the tag, do:
# { :barbat, "~> 0.1", github: "elixir-lang/barbat" }
defp deps do
[
{:exactor, github: "sasa1977/exactor"},
{:"erlang-serial", github: "knewter/erlang-serial", app: false}
]
end
end

37. DocTests
defmodule MyModule do
@doc ~S"""
Sums two numbers
## Examples
iex> MyModule.sum(1, 2)
3
"""
def sum(a, b) do
a + b
end
end
$ mix test
Compiled lib/my_module.ex
..
Finished in 0.1 seconds (0.1s on
load, 0.00s on tests)
2 tests, 0 failures
Randomized with seed 307356

38. OTP
• OTP stands for Open Telecom Platform, but the name is
misleading. OTP is not only for telecom related so!ware.
• It’s a bundle that includes a large number of libraries to
solve problems like state management, application
discovery, failure detection, hot code swapping, and server
structure .
• Unfortunately, we don’t have time to talk about OTP today :/

39. Erlang Observer
iex> :observer.start

40. ELIXIR FOR
WEB APPS

41. Phoenix Framework
• MVC web framework created by Chris McCord. José
Valim is working on it too.
• Tastes a little bit like Ruby on Rails, but it is not.
• Aims for high developer productivity and high
application performance.
• It has powerful abstractions for creating modern web
apps in 2016, such as Channels (~ web sockets).

42. Phoenix Framework
• Create a new project
$ mix phoenix.new hello_phoenix
• Create database
$ mix ecto.create
• Run server
$ mix phoenix.server

43. Phoenix Framework
• It’s actually the top layer of a multi-layer system
designed to be modular and flexible.
• The other layers include Plug (kind of like Ruby’s Rack),
Ecto (kind of like ActiveRecord), and Cowboy, the Erlang
HTTP server.

44. Phoenix Framework
• Thanks to the power of Elixir and the ease of use of
Channels in Phoenix we can create web apps where we
have 1 real time bi-directional data channel with every
user (a websocket). And it scales, for real.
• Despite that WebSockets are the main transport for
Phoenix’s channels, it also supports other transport
mechanism for old browsers or embedded devices.

45. Phoenix Framework
• It plays nicely with the modern front-end world (ES6) by
relying on Brunch, a fast and simple asset build tool.
• It’s very easy to replace Brunch by Webpack or any other
hipster build tool of your choice.
• Note that Brunch requires Node.js (trollface).

46. Phoenix Framework
https://www.youtube.com/watch?v=3LiLjVCDEpU

47. Phoenix Framework

48. Phoenix Framework

49. HOW FAST
IS ELIXIR?
spoiler... a lot!

50. http://bob.ippoli.to/haskell-for-erlangers-2014/#/cost-of-concurrency

52. SHOWCASE

53. Showcase
• BSRBulb: Elixir library to control a Bluetooth Smart Bulb.
https://github.com/diacode/bsr_bulb
• Phoenix Trello: a Trello tribute with Phoenix & React.
https://github.com/bigardone/phoenix-trello
https://blog.diacode.com/trello-clone-with-phoenix-and-react-pt-1
• Phoenix Toggl: a Toggl tribute with Phoenix & React.
https://github.com/bigardone/phoenix-toggl
• Elixir Toggl API Wrapper
https://github.com/diacode/togglex

54. WHERE TO
GO FROM
HERE?

55. Next steps
• Watch every talk by José Valim. Really, you won’t regret.
• Books:
Programming Elixir – Dave Thomas
Programming Phoenix – Chris McCord, Bruce Tate & José Valim.
• Elixir Getting Started Guide (really good!)
http://elixir-lang.org/getting-started/introduction.html
• Phoenix Guide (really good!)
http://www.phoenixframework.org/docs/overview
• Elixir Radar
http://plataformatec.com.br/elixir-radar
• Madrid |> Elixir Slack (#madrid-meetup)
https://elixir-slackin.herokuapp.com/

56. THANK YOU
Questions?