jeremycarter

The latency on those listed products is high because it's async queue based processing. This on the other hand should have predictable low latency as the placement of the live object is known.

Looks great but one of the common problems with the virtual actor model is state query. It's all well and good to have nice separated state dbs but for most use cases that means further double up on storing the state again in another database that can query it. I don't think anyone has come up with a nice solution for this problem without using a loose document database, but even then actors can change their schema.

Perhaps emitting versioned domain events transactionally with the actor state is an option without prescribing an exact solution.

RACE HIM JERRY!

"they took our jobs!"

Maybe a couple of binaries? https://github.com/vercel-labs/scriptc

I remember getting magazines with basic games, where the full syntax was printed out. I would type it in and save to floppies on my Apple 2e - which my mother purchased second hand.

This concept has been around for a long time.

https://www.microsoft.com/en-us/research/wp-content/uploads/...

Do you have any engineering staff in Australia?

Surprised how well the Orleans serializer performs for most uses cases.

Check out https://siloserver.org . Silo has its own API but also spins up a Jellyfin-protocol compatibility layer. This allows you to use any Jellyfin client and just point it at your Silo server.

You've never worked at a large company.

As Reddit already pointed out, this is nothing novel.

I find the cult of python is hard to shift from some people. They just can't see it.

The CD is available on Archive.org

Hundreds of thousands of .NET applications run inside Linux Docker containers.

The tab key doesn't even work consistently across apps and screens.

There are genuinely some great power toys available.

Last year I wrote a simple system using Semantic Kernel, backed by functions inside Microsoft Orleans, which for the most part was a business logic DSL processor by LLM. Your business logic was just text, and you gave it the operation as text.

Nothing could be relied upon to be deterministic, it was so funny to see it try to do operations.

Recently I re-ran it with newer models and was drastically better, especially with temperature tweaks.

When you put it like that it really is a bad product.

Great response. All arguments are valid and fair.

Sounds good!

98% of teams I've worked on did not need microservices.

What's the technology behind this. I'm working on something myself, using a distributed actor model (setup like a graph) to create a living reactive model.

My sentiments exactly - well said. The big mistake is forcing OOP onto everything. It's why I really have an affinity with the virtual actor, it has just enough OOP for me to have classes, methods and internal state - I don't need inheritance, polymorphism, etc - just naive little classifications of things we call objects.

I also don't have to think of my system in a hierarchical supervised manner like earlier actor models. I just need cloud native distributed little objects.

You can see some modern products coming out that are just that:

1. Cloudflare Durable Objects - https://developers.cloudflare.com/durable-objects/

2. Restate Virtual Objects - https://restate.dev/

I agree. I'm not advocating doing a purist DDD solution but rather using similar modelling techniques and just making naive actors.

It's just part 1. I have just published part 2 which goes into more detail.

That's fair feedback. I wanted to post it in 3 parts, but I see now I probably should have just made one large post.

As I mentioned there's nothing novel in this post, especially for a senior. This is more about getting some context out of the way so that I can show some techniques in a future post.

It's tricky to provide a really good example right now. I notice in the .NET world there are like these DDD "starter packs", and my god, they're just layers of maintainability hell. If you look at older OOP/DDD books you'll notice that the domain object has real world methods on it, just like as if it were from a UML diagram.

What you should end up with are plain OOPy objects that mirror the real world. They're not skewed or constrained by their database model. They shouldn't have any dependencies on your infrastructure layer. The object should encapsulate state, behaviour, validity and consistency.

An example (which is probably overkill) would be https://learn.microsoft.com/en-us/dotnet/architecture/micros...

The next post is about modelling an actor and it might provide more insight for you.

What if the platform is not registered as a business in Australia? You can't fine it if it's not a legal entity there. Simply setup a php Facebook clone and host it in another country.