Erlang Virtual Machine

Bogdan/Björn's Erlang Abstract Machine (BEAM)

https://www.erlang.org/

Kaczmarczyk, James

Sakai, Christian

Resilient Distributed Nature of Erlang

"If Java is 'write once, run anywhere', then Erlang is 'write once, run forever'"

Joe Armstrong,

creator of Erlang

A Quick Introduction about Elixir

http://elixir-lang.org/

Basic Syntax

# Basic syntax
defmodule Example do
  def add_one_to_one do
    1 + 1
  end
end

iex(2)> Example.add_one_to_one()
2

Execute a function add_one_to_one that is located in module Example.
The execution returns 2 as a result

Actor Concurrency Model

• Everything is a process
   
• Each process performs a specific task.
   
• To tell a process to do something, you need to send it a message. The process can reply by sending back another message.
   
• The kinds of messages the process can act on are specific to the process itself. In other words, messages are pattern-matched. Other than that, processes don’t share any information with other processes.

Process 101

Spawn a Process

defmodule SpawnExample do
  def say_hi do
    IO.puts "Hello!"
  end
end

iex(2)> spawn(SpawnExample, :say_hi, [])
Hello!
#PID<0.91.0>

iex(3)> spawn_link(SpawnExample, :say_hi, [])
Hello!
#PID<0.93.0>

iex(4)> spawn_monitor(SpawnExample, :say_hi, [])
Hello!
PID<0.95.0>

Spawn another process. If this spawned process dies, the spawner process stays alive and unaffected.

Spawn another process. If this spawned process dies, the spawner process also dies.

Spawn another process. If this spawned process dies, the spawner process gets notified.

Process Message Passing

defmodule MessageExample do
  def listen do
    receive do
      {:hello_cutie, from} ->
        IO.puts """
        Received :hello_cutie from 
        #{inspect(from)},
        but not going to reply back.
        """

      {:please_reply, from} ->
        IO.puts """
        Received :please_reply from 
        "#{inspect(from)}",
        all right, I'll reply back.
        """

        send(from, :what)

      {:kill_yourself, from} ->
        IO.puts """
        Told to kill myself from 
        #{inspect(from)},
        fine, I'll kill myself.
        """

        Process.exit(self(), :kill)
    end
  end
end

Distributed and Fault Tolerance

Fault Tolerance

• "Let it crash" philosophy, means delegating error detection and handling to another process and not coding too defensively
   
• Links set up bidirectional relationships between processes that serve to propagate exit signals when a crash happens in one of the progress
   
• Monitors set up a unidirectional relationship between processes so that the monitoring process is notified when a monitored process dies. Exit signals can be trapped by system processes that convert exit signals into normal messages. You implemented a simple supervisor process using processes and links.

Fault Tolerance

defmodule Juliet do
  def listen_for_love_letter do
    receive do
      {:i_love_you, from} ->
        send(from, :i_love_you_too)

      {:lets_die_together, from} ->
        Process.exit(self(), :kill)

      {:do_my_math_homework, from} ->
        1 / 0
    end
  end
end

defmodule Romeo do
  def listen_for_reply do
    receive do
      :i_love_you_too ->
        IO.puts "Yeah! she loves me too"
    end
  end
end

iex(4)> my_pid = self()
#PID<0.96.0>
iex(5)> {juliet_pid, _} = spawn_monitor(Juliet, :listen_for_love_letter, [])
{#PID<0.106.0>, #Reference<0.0.4.146>}
iex(6)> juliet_pid
#PID<0.106.0>
iex(7)> send(juliet_pid, {:do_my_math_homework, self()})
{:do_my_math_homework, #PID<0.96.0>}
iex(8)>
18:03:10.576 [error] Process #PID<0.106.0> raised an exception
** (ArithmeticError) bad argument in arithmetic expression
    process.exs:94: Juliet.listen_for_love_letter/0

nil
iex(9)> Process.alive?(juliet_pid)
false
iex(10)> Process.alive?(my_pid)
true

iex(2)> juliet_pid = spawn(Juliet, :listen_for_love_letter, [])
#PID<0.99.0>
iex(3)> send(juliet_pid, {:i_love_you, self()})
{:i_love_you, #PID<0.96.0>}
iex(4)> Romeo.listen_for_reply()
Yeah! she loves me too

iex(2)> self()
#PID<0.96.0>
iex(3)> juliet_pid = spawn_link(Juliet, :listen_for_love_letter, [])
#PID<0.100.0>
iex(4)> send(juliet_pid, {:lets_die_together, self()})
** (EXIT from #PID<0.96.0>) killed

BEAM to BEAM Native Communication over Network

The Erlang VM, called Beam, is more than a simple interpreter. It’s like its own little operating system running on top of your host operating system.

It handles its own events, process scheduling, memory, naming services, and interprocess communication. In addition to all that, a node can connect to other nodes— in the same computer, across a LAN, or across the Internet— and provide many of the same services across these connections that it provides to the processes it hosts locally.

BEAM to BEAM Native Communication over Network

BEAM to BEAM Native Communication over Network

We call an instance of BEAM over a network, a "Node"

Remote Method Invocation with BEAM

⇒  iex --sname boss job.exs
Erlang/OTP 19 [erts-8.0.2] [source] [64-bit] [smp:4:4] [async-threads:10] [hipe] [kernel-poll:false] [dtrace]

Interactive Elixir (1.3.4) - press Ctrl+C to exit (type h() ENTER for help)
iex(boss@Christian-Sakais-MacBook-Pro)1> Node.connect(:"worker@Christian-Sakais-MacBook-Pro")
true
iex(boss@Christian-Sakais-MacBook-Pro)2> func = fn -> IO.inspect(Node.self()) end
#Function<20.52032458/0 in :erl_eval.expr/5>
iex(boss@Christian-Sakais-MacBook-Pro)3> Node.spawn(:"worker@Christian-Sakais-MacBook-Pro", func)
:"worker@Christian-Sakais-MacBook-Pro"
#PID<12320.98.0>
iex(boss@Christian-Sakais-MacBook-Pro)4>

⇒  iex --sname worker
Erlang/OTP 19 [erts-8.0.2] [source] [64-bit] [smp:4:4] [async-threads:10] [hipe] [kernel-poll:false] [dtrace]

Interactive Elixir (1.3.4) - press Ctrl+C to exit (type h() ENTER for help)
iex(worker@Christian-Sakais-MacBook-Pro)1> Node.list
[:"boss@Christian-Sakais-MacBook-Pro"]
iex(worker@Christian-Sakais-MacBook-Pro)2> self()
#PID<0.86.0>
iex(worker@Christian-Sakais-MacBook-Pro)3>

Send a local function to be invoked in other Node

Remote Method Invocation with BEAM

⇒  iex --sname boss
Erlang/OTP 19 [erts-8.0.2] [source] [64-bit] [smp:4:4] [async-threads:10] [hipe] [kernel-poll:false] [dtrace]

Interactive Elixir (1.3.4) - press Ctrl+C to exit (type h() ENTER for help)
iex(boss@Christian-Sakais-MacBook-Pro)1> Node.connect(:"worker@Christian-Sakais-MacBook-Pro")
true
iex(boss@Christian-Sakais-MacBook-Pro)2> Node.spawn(:"worker@Christian-Sakais-MacBook-Pro", Job, :work, [])
#PID<8967.95.0>
Boss told me, #PID<0.95.0>, to do work
iex(boss@Christian-Sakais-MacBook-Pro)3>

⇒  iex --sname worker job.exs
Erlang/OTP 19 [erts-8.0.2] [source] [64-bit] [smp:4:4] [async-threads:10] [hipe] [kernel-poll:false] [dtrace]

Interactive Elixir (1.3.4) - press Ctrl+C to exit (type h() ENTER for help)
iex(worker@Christian-Sakais-MacBook-Pro)1>

Tell other Node to execute its function

defmodule Job do
  def work do
    IO.puts "Boss told me, #{inspect self()}, to do work"
  end
end

Open Telecom Platform (OTP)

• Initially used to build telephone exchanges and switches. Since these devices have the same characteristics we want from any large online distributed application, so OTP is now a general-purpose tool for developing and managing large systems.

• Solves common distributed system problems such as application discovery, failure detection and management, hot code swapping, and server structure.

OTP Features

• Debugger
• Supervisors
• GenServers
• GenEvent
• Mnesia
• Hot code reload
• etc

Supervision Tree