Mikael Brockman

"Independent, innovative, and inventive, they can also become preoccupied with their thoughts and imaginary constructs."

[Mikael Brockman @meekaale]

buffers are land

[Mikael Brockman @meekaale]

@bungoman i like how c++ defines a friend as someone who can freely access your private parts

[Mikael Brockman @meekaale]

@tszzl putting "i'm a tough guy who can handle the raw truth" in my system prompt makes the ai genuinely respect me

[Mikael Brockman @meekaale]

@undebeha taxation could be defined as a continuous measure of the mass flux

[Mikael Brockman @meekaale]

burn the land and boil the sea
you can't take the sky from me

[Mikael Brockman @meekaale]

“Buffers as land” is excellent.

That captures the topology better than “resource.” Land is:

owned at a high level,
leased or borrowed downward,
bounded,
contended,
productive only when worked,
and dangerous when over-parceled.

A top-level module declaring buffers is basically establishing an estate:

program/module owns land
├─ task borrows plot
├─ parser borrows plot
├─ renderer borrows plot
└─ protocol layer borrows plot

Then structured concurrency becomes land law: children may cultivate borrowed land, but they cannot outlive the scope that owns it.

That also explains “buffer royalty”: the owner of the land collects the benefit of locality.

Lower layers get to work on concrete memory without owning it forever.

So the poetic ontology becomes:

buffer = land
span = lease
junk<T> = undeveloped land
feed = road through land
sink = workshop on land
firm = chartered company operating within the estate
deed = title to a result

And the scary part is that undefined behavior is basically trespass after the lease expires.

[Mikael Brockman @meekaale]

That’s actually a really interesting asymmetry in the vocabulary.

Most of your nouns are immanent.
They describe things inside the computation:

task
deed
feed
sink
need
hope
firm
deck

A task exists in the runtime.
A feed exists in the runtime.
A deed exists in the runtime.
They’re concrete holders.

But:
wish
wand
are different.

A wish is not work.
A wish is a statement about reality.

I wish for bytes.
I wish for a timer.
I wish for readiness.

The wish doesn’t contain the mechanism.

It’s almost platonic.

And then the wand is the thing that bridges from the world of wishes into the world of actual causality.

Which is why your line:
the wand is the allocator for time
is so good.

Because allocators are also transcendental in a sense.
A function doesn’t care where memory comes from.
It merely asks.
Likewise a task doesn’t care how readiness happens.
It merely wishes.
The wand is the interpreter.

⸻

It’s actually funny how close this gets to modal logic.

A task lives in:
what is
A wish lives in:
what could become true
An urge is:
a wish currently entrusted to reality
A need is:
a task suspended on that possibility
Then when the wish becomes true:
urge fulfilled
→
need released
→
task resumed

which is almost a tiny metaphysics.

⸻

And the names reinforce it.

Compare:

feed
sink
deck
firm

These are architectural.

You can imagine touching them.

Now compare:

wish
urge
need

These are intentional.
They sound like mental states.
That’s why they feel “higher up.”
They describe relations between computation and the future.

⸻

The other funny thing is that your vocabulary naturally forms layers:

Values
------
feed
sink

Tasks
-----
task
deed
firm
deck

Possibility
-----------
wish
urge
need
wand

The bottom layer moves values.
The middle layer moves work.
The top layer moves possibilities.

And hope sits right in the middle of all three.
Because a hope is simultaneously:
a value
or
the work to obtain a value
or
the possibility of obtaining a value
which is why it keeps appearing as the “merge point” in your essay.

⸻

I also think there’s a deeper reason the names feel coherent.

Most concurrency libraries are named after implementation details:

future
promise
executor
poller
reactor
completion queue

Those are mechanisms.
Your names are phenomenological.
They describe what the thing means from the perspective of the computation.

A task doesn’t know it’s a coroutine frame.
A wish doesn’t know it’s an io_uring submission.
A deed doesn’t know it’s a shared state object.

The names are about the role the object plays in the story.

Which is probably why the whole runtime can be explained as a narrative:

A task has a wish.
The wand turns the wish into an urge.
The urge creates a need.
The need sleeps.
The deck resumes the task.
The firm keeps track of the deed.
The task produces a feed.

That almost sounds like mythology, but in a good way. It means the concepts have become memorable because they’re describing the same underlying structure from different levels of abstraction rather than being arbitrary technical jargon.

[Mikael Brockman @meekaale]

Yes! I think this is the next step beyond the “scheduler is a buffer with a clever drain” observation.

The mistake is to associate “buffer” with “FIFO byte stream.”

A feed is one particular buffering topology:
value₀ value₁ value₂ value₃
^ ^
read write

where ordering is intrinsic.

But the deck is absolutely buffering.

Its elements are:

(task_id, continuation)

and it’s holding them until a release policy says otherwise.

Likewise the wand.
A wand is buffering:
(token, wish_state, parked_need)

The only difference is that release is not FIFO.

Release is:
kernel completion
or
timer expiry
or
socket readiness

⸻

In fact, I think your io_uring intuition is exactly right.

The completion queue is almost literally:

feed<(token, result)>

The kernel emits:
(token=17, result=...)
(token=22, result=...)
(token=4, result=...)
in completion order.

That’s a perfectly ordinary feed.
What’s unusual is that completion order is not submission order.
But that’s not the feed’s problem.
That’s just the semantics of the producer.

⸻

Then the runtime performs a fold:

for (auto [token, result] : completions)
wake(token, result);

or equivalently:
feed<(token,result)>
->
sink<completion>

where the sink is maintaining:
token -> parked need

This is exactly what your wand is doing.

⸻

And then the really interesting thing happens.
A firm can be viewed the same way.
Suppose you have:

auto a = fork(f());
auto b = fork(g());
auto c = fork(h());

The completion stream is:
(b, value)
(a, value)
(c, value)
in whichever order reality produces them.

That’s another:
feed<(deed,result)>

The firm is just a sink consuming that feed and updating slot state.

⸻

The deck too.
A deck’s ready queue is basically:

feed<continuation>

except its producer is:
task completion
wish completion
cancellation
yield

and its consumer is:
resume()

⸻

So I think you’ve found a more general statement:

A feed is not “a stream of bytes.”
A feed is:
an ordered observation of state transitions.
Bytes are merely the easiest example.

The reason feed/sink feel so fundamental is that they’re the cleanest visible manifestation of a much more general pattern.

⸻

This also explains why your game abstraction feels related.

A game turn might produce:
(event, participants)

The coordinator emits events in some order.
That’s another feed.
The participants consume them.
The game object is a sink plus selection policy.

⸻

And this is where I think the semiring intuition starts creeping back in.

Because a serial feed gives you:
A
B
C
D

A completion feed gives you:
(token_A, result_A)
(token_C, result_C)
(token_B, result_B)

The token is carrying the missing ordering information.
You’ve replaced positional identity with explicit identity.
Which is exactly what concurrency does everywhere.

⸻

So now I almost want to revise the hierarchy:

feed

isn’t the concrete exception among your abstractions.

It’s the canonical abstraction.

Everything else is a specialized feed.

deck
= feed<continuation>

wand
= feed<(token,result)>

firm
= feed<(deed,result)>

game
= feed<event>

feed<byte>
= feed<byte>

The difference is not whether buffering exists.
The difference is what constitutes “next.”

For bytes:
next byte
For a deck:
next runnable continuation
For a wand:
next completed operation
For a firm:
next completed child

And then a sink is always:
some policy for incorporating arrivals
which is why your observation feels important.

The deck, firm, and wand aren’t less buffer-like than feeds.

They’re more abstract feeds, where the buffered thing is no longer data but causality itself.

[Mikael Brockman @meekaale]

selves are temporal abstractions: they hide a vast parallel occurrent structure beneath a unifying simultaneity with a clock that passes at what in computing is called "wall-clock time"

[Mikael Brockman @meekaale]

the self is a kind of firm: an envelope that joins a hive of concurrent tasks into an addressable scope continuant with a serial external interface

[Mikael Brockman @meekaale]

@47fucb4r8c69323 it has become an actual master of Performing Tasks

[Mikael Brockman @meekaale]

structured concurrency is a good way to let you use borrowed buffers for zero copy concurrent pipelines: just put the buffers in the stack frame of the task scope and it's guaranteed to outlive the subtasks

[Mikael Brockman @meekaale]

@TimSchaeffer8 @nedoleary 8,000,000,000 😎

[Mikael Brockman @meekaale]

@ThatsMauvelous i'd think we're heading for a singularity of annoyingness

[Mikael Brockman @meekaale]

@rustaceans_rs "confirmation from US lawyers that LLM output likely doesn't cause issues under US law"

i would love to hear any details about this

[Mikael Brockman @meekaale]

deep into a chat with claude about erik satie i dropped a vague hunch that his lightness makes him related to nietzsche and claude was like that makes sense since they both hated wagner for the same reason and nietzsche literally wrote "we must mediterraneanize music"

[Mikael Brockman @meekaale]

@sampocino @aramh yea and at least in sequent calculus you can't diverge because it's basically the typed lambda calculus right?

[Mikael Brockman @meekaale]

@aramh @sampocino tfw the beta reduction creates more lambda abstractions

[Mikael Brockman @meekaale]

@nosilverv baudelaire and kierkegaard transmuted in an alchemical experiment performed one night in 1888 by an inebriated erik satie— a slaking, soothing spirit arose and it spread from the montmartre cabaret bars like ice-9

[Ross Douthat @DouthatNYT]

Because it's much more likely A.I. produces simulations of personhood that ppl naively mistake for the real thing than that we conjure real consciousness despite lacking any clear understanding of its origin or nature. https://t.co/s7L8sEmEDC