# The Actor Model, Part Two. CSCI 5828: Foundations of Software Engineering Lecture 18 10/23/2014

Save this PDF as:

Size: px
Start display at page:

Download "The Actor Model, Part Two. CSCI 5828: Foundations of Software Engineering Lecture 18 10/23/2014"

## Transcription

1 The Actor Model, Part Two CSCI 5828: Foundations of Software Engineering Lecture 18 10/23/2014 1

2 Goals Cover the material presented in Chapter 5, of our concurrency textbook In particular, the material presented in Days 2 and 3 2

3 Fibonacci Calculator (I) Let s jump back into Elixir and the Actor model This example is taken from the excellent Programming Elixir book from Pragmatic Programmers We ll take a look at using Actors to calculate Fibonacci numbers 0, 1, 1, 2, 3, 5, 8, 13, Our example will calculate a set of Fibonacci numbers using a different number of actors; starting with one actor and proceeding up to ten actors running at once 3

4 Elixir Function Composition In order to understand the source code of the example, we must review Elixir s function composition operator, also known as the pipe operator If you had a series of statement like this a = f(x); b = g(a); c = h(b) You could also write it like this c = h(g(f(x))) In Elixir, you would write it like c = x > f > g > h x is piped into f, the result is piped into g, the result is piped into h The functions on the right hand side can have parameters x > f(y, z) is equivalent to calling f(x, y, z) the thing being piped becomes the first argument of the function on the right hand side 4

5 Fibonacci Calculator (II) To start our Fibonacci example, we first design two actors A solver: is able to calculate the nth Fibonacci number A scheduler: distributes calculation requests to a set of 1 or more solvers A solver will sit in loop and do the following It sends {:ready, pid} to the scheduler It will then receive a :fib message asking it to calculate a number When it is done, it will send an :answer message to the scheduler The solver will perform these actions until it receives a :shutdown message The scheduler will receive an array of integers that represent the Fibonacci numbers to calculate it will send out :fib messages to :ready solvers until all requests are done 5

6 Fibonacci Calculator (III) The solver 1 defmodule FibSolver do 2 3 def fib(scheduler) do 4 send(scheduler, {:ready, self}) 5 receive do 6 {:fib, n, client} -> 7 send(client, {:answer, n, fib_calc(n), self}) 8 fib(scheduler) 9 {:shutdown} -> exit(:normal) 10 end 11 end defp fib_calc(0) do 0 end 14 defp fib_calc(1) do 1 end 15 defp fib_calc(n) do fib_calc(n-1) + fib_calc(n-2) end 16 end 6

7 Fibonacci Calculator (IV): The Scheduler 1 defmodule Scheduler do 2 3 def run(num_processes, module, func, to_calculate) do 4 (1..num_processes) 5 > Enum.map(fn(_) -> spawn(module, func, [self]) end) 6 > schedule_processes(to_calculate, []) 7 end 8 9 defp schedule_processes(processes, queue, results) do 10 receive do 11 {:ready, pid} when length(queue) > 0 -> 12 [ next tail ] = queue 13 send(pid, {:fib, next, self}) 14 schedule_processes(processes, tail, results) {:ready, pid} -> 17 send(pid, {:shutdown}) 18 if length(processes) > 1 do 19 schedule_processes(list.delete(processes, pid), queue, results) 20 else 21 Enum.sort(results, fn ({n1, _}, {n2, _}) -> n1 <= n2 end) 22 end {:answer, number, result, _pid} -> 25 schedule_processes(processes, queue, [ {number, result} results]) 26 end 27 end 28 end 7

8 Fibonacci Calculator (V): Main Program to_process = [ 37, 37, 37, 37, 37, 37 ] Enum.each(1..10, fn (num_processes) -> 50 {time, result} = 51 :timer.tc(scheduler, :run, 52 [num_processes, FibSolver, :fib, to_process]) if num_processes == 1 do 55 IO.puts inspect result 56 IO.puts "\n # time (s)" 57 end 58 :io.format "~2B ~.2f~n", [num_processes, time/ ] 59 end) 8

9 Fibonacci Calculator (VI): Results On my 8-core machine, the results are: # time (s) <== almost 4 times as fast <== roughly 3.3 times as fast on average 9

10 Discussion Striking how simple the implementation of the FibSolver Actor is small piece of code with a defined message API program can then spin up as many of these actors as they want The scheduler is more complex BUT it implemented scheduling in a very generic way the function being calculated was completely abstracted away the logic simply took care of doling out work to all ready actors shutting down actors when there was no more work to be done With 11 active actors (10 solvers + 1 scheduler): Elixir has flexibility as to how those actors are distributed across the cores of the machine 10

11 Error Handling and Resilience Actors provide the ability to write fault-tolerant code We can assign a supervisor to a set of actors that detects when an actor has crashed and can do something about it such as restart the actor They way they do this is by linking the actors together (as we saw in Lecture 16) First: Process.flag(:trap_exit, true) Second: pid = spawn_link( ) Third: receive do {:EXIT, pid, reason} We re going to build up an example that demonstrates these concepts 11

12 An Actor to Test Links: LinkTest 1 defmodule LinkTest do 2 def loop do 3 receive do 4 {:exit_because, reason} -> exit(reason) 5 {:link_to, pid} -> Process.link(pid) 6 {:EXIT, pid, reason} -> IO.puts("#{inspect(pid)} exited because #{reason}") 7 end 8 loop 9 end def loop_system do 12 Process.flag(:trap_exit, true) 13 loop 14 end 15 end An actor that can link to other actors via :link_to; otherwise it can be told to die by sending it a :exit_because message If we want to receive :EXIT messages, we need to invoke this actor with the loop_system call. Otherwise, we can just call loop to see what happens when an actor exits for a non :normal reason 12

13 Example: Linked Actors; Non-Normal Exit Create two instances of the actor pid1 = spawn(&linktest.loop/0) pid2 = spawn(&linktest.loop/0) Link them (links are bidirectional) send(pid1, {:link_to, pid2}) Tell one to quit for a non-normal reason (it doesn t matter which actor) send(pid2, {:exit_because, :bad_thing}) The result? BOTH actors die; no :EXIT message received 13

14 Example: Linked Actors; Normal Exit Create two instances of the actor pid1 = spawn(&linktest.loop/0) pid2 = spawn(&linktest.loop/0) Link them (links are bidirectional) send(pid1, {:link_to, pid2}) Tell one to quit for a normal reason (it doesn t matter which actor) send(pid2, {:exit_because, :normal}) The result? Actor 2 dies; Actor 1 lives; still no :EXIT message received 14

15 Example: Linked System Actors; Non-Normal Exit Create two instances of the actor pid1 = spawn(&linktest.loop_system/0) pid2 = spawn(&linktest.loop/0) Link them (links are bidirectional) send(pid1, {:link_to, pid2}) Tell one to quit for a normal reason (it doesn t matter which actor) send(pid2, {:exit_because, :bad_thing}) The result? Actor 2 dies; Actor 1 lives; :EXIT message received and logged 15

16 Creating a Supervisor We now have enough knowledge to create an actor and its supervisor The textbook implements a simple cache actor and a supervisor that can detect when the cache goes down The cache actor can receive a request to store something in the cache receive a request to retrieve something in the cache receive a request to return the size of the cache (in bytes) The supervisor will create a cache actor and monitor its status If it goes down, it will restart the cache 16

17 Cache We can cause this actor to crash by sending nil for page in a :put message 1 defmodule Cache do 2 def loop(pages, size) do 3 receive do 4 {:put, url, page} -> 5 new_pages = Dict.put(pages, url, page) 6 new_size = size + byte_size(page) 7 loop(new_pages, new_size) 8 {:get, sender, ref, url} -> 9 send(sender, {:ok, ref, pages[url]}) 10 loop(pages, size) 11 {:size, sender, ref} -> 12 send(sender, {:ok, ref, size}) 13 loop(pages, size) 14 {:terminate} -> # Terminate request - don't recurse 15 end 16 end 17 end 17

18 Cache Helper Routines def start_link do 19 pid = spawn_link( MODULE, :loop, [HashDict.new, 0]) 20 Process.register(pid, :cache) 21 pid 22 end def put(url, page) do 25 send(:cache, {:put, url, page}) 26 end def get(url) do 29 ref = make_ref() 30 send(:cache, {:get, self(), ref, url}) 31 receive do 32 {:ok, ^ref, page} -> page 33 end 34 end def size do 37 ref = make_ref() 38 send(:cache, {:size, self(), ref}) 39 receive do 40 {:ok, ^ref, s} -> s 41 end 42 end def terminate do 45 send(:cache, {:terminate}) 46 end These functions provide an API to the Cache. We can call them and not worry about starting actors and sending messages. 18

19 Cache Supervisor DEMO 1 defmodule CacheSupervisor do 2 3 def start do 4 spawn( MODULE, :loop_system, []) 5 end 6 7 def loop do 8 pid = Cache.start_link 9 receive do 10 {:EXIT, ^pid, :normal} -> 11 IO.puts("Cache exited normally") 12 :ok 13 {:EXIT, ^pid, reason} -> 14 IO.puts("Cache failed with reason #{inspect reason} - restarting it") 15 loop 16 end 17 end def loop_system do 20 Process.flag(:trap_exit, true) 21 loop 22 end 23 end Start up a Cache. If it crashes, restart it; otherwise quit Make sure we call :trap_exit to receive :EXIT messages 19

20 Discussion (I) This example illustrates a generic approach to concurrent actor systems Keep the supervisors as small and as simple as possible So simple that they are easy to debug and get correct Have the actors that they supervise crash when things go wrong Let the supervisors detect those crashes and decide what to do This approach maximizes simplicity rather than adding lots of error checking code in the workers implement the success case and let all error cases cause a crash that gets handled by the supervisor => a nice separation of concerns 20

21 Discussion (II) This example is so generic that most of the work that we did manually has been implemented in a library called OTP Let s take a look at an OTP version of the Cache and CacheSupervisor A worker will make use of a library known as GenServer It can handle calls and casts the former return a result; the latter do not A supervisor will make use of a library known as Supervisor A supervisor has an init method that specifies a list of workers and a restart strategy We use the :one_for_one strategy to specify that crashed workers should simply be restarted 21

22 New Supervisor 1 defmodule CacheSupervisor do 2 use Supervisor 3 4 def start_link do 5 :supervisor.start_link( MODULE, []) 6 end 7 8 def init(_args) do 9 workers = [worker(cache, [])] 10 supervise(workers, strategy: :one_for_one) 11 end 12 end 22

23 New Cache 1 defmodule Cache do 2 use GenServer 3 4 def handle_cast({:put, url, page}, {pages, size}) do 5 new_pages = Dict.put(pages, url, page) 6 new_size = size + byte_size(page) 7 {:noreply, {new_pages, new_size}} 8 end 9 10 def handle_call({:get, url}, _from, {pages, size}) do 11 {:reply, pages[url], {pages, size}} 12 end def handle_call({:size}, _from, {pages, size}) do 15 {:reply, size, {pages, size}} 16 end end 23

24 Helper Functions for Cache def start_link do 19 :gen_server.start_link({:local, :cache}, MODULE, {HashDict.new, 0}, []) 20 end def put(url, page) do 23 :gen_server.cast(:cache, {:put, url, page}) 24 end def get(url) do 27 :gen_server.call(:cache, {:get, url}) 28 end def size do 31 :gen_server.call(:cache, {:size}) 32 end 33 24

25 Using the new version Start by creating the supervisor (which creates the Cache, its worker) CacheSupervisor.start_link Then just use the Cache Cache.size => 0 Cache.put foo, bar => :ok Cache.size => 3 Cache.put ohnoes, nil => error message; auto restart Cache.size => 0 Just like that, we ve reimplemented the previous example 25

26 Nodes and Distribution The Erlang virtual machine is used to execute Elixir programs In an analogous way that Coljure programs compile down to Java bytecodes and are executed by the Java Virtual Machine One cool feature of Erlang virtual machines is that they have the capability to act as nodes that can form clusters Elixir actors running on one node can easily route messages to actors running on other (possibly) distributed nodes To set this up in Elixir, you can launch iex and give it a node name For security reasons, you also give it a cookie ; only nodes with the same cookie can talk to one another iex --name --cookie jiriki < can be any string 26

27 Connecting Nodes Once you have launched a node, you need to tell it about the other nodes iex --name --cookie jiriki iex --name --cookie jiriki Checking status node1> Node.self => node2> Node.self => Connecting node1> => true Both nodes are now connected to each other node1> Node.list => node2> Node.list => 27

28 Sending Code Between Nodes Let s define a function node1> whoami = fn () -> IO.puts(Node.self) end And send it to another node to be executed node1> whoami) node1 REPL prints: Pause to think about what we just did and how easy it was We just defined a function sent it over to another machine as data that machine converted the data back to a function executed it sent back the result and our original machine then displayed the result 28

29 Sending Messages Between Nodes: Set-Up Let s launch our Counter actor on node2 node2> pid = spawn(counter, :loop, [42]) Now, let s register that process id and associate it with a global name node2> :global.register_name(:counter, pid) => :yes In this context, global means across all connected nodes So, now on node1, we can look that name up node1> pid = :global.whereis_name(:counter) => #PID< > Then we can send messages to it (next slide) 29

30 Sending Messages Between Nodes This version of counter expects a message of the form {:next, <caller_pid>, <unique_ref>} It then sends back a message of the form {:ok, <unique_ref>, count} So, to call this Actor from node1, we do node1> ref = make_ref node1> send(pid, {:next, self, ref}) node1> receive do {:ok, ^ref, count} -> count end Sure enough, we get back the result 42 30

31 Just scratched the surface With these building blocks, you can move on to create full-fledged distributed, concurrent programs Start a bunch of actors on one or more worker machines and register their pids via the :global registry Start a supervisor on another machine and have it dole out work to the actors using a message pattern similar to the Fibonacci example If any of the workers die, have the supervisor restart them automatically I highly recommend the Programming Elixir book if you re curious to see more complicated examples It shows an example that starts a server, has it handle requests, then modifies the code of the server, and HOT SWAPS that code into the running server => modifying servers without having to restart them! 31

32 Summary The Actor model is a powerful model for creating distributed, concurrent systems Any individual actor is a single-threaded program with state that changes in well defined ways Software design becomes message design and system design becomes balancing where actors live and how message load is distributed across them The one danger in Actor systems is deadlock; receive is a blocking call to avoid that, you can have receive timeout and have the Actor do something to recover The OTP library can be used to create Client-Server and Cluster-based applications with a minimal amount of code 32

33 Coming Up Next Lecture 19: Introduction to Software Design Lecture 20: The Design of Design, Part One 33

### The Actor Model. CSCI 5828: Foundations of Software Engineering Lecture 13 10/04/2016

The Actor Model CSCI 5828: Foundations of Software Engineering Lecture 13 10/04/2016 1 Goals Introduce the Actor Model of Concurrency isolation, message passing, message patterns Present examples from

### An Introduction to Erlang

An Introduction to Erlang Part 2 - Concurrency Richard Carlsson Processes P1 fib(0) -> 1; fib(1) -> 1; fib(n) when N > 0 -> fib(n-1) + fib(n-2). Whenever an Erlang program is running, the code is executed

### Erlang: An Overview. Part 2 Concurrency and Distribution. Thanks to Richard Carlsson for most of the slides in this part

Erlang: An Overview Part 2 Concurrency and Distribution Thanks to Richard Carlsson for most of the slides in this part Processes P1 fib(0) -> 1; fib(1) -> 1; fib(n) when N > 0 -> fib(n-1) + fib(n-2). Whenever

### Favoring Isolated Mutability The Actor Model of Concurrency. CSCI 5828: Foundations of Software Engineering Lecture 24 04/11/2012

Favoring Isolated Mutability The Actor Model of Concurrency CSCI 5828: Foundations of Software Engineering Lecture 24 04/11/2012 1 Goals Review the material in Chapter 8 of the Concurrency textbook that

### Learning from Bad Examples. CSCI 5828: Foundations of Software Engineering Lecture 25 11/18/2014

Learning from Bad Examples CSCI 5828: Foundations of Software Engineering Lecture 25 11/18/2014 1 Goals Demonstrate techniques to design for shared mutability Build on an example where multiple threads

### Phoenix Is Not Your Application. Lance Halvorsen ElixirConf EU 2016

Phoenix Is Not Your Application Lance Halvorsen ElixirConf EU 2016 Phoenix is one of your applications. Our Language Gives Us Away We Say I'm building a Phoenix app. Or a Rails app. Or an Ember app. Or

### Akka: Simpler Concurrency, Scalability & Fault-tolerance through Actors. Jonas Bonér Viktor Klang

Akka: Simpler Concurrency, Scalability & Fault-tolerance through Actors Jonas Bonér Viktor Klang We believe that... Writing correct concurrent applications is too hard Scaling out applications is too hard

### Clojure Concurrency Constructs. CSCI 5828: Foundations of Software Engineering Lecture 12 10/02/2014

Clojure Concurrency Constructs CSCI 5828: Foundations of Software Engineering Lecture 12 10/02/2014 1 Goals Cover the material presented in Chapters 3 & 4 of our concurrency textbook! Books examples from

### The Little Elixir & OTP Guidebook by Tan Wei Hao

SAMPLE CHAPTER The Little Elixir & OTP Guidebook by Tan Wei Hao Chapter 9 Copyright 2016 Manning Publications brief contents PART 1 GETTING STARTED WITH ELIXIR AND OTP...1 1 Introduction 3 2 A whirlwind

### Introduction to Concurrent Software Systems. CSCI 5828: Foundations of Software Engineering Lecture 12 09/29/2016

Introduction to Concurrent Software Systems CSCI 5828: Foundations of Software Engineering Lecture 12 09/29/2016 1 Goals Present an overview of concurrency in software systems Review the benefits and challenges

### Erlang. Functional Concurrent Distributed Soft real-time OTP (fault-tolerance, hot code update ) Open. Check the source code of generic behaviours

Lecture 9 Erlang Erlang Functional Concurrent Distributed Soft real-time OTP (fault-tolerance, hot code update ) Open Check the source code of generic behaviours 2 Functional Haskell call-by-need (lazy)

### MASSACHVSETTS INSTITVTE OF TECHNOLOGY Department of Electrical Engineering and Computer Science. Issued: Wed. 26 April 2017 Due: Wed.

ps.txt Fri Apr 07 14:24:11 2017 1 MASSACHVSETTS INSTITVTE OF TECHNOLOGY Department of Electrical Engineering and Computer Science 6.945 Spring 2017 Problem Set 9 Issued: Wed. 26 April 2017 Due: Wed. 12

### CS61A Summer 2010 George Wang, Jonathan Kotker, Seshadri Mahalingam, Eric Tzeng, Steven Tang

CS61A Notes Week 6B: Streams Streaming Along A stream is an element and a promise to evaluate the rest of the stream. You ve already seen multiple examples of this and its syntax in lecture and in the

### Introduction to Erlang. Franck Petit / Sebastien Tixeuil

Introduction to Erlang Franck Petit / Sebastien Tixeuil Firstname.Lastname@lip6.fr Hello World % starts a comment. ends a declaration Every function must be in a module one module per source file source

### SCHEME AND CALCULATOR 5b

SCHEME AND CALCULATOR 5b COMPUTER SCIENCE 6A July 25, 203 In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme programs,

### Erlang. Functional Concurrent Distributed Soft real-time OTP (fault-tolerance, hot code update ) Open. Check the source code of generic behaviours

Lecture 10 Erlang Erlang Functional Concurrent Distributed Soft real-time OTP (fault-tolerance, hot code update ) Open Check the source code of generic behaviours 2 Functional Haskell call-by-need (lazy)

### Macros, and protocols, and metaprogramming - Oh My!

Macros, and protocols, and metaprogramming - Oh My! (aka "What is Elixir and why should you care?") jim mccoy, Facebook Infosec Tools mccoy@fb.com (jim.mccoy@gmail.com) Who? Currently build and maintain

### CPS506 - Comparative Programming Languages Elixir

CPS506 - Comparative Programming Languages Elixir Dr. Dave Mason Department of Computer Science Ryerson University c 2017 Dave Mason History Joe Armstrong worked at Ericson Erlang originally for lab development

### FRANCESCO CESARINI. presents ERLANG/OTP. Francesco Cesarini Erlang

FRANCESCO CESARINI presents Francesco Cesarini Erlang Solutions ERLANG/OTP @FrancescoC francesco@erlang-solutions.com www.erlang-solutions.com WHAT IS SCALABILITY? WHAT IS (MASSIVE) CONCURRENCY? WHAT

### Organized by Jean-François Cloutier Held at Big Room Studios, Portland, ME. Holy Elixir, Batman! Meetup June 16, 2015

Organized by Jean-François Cloutier Held at Big Room Studios, Portland, ME Holy Elixir, Batman! Meetup June 16, 2015 A Sampling of Elixir's Superhero Powers Second Order Functions Pipes Pattern Matching

### Introduction to Concurrent Software Systems. CSCI 5828: Foundations of Software Engineering Lecture 08 09/17/2015

Introduction to Concurrent Software Systems CSCI 5828: Foundations of Software Engineering Lecture 08 09/17/2015 1 Goals Present an overview of concurrency in software systems Review the benefits and challenges

### Erlang: distributed programming

Erlang: distributed May 11, 2012 1 / 21 Fault tolerance in Erlang links, exit signals, system process in Erlang OTP Open Telecom Platform 2 / 21 General idea Links Exit signals System processes Summary

### Message-passing concurrency in Erlang

Message-passing concurrency in Erlang Lecture 8 of TDA383/DIT390 (Concurrent Programming) Carlo A. Furia Chalmers University of Technology University of Gothenburg SP3 2016/2017 Today s menu Actors and

### Design Approaches for Concurrent Systems. CSCI 5828: Foundations of Software Engineering Lecture 08 02/09/2012

Design Approaches for Concurrent Systems CSCI 5828: Foundations of Software Engineering Lecture 08 02/09/2012 1 Goals Discuss material in Chapter 3 of our concurrency textbook Design Approaches for Concurrent

### Discussion 11. Streams

Discussion 11 Streams A stream is an element and a promise to evaluate the rest of the stream. You ve already seen multiple examples of this and its syntax in lecture and in the books, so I will not dwell

### CS390 Principles of Concurrency and Parallelism. Lecture Notes for Lecture #5 2/2/2012. Author: Jared Hall

CS390 Principles of Concurrency and Parallelism Lecture Notes for Lecture #5 2/2/2012 Author: Jared Hall This lecture was the introduction the the programming language: Erlang. It is important to understand

### Threads and Locks, Part 2. CSCI 5828: Foundations of Software Engineering Lecture 08 09/18/2014

Threads and Locks, Part 2 CSCI 5828: Foundations of Software Engineering Lecture 08 09/18/2014 1 Goals Cover the material presented in Chapter 2 of our concurrency textbook In particular, selected material

### Erlang and Go (CS262a, Berkeley Fall 2016) Philipp Moritz

Erlang and Go (CS262a, Berkeley Fall 2016) Philipp Moritz The Problem Distributed computation is hard! State Hard to do recovery, dependency on order of execution Concurrency and Synchronization Hard to

### Reminder from last time

Concurrent systems Lecture 5: Concurrency without shared data, composite operations and transactions, and serialisability DrRobert N. M. Watson 1 Reminder from last time Liveness properties Deadlock (requirements;

### Summer 2017 Discussion 10: July 25, Introduction. 2 Primitives and Define

CS 6A Scheme Summer 207 Discussion 0: July 25, 207 Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme programs,

### All you need is fun. Cons T Åhs Keeper of The Code

All you need is fun Cons T Åhs Keeper of The Code cons@klarna.com Cons T Åhs Keeper of The Code at klarna Architecture - The Big Picture Development - getting ideas to work Code Quality - care about the

Erlang 101 Google Doc Erlang? with buzzwords Erlang is a functional concurrency-oriented language with extremely low-weight userspace "processes", share-nothing messagepassing semantics, built-in distribution,

### INTERPRETERS 8. 1 Calculator COMPUTER SCIENCE 61A. November 3, 2016

INTERPRETERS 8 COMPUTER SCIENCE 61A November 3, 2016 1 Calculator We are beginning to dive into the realm of interpreting computer programs that is, writing programs that understand other programs. In

### Robust Erlang (PFP Lecture 11) John Hughes

Robust Erlang (PFP Lecture 11) John Hughes Genesis of Erlang Problem: telephony systems in the late 1980s Digital More and more complex Highly concurrent Hard to get right Approach: a group at Ericsson

Programming, Data Structures and Algorithms in Python Prof. Madhavan Mukund Department of Computer Science and Engineering Indian Institute of Technology, Madras Week - 01 Lecture - 04 Downloading and

### Erlang. Joe Armstrong.

Erlang Joe Armstrong joe.armstrong@ericsson.com 1 Who is Joe? Inventor of Erlang, UBF, Open Floppy Grid Chief designer of OTP Founder of the company Bluetail Currently Software Architect Ericsson Current

### Grand Central Dispatch and NSOperation. CSCI 5828: Foundations of Software Engineering Lecture 28 12/03/2015

Grand Central Dispatch and NSOperation CSCI 5828: Foundations of Software Engineering Lecture 28 12/03/2015 1 Credit Where Credit Is Due Most of the examples in this lecture were inspired by example code

### Starting the System & Basic Erlang Exercises

Starting the System & Basic Erlang Exercises These exercises will help you get accustomed with the Erlang development and run time environments. Once you have set up the Erlang mode for emacs, you will

### A Small Web Server. Programming II - Elixir Version. Johan Montelius. Spring Term 2018

A Small Web Server Programming II - Elixir Version Johan Montelius Spring Term 2018 Introduction Your task is to implement a small web server in Elixir. exercise is that you should be able to: The aim

### /633 Introduction to Algorithms Lecturer: Michael Dinitz Topic: Priority Queues / Heaps Date: 9/27/18

01.433/33 Introduction to Algorithms Lecturer: Michael Dinitz Topic: Priority Queues / Heaps Date: 9/2/1.1 Introduction In this lecture we ll talk about a useful abstraction, priority queues, which are

### ECE 550D Fundamentals of Computer Systems and Engineering. Fall 2017

ECE 550D Fundamentals of Computer Systems and Engineering Fall 2017 The Operating System (OS) Prof. John Board Duke University Slides are derived from work by Profs. Tyler Bletsch and Andrew Hilton (Duke)

### Database management system Prof. D. Janakiram Department of Computer Science and Engineering Indian Institute of Technology, Madras

Database management system Prof. D. Janakiram Department of Computer Science and Engineering Indian Institute of Technology, Madras Lecture 25 Basic 2-phase & 3-phase Commit protocol In the last lecture,

### /633 Introduction to Algorithms Lecturer: Michael Dinitz Topic: Priority Queues / Heaps Date: 9/27/17

01.433/33 Introduction to Algorithms Lecturer: Michael Dinitz Topic: Priority Queues / Heaps Date: 9/2/1.1 Introduction In this lecture we ll talk about a useful abstraction, priority queues, which are

### WE ARE ALL BLESSED. Bruce Tate

WE ARE ALL BLESSED Bruce Tate Dave Thomas @redrapids @pragdave 1 DAVE'S STORY 2 3 4 https://upload.wikimedia.org/wikipedia/commons/0/0b/hand-operated_card_punch-2.jpg 5 https://upload.wikimedia.org/wikipedia/commons/e/e8/ibm_card_punch_029.jpg

### Microservices, Messaging and Science Gateways. Review microservices for science gateways and then discuss messaging systems.

Microservices, Messaging and Science Gateways Review microservices for science gateways and then discuss messaging systems. Micro- Services Distributed Systems DevOps The Gateway Octopus Diagram Browser

### Elixir and Phoenix fast, concurrent and explicit Tobias pragtob.info

Elixir and Phoenix fast, concurrent and explicit Tobias Pfeiffer @PragTob pragtob.info Elixir and Phoenix fast, concurrent and explicit Tobias Pfeiffer @PragTob pragtob.info Platform defmodule MyMap do

### CS558 Programming Languages

CS558 Programming Languages Winter 2018 Lecture 7b Andrew Tolmach Portland State University 1994-2018 Dynamic Type Checking Static type checking offers the great advantage of catching errors early And

### CS1 Lecture 5 Jan. 26, 2018

CS1 Lecture 5 Jan. 26, 2018 HW1 due Monday, 9:00am. Notes: Do not write all the code at once (for Q1 and 2) before starting to test. Take tiny steps. Write a few lines test... add a line or two test...

### Interpreters and Tail Calls Fall 2017 Discussion 8: November 1, 2017 Solutions. 1 Calculator. calc> (+ 2 2) 4

CS 61A Interpreters and Tail Calls Fall 2017 Discussion 8: November 1, 2017 Solutions 1 Calculator We are beginning to dive into the realm of interpreting computer programs that is, writing programs that

### 6.001 Notes: Section 4.1

6.001 Notes: Section 4.1 Slide 4.1.1 In this lecture, we are going to take a careful look at the kinds of procedures we can build. We will first go back to look very carefully at the substitution model,

### Introduction to Scientific Computing

Introduction to Scientific Computing Dr Hanno Rein Last updated: October 12, 2018 1 Computers A computer is a machine which can perform a set of calculations. The purpose of this course is to give you

### CS 167 Final Exam Solutions

CS 167 Final Exam Solutions Spring 2018 Do all questions. 1. [20%] This question concerns a system employing a single (single-core) processor running a Unix-like operating system, in which interrupts are

### Lecture #5: Higher-Order Functions. A Simple Recursion. Avoiding Recalculation. Redundant Calculation. Tail Recursion and Repetition

nnouncements: Lecture #5: Higher-Order Functions Make sure that you have registered electronically with our system (not just TeleBERS). ttend a discussion/lab in which you can fit; don t worry about Tele-

### concurrent programming XXL

concurrent programming XXL Industrial Use of Erlang Introduction Karol Ostrovský (karol.ostrovsky@gmail.com) Motivation Machine Ericsson Blade System 3 sub-racks 14 blades 2 routers 12 compute nodes 6

### CS61A Notes Disc 11: Streams Streaming Along

CS61A Notes Disc 11: Streams Streaming Along syntax in lecture and in the book, so I will not dwell on that. Suffice it to say, streams is one of the most mysterious topics in CS61A, trust than whatever

### CS1 Lecture 3 Jan. 22, 2018

CS1 Lecture 3 Jan. 22, 2018 Office hours for me and for TAs have been posted, locations will change check class website regularly First homework available, due Mon., 9:00am. Discussion sections tomorrow

CS 1 Introduction to Computer Programming Lecture 24: December 5, 2012 Advanced topics, part 2 Last time Advanced topics, lecture 1 recursion first-class functions lambda expressions higher-order functions

### Basic Reliable Transport Protocols

Basic Reliable Transport Protocols Do not be alarmed by the length of this guide. There are a lot of pictures. You ve seen in lecture that most of the networks we re dealing with are best-effort : they

### SCHEME The Scheme Interpreter. 2 Primitives COMPUTER SCIENCE 61A. October 29th, 2012

SCHEME COMPUTER SCIENCE 6A October 29th, 202 In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme programs, we will eventually

### Math 4242 Fibonacci, Memoization lecture 13

Math 4242 Fibonacci, Memoization lecture 13 Today we talk about a problem that sometimes occurs when using recursion, and a common way to fix it. Recall the Fibonacci sequence (F 1, F 2,...) that occurs

### # track total function calls using a global variable global fibcallcounter fibcallcounter +=1

Math 4242 Fibonacci, Memoization lecture 13 Today we talk about a problem that sometimes occurs when using recursion, and a common way to fix it. Recall the Fibonacci sequence (F 0, F 1, F 2,...) that

### CSCI 2321 (Computer Design), Spring 2018 Homework 3

CSCI 2321 (Computer Design), Spring 2018 Homework 3 Credit: 50 points. 1 Reading Be sure you have read, or at least skimmed, all assigned sections of Chapter 2 and Appendix A. 2 Honor Code Statement Please

### SCHEME 7. 1 Introduction. 2 Primitives COMPUTER SCIENCE 61A. October 29, 2015

SCHEME 7 COMPUTER SCIENCE 61A October 29, 2015 1 Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme programs,

### Akka: Simpler Concurrency, Scalability & Fault-tolerance through Actors. Jonas Bonér Scalable Solutions

Akka: Simpler Concurrency, Scalability & Fault-tolerance through Actors Jonas Bonér Scalable Solutions jonas@jonasboner.com twitter: @jboner The problem It is way too hard to build: 1. correct highly concurrent

### Elixir and Phoenix fast, concurrent and explicit Tobias pragtob.info

Elixir and Phoenix fast, concurrent and explicit Tobias Pfeiffer @PragTob pragtob.info Elixir and Phoenix fast, concurrent and explicit Tobias Pfeiffer @PragTob pragtob.info Platform defmodule MyMap do

### Threads and Locks. CSCI 5828: Foundations of Software Engineering Lecture 09 09/22/2015

Threads and Locks CSCI 5828: Foundations of Software Engineering Lecture 09 09/22/2015 1 Goals Cover the material presented in Chapter 2, Day 1 of our concurrency textbook Creating threads Locks Memory

### Introduction to Asynchronous Programming Fall 2014

CS168 Computer Networks Fonseca Introduction to Asynchronous Programming Fall 2014 Contents 1 Introduction 1 2 The Models 1 3 The Motivation 3 4 Event-Driven Programming 4 5 select() to the rescue 5 1

### Beautiful Concurrency with Erlang

Beautiful Concurrency with Erlang Kevin Scaldeferri OSCON 23 July 2008 6 years at Yahoo, building large high-concurrency distributed systems Not an expert, don t use it professionally Dabbled, liked it,

### The name of our class will be Yo. Type that in where it says Class Name. Don t hit the OK button yet.

Mr G s Java Jive #2: Yo! Our First Program With this handout you ll write your first program, which we ll call Yo. Programs, Classes, and Objects, Oh My! People regularly refer to Java as a language that

Thread Safety Today o Confinement o Threadsafe datatypes Required reading Concurrency Wrapper Collections Optional reading The material in this lecture and the next lecture is inspired by an excellent

### CSC 2405: Computer Systems II

CSC 2405: Computer Systems II Dr. Mirela Damian http://www.csc.villanova.edu/~mdamian/csc2405/ Spring 2016 Course Goals: Look under the hood Help you learn what happens under the hood of computer systems

### Distributed Erlang and Map-Reduce

Distributed Erlang and Map-Reduce The goal of this lab is to make the naïve map-reduce implementation presented in the lecture, a little less naïve. Specifically, we will make it run on multiple Erlang

### SCHEME 10 COMPUTER SCIENCE 61A. July 26, Warm Up: Conditional Expressions. 1. What does Scheme print? scm> (if (or #t (/ 1 0)) 1 (/ 1 0))

SCHEME 0 COMPUTER SCIENCE 6A July 26, 206 0. Warm Up: Conditional Expressions. What does Scheme print? scm> (if (or #t (/ 0 (/ 0 scm> (if (> 4 3 (+ 2 3 4 (+ 3 4 (* 3 2 scm> ((if (< 4 3 + - 4 00 scm> (if

### Erlang. Joe Armstrong

Erlang Joe Armstrong Though OOP came from many motivations, two were central. The large scale one was to find a better module scheme for complex systems involving hiding of details, and the small scale

Concurrent Systems 8L for Part IB Handout 3 Dr. Steven Hand Example: Active Objects A monitor with an associated server thread Exports an entry for each operation it provides Other (client) threads call

### (Refer Slide Time: 02.06)

Data Structures and Algorithms Dr. Naveen Garg Department of Computer Science and Engineering Indian Institute of Technology, Delhi Lecture 27 Depth First Search (DFS) Today we are going to be talking

### CS125 : Introduction to Computer Science. Lecture Notes #11 Procedural Composition and Abstraction. c 2005, 2004 Jason Zych

CS125 : Introduction to Computer Science Lecture Notes #11 Procedural Composition and Abstraction c 2005, 2004 Jason Zych 1 Lecture 11 : Procedural Composition and Abstraction Solving a problem...with

### STATS Data Analysis using Python. Lecture 8: Hadoop and the mrjob package Some slides adapted from C. Budak

STATS 700-002 Data Analysis using Python Lecture 8: Hadoop and the mrjob package Some slides adapted from C. Budak Recap Previous lecture: Hadoop/MapReduce framework in general Today s lecture: actually

### Distributed Systems. Lec 10: Distributed File Systems GFS. Slide acks: Sanjay Ghemawat, Howard Gobioff, and Shun-Tak Leung

Distributed Systems Lec 10: Distributed File Systems GFS Slide acks: Sanjay Ghemawat, Howard Gobioff, and Shun-Tak Leung 1 Distributed File Systems NFS AFS GFS Some themes in these classes: Workload-oriented

### The NetBeans IDE is a big file --- a minimum of around 30 MB. After you have downloaded the file, simply execute the file to install the software.

Introduction to Netbeans This document is a brief introduction to writing and compiling a program using the NetBeans Integrated Development Environment (IDE). An IDE is a program that automates and makes

### Concurrent & Distributed Systems Supervision Exercises

Concurrent & Distributed Systems Supervision Exercises Stephen Kell Stephen.Kell@cl.cam.ac.uk November 9, 2009 These exercises are intended to cover all the main points of understanding in the lecture

### Week 2: The Clojure Language. Background Basic structure A few of the most useful facilities. A modernized Lisp. An insider's opinion

Week 2: The Clojure Language Background Basic structure A few of the most useful facilities A modernized Lisp Review of Lisp's origins and development Why did Lisp need to be modernized? Relationship to

### RACKET BASICS, ORDER OF EVALUATION, RECURSION 1

RACKET BASICS, ORDER OF EVALUATION, RECURSION 1 COMPUTER SCIENCE 61AS 1. What is functional programming? Give an example of a function below: Functional Programming In functional programming, you do not

### CS1 Lecture 3 Jan. 18, 2019

CS1 Lecture 3 Jan. 18, 2019 Office hours for Prof. Cremer and for TAs have been posted. Locations will change check class website regularly First homework assignment will be available Monday evening, due

### Processes. Johan Montelius KTH

Processes Johan Montelius KTH 2017 1 / 47 A process What is a process?... a computation a program i.e. a sequence of operations a set of data structures a set of registers means to interact with other

### Programming Paradigms Written Exam (6 CPs)

Programming Paradigms Written Exam (6 CPs) 31.01.2018 First name Student number Last name Signature Instructions for Students Write your name and student number on the exam sheet and on every solution

### COSC441. Lecture 8 Introduction to Erlang

COSC441 Lecture 8 Introduction to Erlang Approach The reference book is Learn You Some Erlang for Great Good! by Fred Hébert. http://learnyousomeerlang.com lets you read it free on-line. What I am going

### Advanced Functional Programming, 1DL Lecture 2, Cons T Åhs

Advanced Functional Programming, 1DL450 2012 Lecture 2, 2012-11-01 Cons T Åhs Higher order functions hof() -> F = fun(x) -> X * X + 1 end, L = lists:map(f, [1, 2, 3], G = fun([]) -> nil; ([_ _]) -> cons

### A process. the stack

A process Processes Johan Montelius What is a process?... a computation KTH 2017 a program i.e. a sequence of operations a set of data structures a set of registers means to interact with other processes

### simplevisor Documentation

simplevisor Documentation Release 1.2 Massimo Paladin June 27, 2016 Contents 1 Main Features 1 2 Installation 3 3 Configuration 5 4 simplevisor command 9 5 simplevisor-control command 13 6 Supervisor

### The Actor Model applied to the Raspberry Pi and the Embedded Domain. Omer

The Actor Model applied to the Raspberry Pi and the Embedded Domain Omer Kilic @OmerK omer@erlang-solutions.com Agenda Current state of Embedded Systems Overview of the Actor Model Erlang Embedded Project

### Code Generation. Lecture 12

Code Generation Lecture 12 1 Lecture Outline Topic 1: Basic Code Generation The MIPS assembly language A simple source language Stack-machine implementation of the simple language Topic 2: Code Generation

### Distributed Computation Models

Distributed Computation Models SWE 622, Spring 2017 Distributed Software Engineering Some slides ack: Jeff Dean HW4 Recap https://b.socrative.com/ Class: SWE622 2 Review Replicating state machines Case

### Computer Science 322 Operating Systems Mount Holyoke College Spring Topic Notes: Processes and Threads

Computer Science 322 Operating Systems Mount Holyoke College Spring 2010 Topic Notes: Processes and Threads What is a process? Our text defines it as a program in execution (a good definition). Definitions

### G Programming Languages Spring 2010 Lecture 13. Robert Grimm, New York University

G22.2110-001 Programming Languages Spring 2010 Lecture 13 Robert Grimm, New York University 1 Review Last week Exceptions 2 Outline Concurrency Discussion of Final Sources for today s lecture: PLP, 12