O Elixir da IoT

Geovane Fedrecheski

geonnave@

Hello

IoT/Swarm Group

IoT?

The Internet

The Internet of Things

IoT applications

Smart infrastructure

Healthcare

Logistics

Social applications

 

Industry case

T

T

T

H

H

A

Demo

mix firmware
mix firmware.burn
defmodule Blinky do
  @on_duration  200 # ms
  @off_duration 200 # ms

  require Logger

  def start(_type, _args) do
    {:ok, gpio_11_pid} = Gpio.start_link(11, :output)
    spawn fn -> blink_led_forever(gpio_11_pid) end
    {:ok, self}
  end


  defp blink_led_forever(gpio_11_pid) do
    Gpio.write(gpio_11_pid, 1)
    Logger.info "gpio_11_pid ON"
    :timer.sleep @on_duration

    Gpio.write(gpio_11_pid, 0)
    Logger.info "gpio_11_pid OFF"
    :timer.sleep @off_duration

    blink_led_forever(gpio_11_pid)
  end
end

WTF

Elixir?

-Java?? Look at Haskell, or Erlang

So what's interesting about

this Erlang thing?

What even an "Erlang" is?

Erlang

  • Concurrency
  • Soft real-time
  • Distribution
  • Continuous Operation
  • Fault Tolerance

~1980

  • Concurrency
  • Soft real-time
  • Distribution
  • Continuous Operation
  • Fault Tolerance

Functional
Processes (instead of objects)

Cases

Processes

Concurreny

Fault tolerance

Data structures

Consistent libs

Modern tooling

I loved everything that Erlang had

but I hated everything that it didn't had

- José Valim

José Valim

Core committer

Unsatisfied with thread-based concurrency

~2010

=>

Elixir

~2011

Elixir

Goals

  • Extensibility

  • Productivity

  • Compatibility

Elixir

Erlang

The VM

Concurreny

Fault tolerance

Data structures

Consistent libs

Modern tooling

defmodule SumServer do
  use GenServer
  
  def start do
    GenServer.start(__MODULE__, nil)
  end

  def sum(server, a, b) do
    GenServer.call(server, {:sum, a, b})
  end
  
  def handle_call({:sum, a, b}, _from, state) do
    {:reply, a + b, state}
  end
end
-module(sum_server).

-behaviour(gen_server).
-export([
  start/0, sum/3,
  init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2,
  code_change/3
]).

start() -> gen_server:start(?MODULE, [], []).

sum(Server, A, B) -> gen_server:call(Server, {sum, A, B}).

init(_) -> {ok, undefined}.
handle_call({sum, A, B}, _From, State) -> {reply, A + B, State};
handle_cast(_Msg, State) -> {noreply, State}.
handle_info(_Info, State) -> {noreply, State}.
terminate(_Reason, _State) -> ok.
code_change(_OldVsn, State, _Extra) -> {ok, State}.

Pattern Matching

> {method, path} = {:get, "temp"}
{:get, "temp"}
> method
:get
> path
"temp"
request = {:get, "temp"}



case request do
  {:post, path, payload} ->
    send_resp 200
  {:get, path} ->
    send_resp 200, "{'value':17.5, 'unit': 'celsius'}"
end
defmodule Math do
  def fib(0), do: 0
  def fib(1), do: 1
  def fib(n), do: fib(n-1) + fib(n-2)
end

Math.fib(8) # => 21

Processes

spawn

A lightweight thread of execution

(The key Erlang/Elixir abstraction)

other_function() |> new_function() |> baz() |> bar() |> foo()
foo(bar(baz(new_function(other_function()))))

Pipe Operator

Processes are key

Performance

Concurrent applications

https://github.com/doomspork/elixir-companies

IoT =~

Embedded webservices

O Elixir da IoT

Raspberry Pi

Beaglebone Black

defmodule Blinky do
  @on_duration  200 # ms
  @off_duration 200 # ms

  require Logger

  def start(_type, _args) do
    {:ok, gpio_11_pid} = Gpio.start_link(11, :output)
    spawn fn -> blink_led_forever(gpio_11_pid) end
    {:ok, self}
  end


  defp blink_led_forever(gpio_11_pid) do
    Gpio.write(gpio_11_pid, 1)
    Logger.info "gpio_11_pid ON"
    :timer.sleep @on_duration

    Gpio.write(gpio_11_pid, 0)
    Logger.info "gpio_11_pid OFF"
    :timer.sleep @off_duration

    blink_led_forever(gpio_11_pid)
  end
end
wget 'http://director.downloads.raspberrypi.org/
raspbian_lite/images/raspbian_lite-2016-09-28/
2016-09-23-raspbian-jessie-lite.zip'

unzip 2016-09-23-raspbian-jessie-lite.zip
sudo dd \
 if/2016-09-23-raspbian-jessie-lite.img \
 of/dev/sdc
sudo vi /etc/apt/sources.list
# deb http://packages.erlang-solutions.com/debian wheezy contrib

wget http://packages.erlang-solutions.com/debian/erlang_solutions.asc
sudo apt-key add erlang_solutions.asc

sudo apt-get update
sudo apt-get install git erlang

git clone https://github.com/elixir-lang/elixir.git
cd elixir
git checkout tags/v1.3.4
make clean test

# waaaaaaaaaaaaaait a LOT (aprox. 1h)

export PATH="$PATH:/path/to/elixir/bin"

SSH

defmodule Broker.AccessControl do
  use GenServer

  def start_link do
    GenServer.start_link(__MODULE__, [], name: __MODULE__)
  end

  def authorize(request) do
    GenServer.call __MODULE__, {:authorize, request}
  end

  def handle_call({:authorize, request}, _from, _current) do
    ans = Broker.AccessControl.PDP.authorize(request)
    {:reply, ans, ans}
  end
end

Compile on board takes time...

host$ ssh pi@192.168.0.1

pi$ mix nerves.new hello_nerves --target rpi
pi$ cd hello_nerves
pi$ mix deps.get
pi$ mix compile
# takes TIME...

pi$ iex -S mix

But..

  • Repeat the process for each board?

    • Maybe write a script

  • Configuration/Compilation Takes time..

  • What if want to use another board? (will need a different setup)

Nerves

Craft and deploy bulletproof embedded software in Elixir

Code

Package

Run

Prepare

mix nerves.new hello_nerves --target rpi3
cd hello_nerves
mix deps.get
mix compile
(write your project in Elixir)
mix firmware
mix firmware.burn
NERVES_TARGET=bbb mix compile

Based on

https://buildroot.org/

Buildroot is a simple, efficient and easy-to-use tool to generate embedded Linux systems through cross-compilation.

Code

Package

Run

Prepare

VM

ARM

Toolchain

=

+

+

|>

{

,

}

=

FOTA (Firmware Over the Air) Upgrades!

$ http POST "192.168.0.121:8988/firmware" \
content-type:application/x-firmware \
x-reboot:true < firmware.fw

Run

How does it compare?

Image sizes

Nerves

Raspbian

~300MB

~20MB

Boot time

Nerves

Raspbian

~30 sec.

~3 sec.

Multiple Boards

Nerves

Raspbian

All drivers included

Nerves

Raspbian

The VM

Concurreny

Fault tolerance

Data structures

Consistent libs

Modern tooling

+

Small images

Multiple boards

Quick iteration

Cases

For more Information

http://nerves-project.org/

Obrigado

elixir-lang.slack.com
www.meetup.com/elug_sp

elixir-lang.org
nerves-project.org

IoT Architectures and Implementations

Functionaλ Programming

f(g(x), h(...))

Steve Vinoski, IEEE Computing Society 2009

"... ironically, the resurgence of interest in FP languages owes a lot to Java’s popularity."

"Another reason [...] is the move toward multicore architectures."

"... developers look for the opportunity to
get more done with less."

Welcome to the Functional Web

The Funcional Web

request
|> route()
|> handle()
|> send_resp()
send_resp(handle(
  route(request)))

Functional Programming Languages

Lisp

Elm

Elixir

Unsatisfied with thread-based concurrency

Repetitive strain

injury

by Bruce A. Tate

A bit of History

Erlang

context

Created in the Telecommunication industry

...

~1980

Programming language

Virtual Machine - BEAM

Framework - OTP

-module(fact).
-export([fac/1]).

fac(0) -> 1;
fac(N) -> N * fac(N-1).

Elixir

~2011

Features

Anonymous Functions

> add = fn(a, b) -> a + b end
#Function<12.71889879/2 in :erl_eval.expr/5>
> add.(1, 2)
3
> Enum.map([17.9, 20.2, 18.4], fn(x) -> x * 2 end)
[35.8, 40.4, 36.8]

Can be passed as parameters

Processes

spawn

A lightweight thread of execution

(The key Erlang/Elixir abstraction)

How is this different from threads?

  • No shared memory

  • VM Processes

Do not share memory

Communicate via

Message Passing

message

VM Processes

Excuse me, have you ever heard of (VM) processes?

Erlang VM

Scheduler

Sched.

Sched.

Sched.

OS Processes

OS Threads

VM Processes

OS 

pid = spawn(fn ->
  :timer.sleep(3000)
  IO.puts "hi"
end)

fn ..

spawn

self()

sleep
puts

A lightweight thread of execution

Messages

pid = spawn(...)
send(pid, "hello")
receive do
  msg ->
    IO.puts msg
end

fn ..

spawn

self()

receive
send
Node.spawn(
  :"app@computer-2",
  fn -> Hello.world end)
send
receive
app@computer-1
app@computer-2

Distributed

Same syntax

We have:

  • Isolated Processes

  • Message passing

  • Distribution

We want:

  • Fault Tolerance

dangling processes!

spawn
spawn

call the supervisor

supervisor

worker

worker

worker

worker

Supervision Tree

import Supervisor.Spec

children = [
  worker(Cache, []),
  supervisor(DatabaseSupervisor, []),
  supervisor(TCPSupervisor, [4040])
]

Supervisor.start_link(children, strategy: :one_for_one)

Applications

your app

http
server

logger

app@computer-1

Distributed Applications

app@computer-2

Fault Tolerance

Open Telecom Platform

  • Supervisor

  • Application

  • GenServer

  • GenEvent

OOP

Objects

Elixir

Processes

Production-ready?

https://github.com/doomspork/elixir-companies

Main challenges

  • Resource constrained
  • Power efficiency
  • Communication unreliability
  • Context sensitivity
  • Remote management
  • Concurrency

Popular languages for IoT

  • C
  • C++
  • Java
  • Javascript
  • Python

http://www.techworm.net/2016/06/best-programming-language-iot.html

Making the IoT
Functional with Elixir:
Four scenarios

  • Easy CoAP binary parser
     

  • Fault-tolerant microservices

  • Elixir and Java load test
     

  • Automatic deployment of Elixir images

CoAP

  • Constrained Application Protocol

  • kind of a "smaller HTTP, for IoT"

request

response

CoAP - Codes

(binary header)

0.01 (GET) (Request)

0.02 (POST) (Request)

2.05 (Content) (Response)

4.04 (Not Found) (Response)

000.00001

000.00010

010.00101

100.00100

CoAP

parser

1

0

0

0.01

123

01000000 00000001 0000000001111011 11111111

255

64 1 0 123 255

(empty)

(empty)

(empty)

%Message(type: :con,
         code: :get,
         msg_id: 123,
         options: [])
int coap_parseHeader(coap_header_t *hdr, 
                     const uint8_t *buf,
                     size_t buflen)
{
    if (buflen < 4)
        return COAP_ERR_HEADER_TOO_SHORT;
    hdr->ver = (buf[0] & 0xC0) >> 6;
    if (hdr->ver != 1)
        return COAP_ERR_VERSION_NOT_1;
    hdr->t = (buf[0] & 0x30) >> 4;
    hdr->tkl = buf[0] & 0x0F;
    hdr->code = buf[1];
    hdr->id[0] = buf[2];
    hdr->id[1] = buf[3];
    return 0;
}

https://github.com/1248/microcoap/blob/master/coap.c

C

def decode(<<1::2, type::2, token_len::4,
             code_class::3, code_detail::5,
             msg_id::16,
             token::binary-size(token_len),
             rest::binary>>) do
def decode(<<1::2, type::2, token_len::4,
             code_class::3, code_detail::5,
             msg_id::16,
             token::binary-size(token_len),
             rest::binary>>) do
  code = decode_code(code_class, code_detail)
  token = decode_token(token, token_len)
  {options, payload} =
    decode_options_and_payload(rest)

  %Message{
    version: 1,
    type: Registry.from(:types, type),
    code: code,
    msg_id: msg_id, token: token,
    options: options, payload: payload
  }
end
int coap_parseHeader(coap_header_t *hdr, 
                     const uint8_t *buf,
                     size_t buflen)
{
    if (buflen < 4)
        return COAP_ERR_HEADER_TOO_SHORT;
    hdr->ver = (buf[0] & 0xC0) >> 6;
    if (hdr->ver != 1)
        return COAP_ERR_VERSION_NOT_1;
    hdr->t = (buf[0] & 0x30) >> 4;
    hdr->tkl = buf[0] & 0x0F;
    hdr->code = buf[1];
    hdr->id[0] = buf[2];
    hdr->id[1] = buf[3];
    return 0;
}

Microservices

Source: http://martinfowler.com/articles/microservices.html

Microservices features

Source: http://martinfowler.com/articles/microservices.html

  • Services as components

  • Organized as business capabilites

  • Smart endpoints and dumb pipes

  • Decentralized Governance

  • Decentralized Data Management

  • Infrastructure Automation

  • Design for failure

  • Evolutionary Design

Microservices

"... my primary guideline would be:
don't even consider microservices unless you have a system that's too complex to manage as a monolith

Martin Fowler, MicroservicePremium, May 2015

The Swarm at the edge of the cloud

Elixir in times of microservices*

  • Processes as nanoservices

  • Processes packaged in Applications

  • Fault-tolerant processes

  • Process supervisors

  • Distributed Erlang

*http://blog.plataformatec.com.br/2015/06/elixir-in-times-of-microservices/

Elixir and Java

load test

Swarm Broker

Swarm Broker

Comparison

  • Lines of Code

  • CPU

  • Memory

  • Requests / sec.

Platform

  • Quad-core computer (x86)

  • 6GB of RAM

  • Java 1.8

  • Erlang 18.2

  • Elixir 1.2

  • Load test tool: Tsung 1.6

Lines of Code

Elixir

Java

551

176

Lines of Code

CPU

Memory

Requests / sec.

Obrigado

Gracias

Merci

Thanks

Appendix

:observer.start

(slide intentionally left blank)

(this is the appendix!)

Code

Compiler

Erlang

VM

(other OS processes)

OS 

defmodule Math do
  # this is a comment.
  # below is a function
  def sum(a, b) do
    a + b
  end
end
# pattern matching is like method
# overloading on steroids!

defmodule Math do
  def zero?(0) do
    true
  end
  def zero?(x) when is_integer(x) do
    false
  end
end
{a, b, c} = {:hello, "world", 42} 
a # has value :hello
b # "world"
c # 42
b = :binary.encode_unsigned(258)
# b has value <<1, 2>>
<<x, 2>> = b
# x has value 1
i = :binary.decode_unsigned(<<x, 2>>)
# i has value 258

Elixir

Some Drips

my = self() #PID<0.141.0>

pid = spawn(fn -> 
  :timer.sleep(3000)
  send(my, {:get, "temp"})
end)

receive do # will block for 3 secs!
  {:post, path} ->
    IO.puts "was a post on path '#{path}'"
  {:get, path} ->
    IO.puts "was a get on path '#{path}'"
end

Pattern Matching

> x = 1
1
> 1 = x
1
> 2 = x
** (MatchError)

x = 1

The "match operator"

Assignment

match values

AND

bind values to variables

Code

Package

Run

Prepare

Elixir e a Internet das Coisas Funcional

By Geovane Fedrecheski

Made with Slides.com

Elixir e a Internet das Coisas Funcional

  • 694

More from Geovane Fedrecheski