Rakka: Actor Model for Racket🔗ℹ

1.1 Your First Actor🔗ℹ

#lang racket/base

(require rakka racket/match)

;; Define an actor that echoes messages back

(define (echo-actor)

(let loop ()

(define msg (receive))

(match msg

[(list 'echo payload from)

(send! from (list 'reply payload))

(loop)]

['stop (void)]

[_ (loop)])))

;; Run it

(define (main)

(define echo (spawn echo-actor))

(send! echo (list 'echo "hello!" (self)))

(define reply (receive))

(printf "Got: ~a\n" reply)

(send! echo 'stop))

;; Must run inside a process

(spawn main)

2.1 The Mental Model🔗ℹ

Think of actors like people in separate rooms, communicating by passing notes.

• Isolation: Each actor has its own memory. No shared state.

• Messages: The only way to communicate. Drop a note in their mailbox.

• Mailboxes: Each actor has one. Messages queue up, processed one at a time.

• Failures stay local: If one actor crashes, others keep running.

2.2 Spawning Processes🔗ℹ

spawn creates a new actor running your function:

(define pid (spawn (lambda ()

(printf "I'm alive!\n")

(sleep 1)

(printf "Goodbye!\n"))))

(printf "Spawned: ~a\n" pid)

(printf "Alive? ~a\n" (pid-alive? pid))

(sleep 2)

(printf "Still alive? ~a\n" (pid-alive? pid))

The spawned process runs in parallel. pid-alive? checks if it’s still running.

2.3 Sending and Receiving Messages🔗ℹ

send! drops a message in an actor’s mailbox. It returns immediately—fire and forget.

(send! some-pid 'hello)

(send! some-pid (list 'data 1 2 3))

(send! some-pid (hash 'key "value"))

receive blocks until a message arrives:

(define msg (receive))  ; blocks

receive/timeout adds a deadline (in milliseconds):

(define msg (receive/timeout 1000))  ; wait up to 1 second

(if msg

(printf "Got: ~a\n" msg)

(printf "Timed out\n"))

2.4 The Actor Loop Pattern🔗ℹ

Most actors follow this pattern—loop forever, handle messages:

(define (counter-actor initial)

(let loop ([count initial])

(define msg (receive))

(match msg

['increment

(loop (add1 count))]

[(list 'get from)

(send! from count)

(loop count)]

['stop

(printf "Final count: ~a\n" count)]

[_

(loop count)])))  ; ignore unknown messages

State lives in the loop arguments. Each iteration can pass new state to the next.

3.1 When to Use Each🔗ℹ

3.2 Switching Modes🔗ℹ

Use runtime-mode to select the execution model before spawning actors:

#lang racket/base

(require rakka)

;; Green mode (default) - lightweight, cooperative

(runtime-mode 'green)

(scheduler-start!)

(for ([i 10000])

(spawn (lambda () (receive))))  ; 10,000 actors, no problem

(scheduler-run-until-done!)

(scheduler-stop!)

For CPU-bound parallel work:

;; Threaded mode - real OS threads

(runtime-mode 'threaded)

(spawn (lambda ()

;; CPU-bound work runs in parallel

(heavy-computation)))

3.3 Performance Characteristics🔗ℹ

Green threads excel at actor-heavy workloads:

Use green mode unless you need CPU parallelism.

3.4 How It Works🔗ℹ

Green threads use continuation-based cooperative scheduling:

• No OS thread per actor: Thousands of actors share one thread

• Cooperative yielding: Actors yield at message receive points

• Two-list mailbox queue: O(1) amortized message operations

• Timeout support: Actors can wait with deadlines

The scheduler maintains a ready queue of actors. When an actor calls receive with no messages, it suspends (saving its continuation) and the scheduler runs the next ready actor. When a message arrives, the waiting actor is added back to the ready queue.

4.1 Why GenServer?🔗ℹ

GenServer provides this infrastructure. You just implement callbacks.

4.2 Implementing a GenServer🔗ℹ

Define a struct that implements gen:server:

#lang racket/base

(require rakka racket/match)

(struct counter-server ()

#:methods gen:server

[(define (init self args)

(ok args))  ; args becomes initial state

(define (handle-call self msg state from)

(match msg

['get (reply state state)]

['increment (reply 'ok (add1 state))]))

(define (handle-cast self msg state)

(match msg

['reset (noreply 0)]

[_ (noreply state)]))

(define (handle-info self msg state)

(noreply state))

(define (terminate self reason state)

(void))])

4.3 The Callbacks🔗ℹ

4.4 Using a GenServer🔗ℹ

;; Start the server

(define pid (gen-server-start (counter-server) 0))

;; Synchronous call (blocks for reply)

(printf "Count: ~a\n" (gen-server-call pid 'get))      ; => 0

(printf "Inc: ~a\n" (gen-server-call pid 'increment))  ; => ok

(printf "Count: ~a\n" (gen-server-call pid 'get))      ; => 1

;; Async cast (fire and forget)

(gen-server-cast! pid 'reset)

(sleep 0.01)  ; let it process

(printf "Count: ~a\n" (gen-server-call pid 'get))      ; => 0

;; Stop

(gen-server-stop pid)

5.1 Links: Shared Fate🔗ℹ

Linked processes die together. If one crashes, the other receives an exit signal.

;; Spawn and link in one step

(define pid (spawn-link (lambda ()

(sleep 1)

(error "boom!"))))

;; Or link explicitly

(define pid2 (spawn some-actor))

(link! pid2)

By default, exit signals kill the receiver too. To handle them instead:

(set-trap-exit! (self) #t)

;; Now exit signals arrive as messages

(define msg (receive))

(match msg

[(exit-signal from reason)

(printf "~a died: ~a\n" from reason)])

5.2 Monitors: One-Way Watching🔗ℹ

Monitors watch without shared fate. The watcher gets notified, but doesn’t die.

(define ref (monitor! some-pid))

;; Later, if some-pid dies:

(define msg (receive))

(match msg

[(down-signal ref pid reason)

(printf "~a died: ~a\n" pid reason)])

Use demonitor! to stop watching.

6.1 Why Supervisors?🔗ℹ

Instead of handling every possible error, let processes crash and restart clean. This is the "let it crash" philosophy.

6.2 Restart Strategies🔗ℹ

6.3 Defining Children🔗ℹ

Use child-spec* to define how to start each child:

(child-spec* #:id 'worker

#:start (lambda () (gen-server-start-link (my-worker) '()))

#:restart 'permanent)

6.4 Starting a Supervisor🔗ℹ

(define sup-pid

(supervisor-start-link 'one-for-one  ; strategy

3              ; max 3 restarts

5              ; in 5 seconds

(list

(child-spec* #:id 'worker1

#:start worker1-start

#:restart 'permanent)

(child-spec* #:id 'worker2

#:start worker2-start

#:restart 'permanent))))

If a child crashes more than 3 times in 5 seconds, the supervisor gives up and terminates (which may trigger its own supervisor to restart it).

9.1 Process Primitives🔗ℹ

9.2 Runtime Mode🔗ℹ

9.3 Registry🔗ℹ

9.4 Links and Monitors🔗ℹ

9.5 GenServer🔗ℹ

9.6 Supervisor🔗ℹ

9.7 Testing Utilities🔗ℹ

10.1 Why #lang rakka?🔗ℹ

In green thread mode, actors cooperatively yield at receive points. But what if an actor computes for a long time without receiving? It starves other actors.

#lang rakka solves this by counting "reductions" (function calls). After 4000 reductions, it automatically yields. This is how Erlang achieves fair scheduling.

10.2 Using #lang rakka🔗ℹ

#lang rakka  ; <-- Just change this line

(require rakka)

;; Every function call now includes a yield point

(define (fib n)

(if (<= n 1)

n

(+ (fib (- n 1)) (fib (- n 2)))))

;; Even fib(30) won't starve other actors

(spawn (lambda () (printf "fib(30) = ~a~n" (fib 30))))

(spawn (lambda () (printf "I'm not blocked!~n")))

10.3 Manual Reduction Control🔗ℹ

#lang rakka

(set-reduction-limit! 1000)  ; Yield more often

(reset-reductions!)          ; Reset counter

(current-reductions)         ; Check current count

10.4 Anti-Pattern Warnings🔗ℹ

#lang rakka warns about patterns that break actor isolation:

#lang rakka

(define x 1)

(set! x 2)  ; Warning: mutation may break actor isolation

(thread (lambda () ...))  ; Warning: raw threads bypass actor scheduler

Disable with (disable-rakka-warnings!).

11.1 Starting a Distributed Node🔗ℹ

#lang racket

(require rakka)

;; Start EPMD (once per machine, typically port 4369)

(define epmd (start-epmd! 4369))

;; Start this node

(start-node! "mynode@localhost" 9001

#:cookie "secret-cookie")

The cookie must match between nodes that want to communicate.

11.2 Connecting Nodes🔗ℹ

;; On node2

(start-node! "node2@localhost" 9002

#:cookie "secret-cookie")

;; Connect to node1

(connect-node! "mynode@localhost")

;; See connected nodes

(nodes)  ; => '("mynode@localhost")