Actor Thinking Dale Schumacher twitter: @dalnefre QCon/SF 2010-11 - - PowerPoint PPT Presentation

Dale Schumacher

twitter: @dalnefre

QCon/SF 2010-11

Actor Thinking

Conway's Law

“... organizations which design systems … are constrained to produce designs which are copies of the communication structures of these organizations.” –M. Conway (1968)

Models of Computation

Objects Objects

Actors Actors

Procedures Procedures

Functions Functions Dataflow Dataflow

Logic Logic

Sequential Stack Machine

JZ +6 IP ROLL -3 ADD SWAP DEC JMP -5 6 SP 1 2 3 5 8 POP 13

Linked Stack Machine

ZERO? IP ROLL -3 ADD SWAP DEC 5 SP 1 2 3 5 8 POP

“Hewitt had noted that the actor model could capture the salient aspects of the lambda calculus; Scheme demonstrated that the lambda calculus captured nearly all salient aspects (excepting only side effects and synchronization) of the actor model.” –G. Steele and R. Gabriel (1993)

Actors and Functions

Objects (Kay) & Actors (Hewitt)

• Everything is an object
• Objects communicate

by sending and receiving messages

• Objects have their own

memory

• Inheritance?

Polymorphism?

• Configuration =

actors + messages

• Actors respond to

messages by:

 Sending messages  Creating actors  Changing behavior

• Everything is concurrent

It's all about the messages

Objects Objects

Actors Actors

Messages

http://www.flickr.com/photos/sunface13/4815937062/

build(4)

ring

ring_link build(0) build(1) build(2) build(3)

L E T ring_builder( n) = λ( first, m) . [ C A S E n O F : [ B E C O M E λm. [ # ring_last( first) C A S E m O F : [ B E C O M E λ_ . [ ] ] _ : [ S E N D dec( m) T O first ] E N D ] S E N D m T O first ] _ : [ C R E A T E next WI T H ring_builder( dec( n) ) S E N D ( first, m) T O next B E C O M E λm. [ # ring_link( next) S E N D m T O next ] ] E N D ] C R E A T E ring WI T H ring_builder( 4 ) S E N D ( ring, 3 ) T O ring

ring_link ring_last ring_link ring_link

next next next next first

(ring, 3) (ring, 3) (ring, 3) (ring, 3) (ring, 3)

3 3 3 3

L E T ring_builder( n) = λ( first, m) . [ C A S E n O F : [ B E C O M E λm. [ # ring_last( first) C A S E m O F : [ B E C O M E λ_ . [ ] ] _ : [ S E N D dec( m) T O first ] E N D ] S E N D m T O first ] _ : [ C R E A T E next WI T H ring_builder( dec( n) ) S E N D ( first, m) T O next B E C O M E λm. [ # ring_link( next) S E N D m T O next ] ] E N D ] C R E A T E ring WI T H ring_builder( 4 ) S E N D ( ring, 3 ) T O ring

ring_link ring_link ring_last ring_link ring_link

ring next next next next first

2 2 2 2 2 1 1 1 1 1 3 λ_ . [ ]

# s e r v i c e p r

• t
• c
• l

: ( cust, { # c r e a t e , # r e a d , # u p d a t e , # d e l e t e } , key[ , value] ) L E T read_only_proxy_beh( service) = λ( cust, req) . [ C A S E req O F ( # r e a d , key) : [ S E N D ( cust, req) T O service ] _ : [ S E N D ? T O cust ] E N D ] L E T revocable_delete_proxy_beh( service,

• wner)

= λ( cust, req) . [ C A S E req O F ( # d e l e t e , key) : [ S E N D ( cust, req) T O service ] ( # r e v

• k

e , $

• wner)

: [ S E N D # r e v

• k

e d T O cust ] _ : [ S E N D ? T O cust ] E N D B E C O M E λ( cust, _) . [ S E N D ? T O cust ] ]

Object-Capability Security

proxy service proxy service

• wner

Lifetimes vary dramatically

C R E A T E empty_grammar WI T H λ( cust, # m a t c h , src) . [ S E N D ( T R U E , N I L , src) T O cust ] L E T symbol_grammar_beh( symbol) = λ( cust, # m a t c h , src) . [ S E N D ( k_symbol, # r e a d ) T O src C R E A T E k_symbol WI T H λ( token, next) . [ C A S E token O F $ symbol : [ S E N D ( T R U E , token, next) T O cust ] _ : [ S E N D ( F A L S E , src) T O cust ] E N D ] ] L E T alt_grammar_beh( first, rest) = λ( cust, # m a t c h , src) . [ S E N D ( k_alt, # m a t c h , src) T O first C R E A T E k_alt WI T H λmatch. [ C A S E match O F ( T R U E , _ ) : [ S E N D match T O cust ] _ : [ S E N D ( cust, # m a t c h , src) T O rest ] E N D ] ]

symbol k_symbol k_alt ... alt ...

first rest

empty

L E T seq_grammar_beh( first, rest) = λ( cust, # m a t c h , src) . [ S E N D ( k_seq, # m a t c h , src) T O first C R E A T E k_seq WI T H λmatch. [ C A S E match O F ( T R U E , token, next) : [ S E N D ( S E L F , # m a t c h , next) T O rest B E C O M E λmatch'. [ C A S E match' O F ( T R U E , token', next') : [ S E N D ( T R U E , ( token, token') , next') T O cust ] _ : [ S E N D ( F A L S E , src) T O cust ] E N D ] ] _ : [ S E N D ( F A L S E , src) T O cust ] E N D ] ]

k_seq ... seq ...

first rest

k_seq'

L E T

• pt_grammar_beh(

grammar) = λmsg. [ #

• p

t : : = < g r a m m a r > | < e m p t y > ; B E C O M E alt_grammar_beh( grammar, empty_grammar ) S E N D msg T O S E L F ] L E T star_grammar_beh( grammar) = λmsg. [ # s t a r : : = < g r a m m a r > < s t a r > | < e m p t y > ; B E C O M E seq_grammar_beh( N E W seq_grammar_beh( grammar, S E L F ) , empty_grammar ) S E N D msg T O S E L F ] L E T plus_grammar_beh( grammar) = λmsg. [ # p l u s : : = < g r a m m a r > < g r a m m a r > * ; B E C O M E seq_grammar_beh( grammar, N E W star_grammar_beh( grammar) ) S E N D msg T O S E L F ]

grammar alt empty

first rest

seq seq empty grammar

first first rest rest

grammar seq star(...)

first rest

expr ::= <const> | <ident> | 'λ' <ident> '.' <expr> | <expr> '(' <expr> ')'; Un-typed Lambda Calculus

C R E A T E empty_env WI T H λ( cust, _) . [ S E N D ? T O cust ] L E T env_beh( ident, value, next) = λ( cust, ident') . [ I F $ ident' = $ ident [ S E N D value T O cust ] E L S E [ S E N D ( cust, ident') T O next ] ] L E T const_expr_beh( value) = λ( cust, # e v a l , _) . [ S E N D value T O cust ] L E T ident_expr_beh( ident) = λ( cust, # e v a l , env) . [ S E N D ( cust, ident) T O env ] L E T abs_expr_beh( ident, body_expr) = λ( cust, # e v a l , env) . [ C R E A T E closure WI T H λ( cust, # a p p l y , arg) . [ C R E A T E env' WI T H env_beh( ident, arg, env) S E N D ( cust, # e v a l , env') T O body_expr ] S E N D closure T O cust ] L E T app_expr_beh( abs_expr, arg_expr) = λ( cust, # e v a l , env) . [ S E N D ( k_abs, # e v a l , env) T O abs_expr C R E A T E k_abs WI T H λabs. [ S E N D ( k_arg, # e v a l , env) T O arg_expr C R E A T E k_arg WI T H λarg. [ S E N D ( cust, # a p p l y , arg) T O abs ] ] ]

Evaluating (λx.x)(42)

Open Systems

• Continuous Change and Evolution
• Decentralized Decision-Making

– Absence of Bottlenecks – Arms-length Relationships

• Perpetual Inconsistency
• Negotiation Among Components

–C. Hewitt and P. de Jong (1983)

References

• It's Actors All The Way Down <http://dalnefre.com/>
• C. Hewitt. Viewing Control Structures as Patterns of Passing
• Messages. Journal of Artificial Intelligence, 8(3), 1977.
• G. Agha. Actors: A Model of Concurrent Computation in

Distributed Systems. MIT Press, Cambridge, MA, 1986.

• C. Hewitt, H. Lieberman. Design Issues in Parallel Architectures

for Artificial Intelligence. AI Memo 750, MIT AI Lab, 1983.

• G. Agha, I. Mason, S. Smith, and C. Talcott. A Foundation for

Actor Computation. Journal of Functional Programming, Vol. 7,

• No. 1, January 1997.