"I keep bouncing off the #Scheme language"

https://www.sicpers.info/2026/05/i-keep-bouncing-off-the-scheme-language/

( #Lisp )

with interesting discussion in the HN thread - https://news.ycombinator.com/item?id=48233398

'Scheme was invented as a consequence of Sussman & Steele’s discovery that lexical closures in the lambda calculus had essentially an identical implementation to a fully elaborated version of Hewitt’s actor model.

I do wonder what a language with the same “taste” and minimalism as Scheme but embracing the actor model would look like. Erlang?

Even better if someone could figure out how to harmonize them in the same language: “There are exactly two ways to do it, and they’re interchangeable.”'

to which a reply referencing @spritely #SpritelyGoblins:

'> I do wonder what a language with the same “taste” and minimalism as Scheme but embracing the #ActorModel would look like.

There is Spritely Goblins: https://spritely.institute/goblins/ '

(and a third reply:

'A 98-page PDF on language design for distributed objects in a capability security model? Made my day, thanks!')

RE: https://mastodon.social/@Mastodon/116402716327956884

Glad to see things like search and discovery #FASP, although it doesn't seem like FASPs are being modeled with an #ActorModel or #JSON-LD in mind. Another thing I'd like to see implement is federated search (#sparQL has prior art)

DomoTacticalStorage-TS is now available for #ActorModel.

Persistent storage backends for DomoTactical-TS providing #EventSouring Journal and DocumentStore implementations for #Kurrent #KurrentDB / #EventStoreDB and @cloudflare #D1.

https://www.npmjs.com/package/domo-tactical-storage

https://kitfucoda.medium.com/actor-models-in-pygame-lessons-in-serialization-and-state-isolation-979c5af57cc5

My attempt to build a prototype recreating the Matrix rain effect last week forced a hard look at my mini Pygame framework. The implementation yielded a mixed result that I’d previously overlooked—not due to the Actor model itself, but a misjudgment in where the "Physical" meets the "Semantic." Extracting a portable framework through refactoring was the goal, yet I was still facing inefficiencies in state management and event dispatch lookups.

In a search for order, I decided to overengineer the project for the sake of learning. My plan was to split the application into three independent processes: the state actor, the display loop, and the event dispatcher. If a little isolation is good, then I figured more processes in parallel must mean faster execution. I wanted to bypass the Global Interpreter Lock and find true independence for each component.

Then I hit the waterfall. The code eventually ran, but the realization of a "Transparency Tax" came an hour later. Instead of hitting a 60 FPS target, my frame rate plummeted into the 30s. Between the serialization overhead of sending callables through cross-process queues and the blocking nature of Pygame’s clock, the Actor process was left with little room for concurrency. The added complexity of message passing became the very bottleneck I sought to avoid.

I failed the mission to cleanly separate components into independent processes, but the expedition pushed me far enough from my comfort zone that the insights were worth the crash. If experience is a painting, the trail of footsteps is exactly how lines are formed in an image. I’m moving back to a single-process model for the next revision, keeping the clean Actor API but losing the performance tax.

#Python #Pygame #SoftwareArchitecture #ActorModel #Concurrency #KitFuCoda #Fediverse

In case you are freaking out over using some mysterious asynchronous messaging library for #TypeScript, don't worry. It will feel exactly like async/await because it is async/await, but with all the benefits of the #ActorModel.

https://mastodon.social/@VaughnVernon/115566789124869401

#DomoActors-TS v1.1.0 of is now published; the #ActorModel toolkit for #TypeScript fault-tolerant and message-driven concurrency.

Stage's new registerValue(), registeredValue(), and deregisterValue(). See the documentation and source code:

https://www.npmjs.com/package/domo-actors

https://github.com/VaughnVernon/DomoActors-TS

Now it's time for #DomoActors on #Python => DomoActors-Py the type-safe #ActorModel library for Python.

$ pip install domo-actors

Requires: Python 3.10+
Uses: asyncio for async/await

See below for links.

On GitHub:
https://github.com/VaughnVernon/DomoActors-Py

On PyPI:
https://pypi.org/project/domo-actors/1.0.0/

I have published #DomoActors for #TypeScript, an #ActorModel toolkit for the #JavaScript platform with fault-tolerant, message-driven concurrency.

$ npm -install domo-actors

See below for access.

- Runtimes: Node.js >= 18.0.0, Deno, Bun, Cloudflare Workers and Durable Objects, or any V8-based JavaScript runtime

- TypeScript: >= 5.0.0 (for development)

- DomoActors has zero Node.js-specific dependencies and runs on any V8-compatible runtime. See below for access.

1/2

This is an amazing prediction by #CarlHewitt, inventor of the #ActorModel, regarding a revolution in #AI by 2025. It's sad that like many of the early pioneers, he didn't live to see it happen. (Video: 5 minutes.)

https://www.youtube.com/watch?v=A69umiVS3ic