The document discusses various aspects of Elixir, a functional programming language designed for concurrent and distributed systems. It covers features such as immutability, pattern matching, and its lack of traditional object-oriented elements like classes and inheritance. Additionally, it highlights Elixir's metaprogramming capabilities and its growing ecosystem.

1. @marekkirejczyk

2. Founder & animatorAgile Coach
Shareholder & advisor VP of engineering

3. Some random Rails problems
● gem explosion (e.g. background processing)
● websockets
● scaling, deployment, transparent failover
● ddd, dci, microservices

4. Still there is no real competition to RoR on
horizont? Or is there?
It is all getting complex

6. Elixir?
● Compiled to Erlang VM
● Created by Jose Valim

7. Elixir?
● Purely functional (no state!)
● Concurrency oriented, distributed
● Fault tolerant
● Strong metaprogramming
● Growing Ecosystem

8. Elixir is purely functional

9. Some basic data types
● (Immutable) Lists: [1, 2, 3]
● (Immutable) Tuples: {:meaning_of_life, 42}
● (Immutable) Strings: “Hello Elixir”

10. No loops!
sum = 0
for(i = 0; i < array.length; i++) {
sum += array[i]
}

11. List & recursion
def sum_list([head|tail], accumulator) do
sum_list(tail, head + accumulator)
end
sum_list([1,2,3], 0)

12. List & Enum
Enum.reduce([1, 2, 3], 0, fn(x, acc) -> x + acc end)
or
Enum.reduce([1, 2, 3], 0, &+/2)

13. Lists & Streams
1..100_000 |>
Stream.map(&(&1 * 3)) |>
Stream.filter(odd?) |>
Enum.sum

14. No classes
class String
...
end
String.new

15. defmodule Math do
def sum(a, b) do
a + b
end
end
Modules

16. Modules
s = “hello”
String.length s
Kernel.byte_size s
byte_size s

17. ● No inheritance
● No mixins
● No interfaces
● No OOP, DCI
No classes

18. Elixir encourage SOLID
design

19. Protocols
defprotocol Blank do
@doc "Returns true if data is blank"
def blank?(data)
end

20. Protocols implementation
defimpl Blank, for: Integer do
def blank?(_), do: false
end
defimpl Blank, for: List do
def blank?([]), do: true
def blank?(_), do: false
end

21. Pattern matching and tuples
{a, b, c} = {:hello, "world", 42}
{:hello, _, c} = {:hello, "world", 42}
{:yellow, _, c} = {:hello, "world", 42}

22. Why Pattern matching
● tuples are used all the time for everything
(remember: no classes!)
● exceptions usage is discouraged
● managing messages (see later)

23. Concurrency oriented,
distributed

24. Spawning a process is easy
spawn fn -> 1 + 2 end

25. Sending a message is easy
send self(), {:hello, "world"}

26. Receiving
receive do
{:hello, msg} -> msg
{:world, msg} -> "won't match"
end

27. State
The way to store state in elixir is to spawn
processes.

28. Concurrency oriented, distributed
● GenServer
● GenEvent
● Supervisors
● Distributed configuration

29. Metaprogramming

30. Quote
quote do: sum(1, 2, 3)
{:sum, [], [1, 2, 3]}
quote do: 1 + 2
{:+, [context: Elixir, import: Kernel], [1, 2]}

31. defmacro macro_unless(clause, expression) do
quote do
if(!unquote(clause), do: unquote(expression))
end
end

32. And… what else?
● Mix
● www.phoenixframework.org

33. elixir-lang.org

35. Questions?
@marekkirejczyk