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

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

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

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

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.

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

#javascript #xstate #stately #actormodel #designpatterns

https://youtu.be/_kdBNeMKLL0

Update: got an answer from the best possible choice, Aaron Stannard 🙂

🙋‍♂️ Got a question regarding restarting #AkkaDotNet actors, and clearing their mailbox.

If you've been working with Akka.NET and have some idea, I'd appreciate the help 🙂

#CSharp #DotNet #ActorModel

https://stackoverflow.com/q/77696942/4923902

Lots of talk the last few days about #AdventOfCode. Unfortunately I don't have time to take part again this year. Too busy beavering away on a private project in #RustLang. Trying my hand at using an #ActorModel for the first time. Surprising little posts online about it. Best design advice I've seen was to follow the #EnterpriseIntegrationPatterns.

I feel like:

• Scheme is a great language

• The Actor Model is a great paradigm for computing (honestly underrated in practice)

• Scheme completely failed to capture the Actor Model.

I finally understand that the way that actors were supposedly designed into Scheme is by using closures. The problem with that is that invoking a closure is a synchronous (not asynchronous :P) operation, which is not equivalent to messaging an actor, which is always asynchronous.

I’ve been banging my head against the wall trying to do Actor Model programming in Scheme because I’ve read so much about that being the root inspiration of Scheme, but I’ve finally concluded that it just isn’t supported.

Of course, like any language, you can write an actor model library on top. And with the macro system in Scheme you can even make it look pretty. It’s just disappointing that it really isn’t supported, despite the abundant claims about the origins of Scheme, going back to Sussman and Steele themselves.

#Scheme #ActorModel #Concurrency

Hi everyone, here's my #introduction

I'm a PhD student in #distributedsystems at Sorbonne University in Paris.
Prior to being a student I worked at Intel, in the fintech industry and at Inria.

I'm interested in bringing shared memory to the #actormodel (I know, I know...).
My current interests are: transactional causal consistency, CRDTs and actors.

Besides from being a student, I'm also a dad ! (I know, I know...)
I try my best to share my passions and hobbies with my daughter. This includes traveling, reading, playing music and chess among other things.

Looking forwards to chatting about systems with this awesome community!

Hi Friends,

Looking for a new #freelance #software #development #project. Would ♥ to #getfedihired.

* >20 years coding #Python, #C#, #Java, #JS, & #TS.

* Vast exp. building #DistributedSystems in the ☁(#AWS, #Azure, #GoogleCloud) & on-prem.

* Authored & teaching academic #course on #DatabaseDesign + #workshops on #TestAutomation, #k8s, the #ActorModel, #CleanCode...

* #Empathy is my super-power, I love to help, teach, build and fix.

Please RT - Every BOOST helps 🙏

return(GiS); | Ejemplo del modelo actor con Dapr | https://www.returngis.net/2022/12/ejemplo-del-modelo-actor-con-dapr/ #dapr #dotnet #actormodel #returngis