#actormodel — Public Fediverse posts

"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!')

"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!')

"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!')

"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!')

"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)

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)

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)

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)

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

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

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

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

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

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

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

i might not need a full blown actor framework for the idea i have to get the features i want. i dont care about asynchronous execution, distributed runtimes and all that other stuff for my text editor to have runtime function hot swapping. i just need a single massive global vtable, and online upgrades are just updating the function pointer the index points to. plus i get object capability security for free since you use an opaque index (tho that's kinda irrelevant for my usage)

all the actual logic for that is a single function with a bit of inline assembly to shuffle the arguments around, do a silly little index into an array, then jump to it.

it's a memory access so this does hurt cache if you're calling into an actor while doing some heavy computation in some loop (like processing a text buffer into a list of vertices and passing it to a renderer actor), but you're calling into another actor anyway and that could do anything. you should probably be batching these calls instead.

#actormodel #texteditor

i might not need a full blown actor framework for the idea i have to get the features i want. i dont care about asynchronous execution, distributed runtimes and all that other stuff for my text editor to have runtime function hot swapping. i just need a single massive global vtable, and online upgrades are just updating the function pointer the index points to. plus i get object capability security for free since you use an opaque index (tho that's kinda irrelevant for my usage)

all the actual logic for that is a single function with a bit of inline assembly to shuffle the arguments around, do a silly little index into an array, then jump to it.

it's a memory access so this does hurt cache if you're calling into an actor while doing some heavy computation in some loop (like processing a text buffer into a list of vertices and passing it to a renderer actor), but you're calling into another actor anyway and that could do anything. you should probably be batching these calls instead.

#actormodel #texteditor

also correct me if im wrong, but can a #microkernel be considered to be using the actor model? because rpc can be seen as just passing messages around and each userspace driver as an actor. i only just learnt about the #actormodel though

also correct me if im wrong, but can a #microkernel be considered to be using the actor model? because rpc can be seen as just passing messages around and each userspace driver as an actor. i only just learnt about the #actormodel though

also correct me if im wrong, but can a #microkernel be considered to be using the actor model? because rpc can be seen as just passing messages around and each userspace driver as an actor. i only just learnt about the #actormodel though

Talking to someone from the Actor/OCAP model about programming.

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

#programming #ActorModel #OCAP

Talking to someone from the Actor/OCAP model about programming.

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

#programming #ActorModel #OCAP

Talking to someone from the Actor/OCAP model about programming.

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

#programming #ActorModel #OCAP

Talking to someone from the Actor/OCAP model about programming.

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

#programming #ActorModel #OCAP

Watching David Khourshid talk from JSConf. It's interesting to see how to relates the actor model to LLM agents

(also points for the Microsoft Orleans call out 🙂)

https://www.youtube.com/watch?v=GhAl0EiXmaY
#jsconf #actormodel #llm

Watching David Khourshid talk from JSConf. It's interesting to see how to relates the actor model to LLM agents

(also points for the Microsoft Orleans call out 🙂)

https://www.youtube.com/watch?v=GhAl0EiXmaY
#jsconf #actormodel #llm

Watching David Khourshid talk from JSConf. It's interesting to see how to relates the actor model to LLM agents

(also points for the Microsoft Orleans call out 🙂)

https://www.youtube.com/watch?v=GhAl0EiXmaY
#jsconf #actormodel #llm

Watching David Khourshid talk from JSConf. It's interesting to see how to relates the actor model to LLM agents

(also points for the Microsoft Orleans call out 🙂)

https://www.youtube.com/watch?v=GhAl0EiXmaY
#jsconf #actormodel #llm

Watching David Khourshid talk from JSConf. It's interesting to see how to relates the actor model to LLM agents

(also points for the Microsoft Orleans call out 🙂)

https://www.youtube.com/watch?v=GhAl0EiXmaY
#jsconf #actormodel #llm

Meet #ApachePekko - an open-source framework designed to simplify the development of concurrent, distributed, resilient, and elastic applications.

Pekko allows developers to focus on business logic rather than low-level implementation details.

Discover more: https://bit.ly/3wtUCxS

#InfoQ #Java #ActorModel #Concurrency

Meet #ApachePekko - an open-source framework designed to simplify the development of concurrent, distributed, resilient, and elastic applications.

Pekko allows developers to focus on business logic rather than low-level implementation details.

Discover more: https://bit.ly/3wtUCxS

#InfoQ #Java #ActorModel #Concurrency

Meet #ApachePekko - an open-source framework designed to simplify the development of concurrent, distributed, resilient, and elastic applications.

Pekko allows developers to focus on business logic rather than low-level implementation details.

Discover more: https://bit.ly/3wtUCxS

#InfoQ #Java #ActorModel #Concurrency

Meet #ApachePekko - an open-source framework designed to simplify the development of concurrent, distributed, resilient, and elastic applications.

Pekko allows developers to focus on business logic rather than low-level implementation details.

Discover more: https://bit.ly/3wtUCxS

#InfoQ #Java #ActorModel #Concurrency

Watching some of the #FosDem talks. I like the look of the #QuickWit #ActorModel framework. https://archive.fosdem.org/2023/schedule/event/building_an_actor_library_for_quickwits_indexing_pipeline/ Could be useful for my current project.

Watching some of the #FosDem talks. I like the look of the #QuickWit #ActorModel framework. https://archive.fosdem.org/2023/schedule/event/building_an_actor_library_for_quickwits_indexing_pipeline/ Could be useful for my current project.

Watching some of the #FosDem talks. I like the look of the #QuickWit #ActorModel framework. https://archive.fosdem.org/2023/schedule/event/building_an_actor_library_for_quickwits_indexing_pipeline/ Could be useful for my current project.

⏮️ Did you miss our XState: Exploring actors live stream last week? Catch up below.

Want us to do more live streams around XState and Stately? Let us know which topics are most valuable to you!

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

#XState #actors #actorModel #XStateV5 #Stately #visualization #diagramming #sequenceDiagrams

⏮️ Did you miss our XState: Exploring actors live stream last week? Catch up below.

Want us to do more live streams around XState and Stately? Let us know which topics are most valuable to you!

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

#XState #actors #actorModel #XStateV5 #Stately #visualization #diagramming #sequenceDiagrams

⏮️ Did you miss our XState: Exploring actors live stream last week? Catch up below.

Want us to do more live streams around XState and Stately? Let us know which topics are most valuable to you!

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

#XState #actors #actorModel #XStateV5 #Stately #visualization #diagramming #sequenceDiagrams

🎥 @laura explains the actor model & how it relates to state machines, in simple terms:

#javascript #xstate #stately #actormodel #designpatterns

https://youtu.be/_kdBNeMKLL0

🎥 @laura explains the actor model & how it relates to state machines, in simple terms:

#javascript #xstate #stately #actormodel #designpatterns

https://youtu.be/_kdBNeMKLL0

🎥 @laura explains the actor model & how it relates to state machines, in simple terms:

#javascript #xstate #stately #actormodel #designpatterns

https://youtu.be/_kdBNeMKLL0

🎥 @laura explains the actor model & how it relates to state machines, in simple terms:

#javascript #xstate #stately #actormodel #designpatterns

https://youtu.be/_kdBNeMKLL0

🎥 @laura explains the actor model & how it relates to state machines, in simple terms:

#javascript #xstate #stately #actormodel #designpatterns

https://youtu.be/_kdBNeMKLL0