Phoenix demysitify, with fun

Who am I
@taiansu
|>
|> Ruby
|> React.js, Redux, Rx.js
|> RailsGirls.tw & Elixir.tw
http://taian.su
facebook.com/sutaian

Elixir Taiwan
» Facebook: Elixir Taiwan
» Slack: elixirtw.slack.com
» KKTIX: elixirtw.kktix.cc

Dave Thomas droped by Taiwan
at 2014

Elixir =~
Ruby syntax + Erlang speciality
and some more

Erlang
from 1986
open-sourced in 1998

Build for Telecom switch system
at beginning
» Functional
» Soft real time
» Concurrent
» 99.999% up-time, including upgrade and hot-fix
» Hot update

On the fly update, literally*.
Erlang AR drone in-flight upgrade

Compare with system process
» C# process:
300µs per process
50µs per message
» Erlang VM process:
1µs up to 2,500 processes
3µs up to 30,000 processes
0.8µs per message

We do not have ONE web server handling 2 millions sessions.
We have 2 million web servers handling one session each.
» Joe Armstrong

process in Erlang/Elixir
=~
object instance in OO application

github.com/taiansu/game_of_life_elixir

Weakness
» Hard real time
» Processing big chunk of data (Video, Audio)
» Uncommon syntax
» String

Syntax
-module(mym).
-export([max/2]).
max(X, Y) ->
if
X > Y -> X;
X < Y -> Y;
true -> nil
end.

Erlang string: a list of integer
[1, 2, 3] % [1, 2, 3]
[119, 97, 116, 63, 33] % "wat?!"
<<119, 97, 116, 63, 33>> % Bit-syntax from R16

Elixir
by José Valim at 2013
Rails core team member

Pattern matching
What's the "=" means, seriously?

Pattern matching basic
# Ruby
x, x, y = [1, 2, 3] # => x = 2, y = 3
# Elixir
[x, x, y] = [1, 2, 3] # => (MatchError) no match of right hand side value
[x, x, y] = [1, 1, 3] # => x = 1, y = 3
[head | tail] = [1, 2, 3, 4] # => head = 1, tail = [2, 3, 4]
{:ok, contents} = File.read("my_app.conﬁg")

Pattern matching: recursive
defmodule Factorial do
def calc(0), do: 1
def calc(val), do: val * calc(val - 1)
end
Factorial.calc(100)

Pattern matching with function, contd.
parse_response = fn
{:err, msg} ->
show_error(msg)
{:ok, article = %{title: title, content: content}} ->
# article = %{title: "abc", content: "123"}
# title = "abc"
# content = "123"
render(title, content)
_ ->
IO.puts "Huston, we have a problem."
end
parse_response.(response)

OTP compliant
GenServer, Supervisor, GenEvent, Application

Case: useless variable
request = generate_request
response = get_response(request)
body = parse_body(response, :html)
html = render(body)
# otherwise
html = render(parse_body(get_response(generate_request), :html))

Pipe operator: |>
html = generate_request
|> get_response
|> parse_body(:html)
|> render

Meta-programming
macro, quote and unquote, to AST
live demo ( if enough time )
quote do: 1 + 2 * 3

github.com/taiansu/pipe_to
2
|> Enum.drop(1..10, _)
|> Enum.at(1)

Code with doctest
defmodule Num do
@doc """
Demonstrate doctest feature
## Example
iex> Num.is_even?(1)
true
"""
def is_even?(num) do
rem(num, 2) == 0
end
end

Phoenix is Rails with less magic

Demysitify: Both are MVC framework with
» Routes
» Controller
» Model
» View
» assets

Core idea of phoenix:
Your entire web application is a function

The conn variable pipe through the whole system

Routes & Controller
Basically the same

Model and ORM
SQL wrapper named Ecto

Ecto
defmodule MyApp.Order
schema "orders" do
belongs_to :user, MyApp.User
has_many :order_items, MyApp.OrderItem
ﬁeld :code, :string
ﬁeld :payment_method, :string
end
# query functions here
end

Ecto query functions
def query_cart_of_user(query __MODULE__, user_id) do
from o in query,
where: o.user_id == ^user_id
end
def order_by_created_at(query __MODULE__) do
from o in query,
order_by: o.created_at
end
## in Controller
orders = %Order{}
|> query_cart_of_user(20)
|> order_by_created_at
|> Repo.all

File: template/order/show.html.eex
<h2>
Hi! this is the show page!<%= order_name(@conn, @order) %>
</h2>

File: /view/order_view.ex
defmodule MyApp.OrderView do
use MyApp.Web, :view
def render("show.html", params []) do
~E{
<h2>Hi! this is the show page!<%= order_name(@conn, @order) %></h2>
}
end
def order_name(conn, order) do
user = conn.assigns[:current_user]
"#{user.name}: #{order.name} x #{order.quantity}"
end
end

What I've learned
» Different paradiam expand your horizon
» Which is a knowledge you can bring with you anywhere
» Composability over REUSE
» Think in process way
» And...

Code with Fun
Just like Ruby tought us, thanks Matz.

Thanks for your time!
Any Questions?
more plans on going, join Elixir.tw!

Phoenix demysitify, with fun

More Related Content

What's hot (20)

Viewers also liked (16)

Similar to Phoenix demysitify, with fun (20)

Recently uploaded (20)

Phoenix demysitify, with fun