Thinking In Boc

Thinking in Behavior-Oriented Concurrency

This skill is a corrective. The default reflex when synchronizing concurrent work is to reach for threads-and-locks primitives: shared state, a mutex, a condition variable, a busy-wait loop, an atomic counter, an event flag, a Future. In BOC, those answers are almost always wrong — not because they break, but because they bypass the very mechanism that makes BOC safe and fast.

The BOC question is not "what synchronization primitive do I need here?"

It is: "what cown is this work ordered against, and what behavior should run when that cown is free?"

Read this skill any time you catch yourself writing one of the smells below.

The smells

If you find yourself typing any of these inside, or in code that interacts with, a BOC program — stop and re-derive the design.

The smells are signals that you are managing concurrency outside the runtime. The runtime cannot help you make that correct or fast.

The replacements

There are only a handful of BOC patterns. Almost every problem decomposes into one of them.

1. Sequencing on data — @when(cown)

A behavior runs when its cowns are free. That is the entire ordering mechanism. If step2 must observe step1's effect on x, both behaviors take x:

@when(x)
def step1(x):
    x.value = "ready"

@when(x)
def step2(x):
    assert x.value == "ready"

You did not need a lock. You did not need an event. You did not need to poll. The runtime acquired x for step1, released it, and only then gave it to step2.

2. Fan-in / barrier — @when(cowns) vs @when(a, b, c)

There are two distinct shapes for "this behavior depends on multiple cowns" and choosing the right one matters.

Use @when(a, b, c) — separate positional arguments — when you know at write-time exactly which cowns the behavior needs and they have distinct roles. The decorated function takes one named parameter per cown:

@when(account_a, account_b)
def transfer(src, dst):                     # two roles, two names
    dst.value += src.value
    src.value = 0

Use @when(cowns) — a single list/tuple argument — when the set is dynamic or homogeneous (its size is determined at runtime, or the cowns play the same role). The decorated function takes one parameter which is the list itself:

cowns = [Cown(i) for i in range(N)]
for c in cowns:
    @when(c)
    def producer(c):
        ...                                 # writes whatever it writes

@when(cowns)                                # one list arg, not *cowns
def consumer(cowns):
    total = sum(c.value for c in cowns)     # cowns IS the list

This is the classical N-way barrier, expressed as data dependence: the runtime acquires every cown in the list before the behavior runs, so the consumer cannot start until every producer behavior has returned. Do not spread the list with * — @when accepts the list directly, and spreading would force you to know N at write-time, defeating the point.

Mixing the two forms — @when(anchor, cowns) — is also valid: the behavior takes one named parameter (anchor) plus one list parameter.

3. Happens-after — chain on the prior behavior's result cown

@when returns a Cown holding the behavior's result. Pass that cown to a later @when to enforce happens-after across unrelated data:

@when(x)
def writer(x):
    x.value = compute()

@when(y, writer)                            # y is unrelated; writer is the result cown
def reader(y, w):
    consume(y.value, w.value)               # runs only after writer finished

Here reader touches its own data (y) and would otherwise be free to run concurrently with writer. Depending on the writer result cown is what serializes them: the runtime cannot acquire writer until that behavior has returned, so reader sees its result via w.value.

4. Run when any worker is free — @when()

@when() with no arguments schedules a behavior with no data dependencies. It runs as soon as a worker is available. Use this when you want some work to happen in the background and you do not need to coordinate with any particular cown — for example, sending a report after forks have been released:

@when(left, right, hunger)
def take_bite(left, right, hunger):
    left.value.use(); right.value.use()
    hunger.value -= 1
    if hunger.value == 0:
        # forks released when this behavior returns; the report goes
        # out from a fresh behavior so it does not delay the release.
        @when()
        def _():
            send("report", ("full", index))

@when() is also the BOC equivalent of "tail-call this on the worker pool" — it lets the current behavior return promptly while the follow-up work waits its turn.