Making money with Erlang · Erlang having your Pi and selling it with a margin Torben Hoffmann Product & Research Manager Erlang Solutions @LeHoff Wednesday, 1 May 2013 W. Erlang

Making money with Erlang

having your Pi and selling it with a margin

Torben HoffmannProduct & Research Manager

Erlang Solutions@LeHoff

Wednesday, 1 May 2013 W

Erlang History


wantedshort time-to-market

on-the-fly upgrades

quality and reliability

and more...


wantedproductivity

no down-time

something that always works


wantedmoney

money

money


Semantic Gap


© 1999-2012 Erlang Solutions Ltd.

Small semantic gap

7

Telecom

General vs Domain Specific



Small semantic gap

7

Telecom

C++/Java




Small semantic gap

7

Telecom

C++/Java




Small semantic gap

7

Telecom

Erlang

C++/Java




Small semantic gap

7

Telecom

Erlang

C++/Java




Small semantic gap

7

Telecom

Erlang

C++/Java

Smaller gap =

money!



The Sweet SpotGUI

Drivers

MiddlewareCoordination

Control


If the glove fits...

drivers coordination GUI

needs/fit




needs/fitTelecom




needs/fit

C

Telecom




needs/fit

C

Erlang

Telecom


Erlang’s Original Requirements



• Large scale concurrency




• Soft real-time




• Soft real-time

• Distributed systems




• Soft real-time


• Hardware interaction




• Soft real-time



• Very large software systems




• Soft real-time




• Complex functionality




• Soft real-time





• Continuous operation for many years




• Soft real-time






• Software maintenance on-the-fly




• Soft real-time







• High quality and reliability




• Soft real-time







• High quality and reliability

• Fault tolerance


Simplicity


Erlang doesn’t need an IDE!

Simplicity


Erlang doesn’t need an IDE!

InspirationDies inExpansion

Simplicity



Accepting Erlang


•So if Erlang is the best thing since sliced bread, how come it is so hard to convince people to use it?


A detour:Understanding

Technology Adoptation


16

Technology Adaptation Life Cycle

Originally developed by Joe M. Bohlen, George M. Beal and Everett M. Rogers


16



Technology enthusiasts


16




Visionaries


16




Visionaries

Pragmatists


16




Visionaries

PragmatistsConservatives


16




Visionaries


Laggards


Cracks and a Chasm


Cracks and a Chasm



Cracks and a Chasm


Visionaries


Cracks and a Chasm


Visionaries

Pragmatists


Cracks and a Chasm


Visionaries



Cracks and a Chasm


Visionaries


Laggards


Cracks and a Chasm


Visionaries


Laggards

Crack


Cracks and a Chasm


Visionaries


Laggards

Crack

Crack


Cracks and a Chasm


Visionaries


Laggards

Crack

CrackChasm


Visionaries vs Pragmatists

Visionaries have four characteristics that alienate Pragmatists:



• Lack of respect for their colleagues’ experiences





• Takes greater interest in technology than in their industry






• Fail to recognise the importance of existing product infrastructure






• Fail to recognise the importance of existing product infrastructure

• Overall disruptiveness



The Whole Product


Whole Product

See Levitt’s “The Marketing Imagination” for details


Whole Product

Generic Product



Whole Product

Generic ProductExpected Product



Whole Product


Augmented Product



Whole Product


Augmented ProductPotential Product



Whole Product


Augmented ProductPotential Product


Pragmatists evaluate and buy whole products!


Whole Product Planning

GenericProduct

Standards&

Procedures AdditionalSoftware

SystemIntegration

Training&

Support

Installation&

Debugging

AdditionalHardware

Anything elseto achieve your

compelling reason to buy

Simplified for chasm crossing


Whole Product Planning

GenericProduct

Standards&

Procedures AdditionalSoftware

SystemIntegration

Training&

Support

Installation&

Debugging

AdditionalHardware

Anything elseto achieve your

compelling reason to buy

Simplified for chasm crossing

= marketing promise to win the sale


Erlang Whole Product 1/2

•Generic product:

- Erlang compiler and runtime

•Additional software:

- rich library shipped with each release

- many open source libraries

•Training & support:

- ESL provides many courses

- ErlangCamp also provides training


Erlang Whole Product 2/2

• System integration:

- mostly case-by-case

- few public success stories

• Installation & Debugging:

- Adequate functionalities for installing applications

- Lack of good mass deployment tools

- Good debugging tools, but not well publicised


Advice?


Advice?

Find a visionary with money as your sponsor!


Erlang/ALE




needs/fit




needs/fitEmbedded




needs/fit

C

Embedded




needs/fit

C

Erlang

Embedded


Introducing


Introducing

Erlang


Introducing

Erlang Actor


Introducing

Erlang ActorLibrary


Introducing

Erlang ActorLibraryfor


Introducing


Embedded


Introducing


Embedded

Erlang/ALE


Opportunities


Opportunities

Cheap, powerful hardware


Opportunities

Cheap, powerful hardwareInternet of things


Opportunities

Cheap, powerful hardwareInternet of thingsExtending solutions in field - both HW & SW


Opportunities

Cheap, powerful hardwareInternet of thingsExtending solutions in field - both HW & SWDealing with more complex problems


Opportunities

Cheap, powerful hardwareInternet of thingsExtending solutions in field - both HW & SWDealing with more complex problemsShort time-to-market


Hardware


HardwareRaspberry-Pi for fun and prototypesFor production:

Gumstix, Beaglebone.Later:

OLinuXino (<€20)


Raspberry-Pi is

NOTfor

production


Architecture


Architecture

HardwareWednesday, 1 May 2013 W

Architecture

Driver


Architecture

Driver

I/F X Process


Architecture

Driver

I/F X Process

UserProcess


Architecture

Driver

I/F X Process

UserProcess

Hardware

Erlang


Architecture

Driver

I/F X Process

UserProcess

Hardware

Erlang

C


Architecture

Driver

I/F X Process

UserProcess

Erlang/ALE

Hardware

Erlang

C


Driver


Driver

C port driver


Driver

C port drivererl_marshal


Driver

C port drivererl_marshalpthread


erl_marshalETERM*gpio_port_write(ETERM* pin_t, ETERM* value_t) { unsigned int pin; unsigned int val; pin = ERL_INT_VALUE(pin_t); val = ERL_INT_VALUE(value_t);

if (!gpio_write(pin, val)) return erl_format("{error, gpio_port_write}"); return erl_format(“ok”)

}


pthreads for

interrupts

static void *isr_handler (void *isr) { struct pollfd fdset[2]; int nfds = 2, gpio_fd, rc; char *buf[64];

isr_t i = *(isr_t *) isr;

if (isr_handler_flag) { printf ("isr_handler running\n");

/* Get /value fd TODO: Add check here */ gpio_fd = gpio_valfd (ERL_INT_VALUE(i.pinp));

if ( gpio_fd == -1) { fprintf(stderr, "Unable to open gpio fd\n\r"); return NULL; }

while (1) { memset ((void *) fdset, 0, sizeof (fdset));

fdset[0].fd = STDIN_FILENO; fdset[0].events = POLLIN;

fdset[1].fd = gpio_fd; fdset[1].events = POLLPRI;

rc = poll (fdset, nfds, 1000);! /* Timeout in ms */

if (rc < 0) { debug ("\npoll() failed!\n"); return (void *) -1; }

if (rc == 0) { /* debug ("poll() timeout.\n"); */ if (isr_handler_flag == 0) { debug ("exiting isr_handler (timeout)"); pthread_exit (NULL); } }

if (fdset[1].revents & POLLPRI) {/* We have an interrupt! */ if (-1 == read (fdset[1].fd, buf, 64)) { debug ("read failed for interrupt"); return (void *) -1; }

(*i.isr) (i.pinp, i.pidp, i.modep);! /* Call the ISR */ }

if (fdset[0].revents & POLLIN) { if (-1 == read (fdset[0].fd, buf, 1)) { debug ("read failed for stdin read"); return (void *) -1; }

printf ("\npoll() stdin read 0x%2.2X\n", (unsigned int) buf[0]); }

fflush (stdout); } } else { debug ("exiting isr_handler (flag)"); pthread_exit (NULL); }

}


I/F X Process

set_int(Pin, Condition) when Condition == rising; Condition == falling; Condition == both; Condition == none -> Requestor = self(), call_existing(Pin, {set_int, Condition, Requestor});set_int(_Pin, _Condition) -> {error, wrong_condition}.


I/F X Processhandle_call({set_int, Condition, Requestor}, From, #state{direction=input, interrupt=none, pending=Pending, port=Port}=State) -> port_lib:call_to_port(Port, From, {set_int, Condition}), NewPending = [From | Pending], {noreply, State#state{interrupt={Condition, [Requestor]}, pending=NewPending}};


I/F X Process


I/F X Processhandle_info({Port, {data, Msg}}, #state{port=Port, pin=Pin}=State) -> apply_after(0, ?MODULE, from_port, [Pin, Msg]), {noreply, State}.



from_port(Pin, Msg) -> call_existing(Pin, {from_port, Msg}).



from_port(Pin, Msg) -> call_existing(Pin, {from_port, Msg}).

handle_call({from_port, {port_reply, To, Msg}}, _From, #state{pending=Pending}=State) -> NewPending = lists:delete(To, Pending), gen_server:reply(To, Msg), {reply, ok, State#state{pending=NewPending}}.


User ProcessSpecification

Two LEDscount up & down between 0 and 3

One button to act as +1One button to act as -1


User ProcessInitialisation



init([]) ->



init([]) -> {ok, _} = gpio:start_link(?UP_PIN, input),



init([]) -> {ok, _} = gpio:start_link(?UP_PIN, input), {ok, _} = gpio:start_link(?DOWN_PIN, input),



init([]) -> {ok, _} = gpio:start_link(?UP_PIN, input), {ok, _} = gpio:start_link(?DOWN_PIN, input), ok = gpio:pin_set_int(?UP_PIN, rising),



init([]) -> {ok, _} = gpio:start_link(?UP_PIN, input), {ok, _} = gpio:start_link(?DOWN_PIN, input), ok = gpio:pin_set_int(?UP_PIN, rising), ok = gpio:pin_set_int(?DOWN_PIN, rising),



init([]) -> {ok, _} = gpio:start_link(?UP_PIN, input), {ok, _} = gpio:start_link(?DOWN_PIN, input), ok = gpio:pin_set_int(?UP_PIN, rising), ok = gpio:pin_set_int(?DOWN_PIN, rising), {ok, _} = gpio:start_link(?ONES_PIN, output),



init([]) -> {ok, _} = gpio:start_link(?UP_PIN, input), {ok, _} = gpio:start_link(?DOWN_PIN, input), ok = gpio:pin_set_int(?UP_PIN, rising), ok = gpio:pin_set_int(?DOWN_PIN, rising), {ok, _} = gpio:start_link(?ONES_PIN, output), {ok, _} = gpio:start_link(?TWOS_PIN, output),



init([]) -> {ok, _} = gpio:start_link(?UP_PIN, input), {ok, _} = gpio:start_link(?DOWN_PIN, input), ok = gpio:pin_set_int(?UP_PIN, rising), ok = gpio:pin_set_int(?DOWN_PIN, rising), {ok, _} = gpio:start_link(?ONES_PIN, output), {ok, _} = gpio:start_link(?TWOS_PIN, output), {ok, #state{count=0}}.


User ProcessReacting



handle_info({gpio_interrupt, ?UP_PIN, rising},



handle_info({gpio_interrupt, ?UP_PIN, rising}, #state{count=N}=State) when N < 3 ->



handle_info({gpio_interrupt, ?UP_PIN, rising}, #state{count=N}=State) when N < 3 -> N1 = N + 1,



handle_info({gpio_interrupt, ?UP_PIN, rising}, #state{count=N}=State) when N < 3 -> N1 = N + 1, set_counter_pins(N1),



handle_info({gpio_interrupt, ?UP_PIN, rising}, #state{count=N}=State) when N < 3 -> N1 = N + 1, set_counter_pins(N1), {noreply, State#state{count=N1}};



handle_info({gpio_interrupt, ?UP_PIN, rising}, #state{count=N}=State) when N < 3 -> N1 = N + 1, set_counter_pins(N1), {noreply, State#state{count=N1}};handle_info({gpio_interrupt, ?DOWN_PIN, rising},



handle_info({gpio_interrupt, ?UP_PIN, rising}, #state{count=N}=State) when N < 3 -> N1 = N + 1, set_counter_pins(N1), {noreply, State#state{count=N1}};handle_info({gpio_interrupt, ?DOWN_PIN, rising}, #state{count=N}=State) when N > 0 ->



handle_info({gpio_interrupt, ?UP_PIN, rising}, #state{count=N}=State) when N < 3 -> N1 = N + 1, set_counter_pins(N1), {noreply, State#state{count=N1}};handle_info({gpio_interrupt, ?DOWN_PIN, rising}, #state{count=N}=State) when N > 0 -> N1 = N - 1,



handle_info({gpio_interrupt, ?UP_PIN, rising}, #state{count=N}=State) when N < 3 -> N1 = N + 1, set_counter_pins(N1), {noreply, State#state{count=N1}};handle_info({gpio_interrupt, ?DOWN_PIN, rising}, #state{count=N}=State) when N > 0 -> N1 = N - 1, set_counter_pins(N1),



handle_info({gpio_interrupt, ?UP_PIN, rising}, #state{count=N}=State) when N < 3 -> N1 = N + 1, set_counter_pins(N1), {noreply, State#state{count=N1}};handle_info({gpio_interrupt, ?DOWN_PIN, rising}, #state{count=N}=State) when N > 0 -> N1 = N - 1, set_counter_pins(N1), {noreply, State#state{count=N1}};


User ProcessLight my LEDs baby



set_counter_pins(N1) ->



set_counter_pins(N1) -> <<Twos:1, Ones:1>> = <<N1:2>>,



set_counter_pins(N1) -> <<Twos:1, Ones:1>> = <<N1:2>>, gpio:pin_write(?ONES_PIN, Ones),



set_counter_pins(N1) -> <<Twos:1, Ones:1>> = <<N1:2>>, gpio:pin_write(?ONES_PIN, Ones), gpio:pin_write(?TWOS_PIN, Twos).


Testing w/o Port Drivers

API

Erlang process

Port driver

Async interaction

client


Testing w/o Port Drivers

API

Erlang process

Port driver

Async interaction

client

How do we test this guy?


Simulating port driver



gpio_port(#state{owner=Owner, value=Value, interrupt=Cond}=S) ->



gpio_port(#state{owner=Owner, value=Value, interrupt=Cond}=S) -> receive



gpio_port(#state{owner=Owner, value=Value, interrupt=Cond}=S) -> receive {Owner, {command, Cmd}} ->



gpio_port(#state{owner=Owner, value=Value, interrupt=Cond}=S) -> receive {Owner, {command, Cmd}} -> case Cmd of



gpio_port(#state{owner=Owner, value=Value, interrupt=Cond}=S) -> receive {Owner, {command, Cmd}} -> case Cmd of {call, From, {write, V}} ->



gpio_port(#state{owner=Owner, value=Value, interrupt=Cond}=S) -> receive {Owner, {command, Cmd}} -> case Cmd of {call, From, {write, V}} -> Owner ! port_reply({port_reply, From, ok}),



gpio_port(#state{owner=Owner, value=Value, interrupt=Cond}=S) -> receive {Owner, {command, Cmd}} -> case Cmd of {call, From, {write, V}} -> Owner ! port_reply({port_reply, From, ok}), gpio_port(S#state{value=V});



gpio_port(#state{owner=Owner, value=Value, interrupt=Cond}=S) -> receive {Owner, {command, Cmd}} -> case Cmd of {call, From, {write, V}} -> Owner ! port_reply({port_reply, From, ok}), gpio_port(S#state{value=V}); ...


Hardware Backdoor


Hardware Backdoorgpio_port(#state{owner=Owner, value=Value, interrupt=Cond}=S) ->


Hardware Backdoorgpio_port(#state{owner=Owner, value=Value, interrupt=Cond}=S) -> ...


Hardware Backdoorgpio_port(#state{owner=Owner, value=Value, interrupt=Cond}=S) -> ... %% pure testing


Hardware Backdoorgpio_port(#state{owner=Owner, value=Value, interrupt=Cond}=S) -> ... %% pure testing {set_value, V} ->


Hardware Backdoorgpio_port(#state{owner=Owner, value=Value, interrupt=Cond}=S) -> ... %% pure testing {set_value, V} -> case value_change(Value, V) of


Hardware Backdoorgpio_port(#state{owner=Owner, value=Value, interrupt=Cond}=S) -> ... %% pure testing {set_value, V} -> case value_change(Value, V) of Cond ->


Hardware Backdoorgpio_port(#state{owner=Owner, value=Value, interrupt=Cond}=S) -> ... %% pure testing {set_value, V} -> case value_change(Value, V) of Cond -> Owner ! port_reply({gpio_interrupt, Cond});


Hardware Backdoorgpio_port(#state{owner=Owner, value=Value, interrupt=Cond}=S) -> ... %% pure testing {set_value, V} -> case value_change(Value, V) of Cond -> Owner ! port_reply({gpio_interrupt, Cond}); C when C /= no_change,


Hardware Backdoorgpio_port(#state{owner=Owner, value=Value, interrupt=Cond}=S) -> ... %% pure testing {set_value, V} -> case value_change(Value, V) of Cond -> Owner ! port_reply({gpio_interrupt, Cond}); C when C /= no_change, Cond == both ->


Hardware Backdoorgpio_port(#state{owner=Owner, value=Value, interrupt=Cond}=S) -> ... %% pure testing {set_value, V} -> case value_change(Value, V) of Cond -> Owner ! port_reply({gpio_interrupt, Cond}); C when C /= no_change, Cond == both -> Owner ! port_reply({gpio_interrupt, Cond});


Hardware Backdoorgpio_port(#state{owner=Owner, value=Value, interrupt=Cond}=S) -> ... %% pure testing {set_value, V} -> case value_change(Value, V) of Cond -> Owner ! port_reply({gpio_interrupt, Cond}); C when C /= no_change, Cond == both -> Owner ! port_reply({gpio_interrupt, Cond}); _ ->


Hardware Backdoorgpio_port(#state{owner=Owner, value=Value, interrupt=Cond}=S) -> ... %% pure testing {set_value, V} -> case value_change(Value, V) of Cond -> Owner ! port_reply({gpio_interrupt, Cond}); C when C /= no_change, Cond == both -> Owner ! port_reply({gpio_interrupt, Cond}); _ -> ok


Hardware Backdoorgpio_port(#state{owner=Owner, value=Value, interrupt=Cond}=S) -> ... %% pure testing {set_value, V} -> case value_change(Value, V) of Cond -> Owner ! port_reply({gpio_interrupt, Cond}); C when C /= no_change, Cond == both -> Owner ! port_reply({gpio_interrupt, Cond}); _ -> ok end,


Hardware Backdoorgpio_port(#state{owner=Owner, value=Value, interrupt=Cond}=S) -> ... %% pure testing {set_value, V} -> case value_change(Value, V) of Cond -> Owner ! port_reply({gpio_interrupt, Cond}); C when C /= no_change, Cond == both -> Owner ! port_reply({gpio_interrupt, Cond}); _ -> ok end, gpio_port(S#state{value=V})


Hardware Backdoorgpio_port(#state{owner=Owner, value=Value, interrupt=Cond}=S) -> ... %% pure testing {set_value, V} -> case value_change(Value, V) of Cond -> Owner ! port_reply({gpio_interrupt, Cond}); C when C /= no_change, Cond == both -> Owner ! port_reply({gpio_interrupt, Cond}); _ -> ok end, gpio_port(S#state{value=V}) ...


Mocking

mock_gpio(Config) -> meck:new(port_lib, [passthrough]), meck:expect(port_lib, load_driver, fun(_) -> ok end), Port =spawn( fun gpio_port_sim:gpio_port/0 ), meck:expect(port_lib, open_port, fun(_) -> Owner = self(), Port ! {context, Owner}, Port end), [{port_pid, Port}|Config].


Mocking

mock_gpio(Config) -> meck:new(port_lib, [passthrough]), meck:expect(port_lib, load_driver, fun(_) -> ok end), Port =spawn( fun gpio_port_sim:gpio_port/0 ), meck:expect(port_lib, open_port, fun(_) -> Owner = self(), Port ! {context, Owner}, Port end), [{port_pid, Port}|Config].

Make sure the port knows its context


Interrupt Test Case


Interrupt Test Case

one_interrupt(Config) ->


Interrupt Test Case

one_interrupt(Config) -> Pin = 23,


Interrupt Test Case

one_interrupt(Config) -> Pin = 23, {ok, _} = gpio:init(Pin, input),


Interrupt Test Case

one_interrupt(Config) -> Pin = 23, {ok, _} = gpio:init(Pin, input), Port = ?config(port_pid, Config),


Interrupt Test Case

one_interrupt(Config) -> Pin = 23, {ok, _} = gpio:init(Pin, input), Port = ?config(port_pid, Config), Condition = rising,


Interrupt Test Case

one_interrupt(Config) -> Pin = 23, {ok, _} = gpio:init(Pin, input), Port = ?config(port_pid, Config), Condition = rising, InitialValue = 0,


Interrupt Test Case

one_interrupt(Config) -> Pin = 23, {ok, _} = gpio:init(Pin, input), Port = ?config(port_pid, Config), Condition = rising, InitialValue = 0, Port ! {set_value, InitialValue},


Interrupt Test Case

one_interrupt(Config) -> Pin = 23, {ok, _} = gpio:init(Pin, input), Port = ?config(port_pid, Config), Condition = rising, InitialValue = 0, Port ! {set_value, InitialValue}, ok = gpio:set_int(Pin, Condition),


Interrupt Test Case

one_interrupt(Config) -> Pin = 23, {ok, _} = gpio:init(Pin, input), Port = ?config(port_pid, Config), Condition = rising, InitialValue = 0, Port ! {set_value, InitialValue}, ok = gpio:set_int(Pin, Condition), TriggerValue = 1,


Interrupt Test Case

one_interrupt(Config) -> Pin = 23, {ok, _} = gpio:init(Pin, input), Port = ?config(port_pid, Config), Condition = rising, InitialValue = 0, Port ! {set_value, InitialValue}, ok = gpio:set_int(Pin, Condition), TriggerValue = 1, Port ! {set_value, TriggerValue},


Interrupt Test Case

one_interrupt(Config) -> Pin = 23, {ok, _} = gpio:init(Pin, input), Port = ?config(port_pid, Config), Condition = rising, InitialValue = 0, Port ! {set_value, InitialValue}, ok = gpio:set_int(Pin, Condition), TriggerValue = 1, Port ! {set_value, TriggerValue}, ok = receive_interrupt(Pin, Condition).


Conclusions


ConclusionsPitch Erlang to Visionaries with money ;-)


ConclusionsPitch Erlang to Visionaries with money ;-)Expect resistance from Pragmatists



Erlang/ALE is for embedded what



Erlang/ALE is for embedded what Erlang/OTP is for telecom




Productivity = Money




Productivity = MoneyTime-to-market = Money




Productivity = MoneyTime-to-market = MoneySimplicity = Money




Productivity = MoneyTime-to-market = MoneySimplicity = MoneyRobustness = Money




Productivity = MoneyTime-to-market = MoneySimplicity = MoneyRobustness = Money


Documents

Making money with Erlang · Erlang having your Pi and selling it with a margin Torben Hoffmann Product & Research Manager Erlang Solutions @LeHoff Wednesday, 1 May 2013 W. Erlang