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

- https://discuss.python.org/t/python-3-14-0-final-is-here/104210 (Python 3.14.0 (final) is here!)

- https://docs.python.org/3.14/whatsnew/3.14.html (What’s new in Python 3.14 by Adam Turner and Hugo van Kemenade)

- https://docs.python.org/3.14/whatsnew/changelog.html#changelog (Python 3.14 Changelog)

- https://astral.sh/blog/python-3.14 (Astral ready for Python 3.14)

```
uv self update
uv python upgrade 3.14
uvx [email protected]
uvx [email protected]
```

#Annotations

- https://docs.python.org/3/whatsnew/3.14.html#pep-649-pep-749-deferred-evaluation-of-annotations
- https://discuss.python.org/t/python-3-14-0-final-is-here/104210#:~:text=the%20evaluation%20of%20annotations%20is%20now%20deferred

Instead, annotations are stored in special-purpose annotate functions and **evaluated
only when necessary** (except if from __future__ import annotations is used).

# PEP 768 Python 3.14 **Safe external debugger interface, a zero-overhead external debugger interface for CPython

- https://docs.python.org/3.14/whatsnew/3.14.html#pep-768-safe-external-debugger-interface
- https://discuss.python.org/t/python-3-14-0-final-is-here/104210#:~:text=A%20zero%2Doverhead%20external%20debugger%20interface%20for%20CPython

Python 3.14 introduces a zero-overhead debugging interface that allows debuggers and profilers to safely attach to running Python processes without stopping or restarting them.

# RFC9562 Python 3.14 **UUID versions 6-8 are now supported by the uuid module**

- https://docs.python.org/3/whatsnew/3.14.html#uuid
- https://discuss.python.org/t/python-3-14-0-final-is-here/104210#:~:text=UUID%20versions%206%2D8%20are%20now%20supported%20by%20the%20uuid%20module

# zstandard

- https://peps.python.org/pep-0784/ (Adding Zstandard to the standard library)
- https://docs.python.org/3/whatsnew/3.14.html#whatsnew314-zstandard
- https://discuss.python.org/t/python-3-14-0-final-is-here/104210#:~:text=compression.zstd%20providing%20support%20for%20the%20zstandard%20compression%20algorithm.

# A new command line interface with asyncio introspection capabilities: python -m asyncio ps PID

- https://docs.python.org/3/whatsnew/3.14.html#asyncio-introspection-capabilities
- https://discuss.python.org/t/python-3-14-0-final-is-here/104210#:~:text=inspect%20running%20Python%20processes

# Multiple interpreters in the standard library

- https://peps.python.org/pep-0734/ (Multiple Interpreters in the Stdlib)
- https://docs.python.org/3.14/whatsnew/3.14.html#pep-734-multiple-interpreters-in-the-standard-library
- https://discuss.python.org/t/python-3-14-0-final-is-here/104210#:~:text=Multiple%20interpreters%20in%20the%20stdlib

- https://gdevops.frama.io/python/versions/3.14.0/3.14.0.html

# Python #Python314 #TemplateString #ZStandard #RemoteDebugging #MultipleInterpreters #FreeThreaded #UUID7 #asyncio #parallelism #CSP #ActorModel

Concurrency isn’t new, but how we apply it keeps evolving.

In this post, @JeroenSoeters explores how Ergo brings Erlang-inspired concurrency patterns to Go using the Actor Model.

We’re using ideas like this to help build tools that feel simple, but scale with your systems.

Full write-up and repo in comments below. 👇

Follow @plateng_labs for updates on what we're building.

#golang #actormodel #infra #platformengineering #devtools