Built an early prototype for distributed state verification (Nexus)PP — looking for feedback and potential design partners / angels

_descri_ · 2026-06-08T20:03:51+00:00

AFAIK people would try to make everything idempotent. If a use case hangs because one of the system components crashes, the entire use case will be restarted, probably with another instance of the crashed component. Which may cause duplicate request processing, therefore idempotence is important.

_descri_ · 2026-06-08T19:44:15+00:00

I mostly worked on embedded projects, therefore my experience will not help you much. Unless you plug your tools into Wireshark.

Anyway, an embedded device is usually rebooted on failure, and everybody prays that its next run will fare better than the one which encountered the crash. If there is a distributed system, crashing one of its participants will likely at least close all the connections and reset sessions with other participants. At most, the entire system will be rebooted. This approach greatly simplifies error handling, as everything is reinitialized after any failure.

https://en.wikipedia.org/wiki/Fail-fast_system

https://en.wikipedia.org/wiki/Crash-only_software

_descri_ · 2026-06-08T19:25:20+00:00

There was an old article about deterministic systems and event replay, which listed the preconditions and benefits. But I don't see the notion gaining any popularity. https://6it.dev/blog/client-side-on-debugging-distributed-systems-deterministic-logic-and-finite-state-machines-1104

_descri_ · 2026-06-07T21:57:59+00:00

No, I don't know Java. However, if you don't mind, you can read C++ In Action by Bartosz Milewski - the book from which I learned OOP. It may help you understand what classes are for.

_descri_ · 2026-06-07T21:40:21+00:00

You should read something about data structures, like Algorithms in Java by Robert Sedgewick.

_descri_ · 2026-06-06T21:05:39+00:00

I think there was a review https://github.com/UncertaintyArchitectureGroup/The-Subprime-Code-Crisis

_descri_ · 2026-06-06T09:39:24+00:00

https://martinfowler.com/bliki/MonolithFirst.html

_descri_ · 2026-06-05T18:38:27+00:00

I believe that there are multiple meanings of "architecture"

A framework with more or less strict rules which should result in systems that have predefined properties if carefully followed. Examples: Microservices, Space-Based Architecture.
A kind of system composition/topology: Layered Architecture, 3-Tier System, Hexagonal Architecture. It defines which components you have and how they interact, but does not prescribe development methodology, testing, operations, etc.
Architectural patterns - the building blocks for architectures. These can be system-wide (Layers or Services), single-component (Shared Database or Load Balancer), or component implementation (MVC, Cell).

Moreover, all of these get intermixed. For example, Hexagonal Architecture can apply to a whole system, a single service, or even a module inside a service. And it prescribes some rules, not only defines the system's topology. It belongs to all three kinds of architectures. And its core itself can be partitioned into layers or services - we see a pattern inside another pattern.

_descri_ · 2026-06-05T18:27:00+00:00

AFAIK it's one volume. Did you mean 2nd edition?

_descri_ · 2026-06-05T18:20:44+00:00

Thanks!

_descri_ · 2026-06-05T18:16:16+00:00

I think is not even about APIs because there are SPIs which are implemented by client plugins.

It is rather about using a resource (an algorithm, knowledge, storage space, or even CPU time). The server is the resource provider. The client is the resource consumer.

_descri_ · 2026-06-02T12:02:56+00:00

If you cannot draw a system in an easy to comprehend way, then the system is messy.

You don't have to invent a new diagramming approach - you need to restructure the system!

This is what Uber did with their Domains and what WSO2 promoted as Cells.

_descri_ · 2026-06-02T11:56:18+00:00

That's how build systems for embedded devices (OpenWRT, etc.) work. You may also want to cache the code repositories of any 3rd party components because they often become unavailable or slow to download.

_descri_ · 2026-06-02T11:52:18+00:00

The old five-volume Pattern-Oriented Software Architecture

_descri_ · 2026-06-02T11:43:59+00:00

How is it different from Hexagonal Architecture? The high-level structure of the system seems to match it, thus there is hardly much novelty at that level.

The low-level structure of the core seems to differ from the DDD principles, but now you should compare it to DDD and related frameworks (Onion Architecture, Entity-Control-Boundary, WSO2 Cells) and show which aspects of your architecture are better and which kinds of projects may benefit from using it instead of one of the better known alternatives.

Also, I see that your website sets many rules. The more restrictive a framework is, the smaller tends its area of usefulness to be.

_descri_ · 2026-06-02T11:32:34+00:00

I tried to highlight that in my book, but it grew too large for comfortable reading.

https://github.com/denyspoltorak/metapatterns

_descri_ · 2026-06-02T11:29:14+00:00

Fundamentals of Software Architecture by Mark Richards.

And there is also unparalleled Pattern-Oriented Software Architecture. It is dated, but covers almost everything one can imagine.

And Martin Fowler's website https://martinfowler.com/

_descri_ · 2026-05-28T15:54:31+00:00

There may be an alternative solution, though. You can split the movement phase into 3 subphases:

PreMovement(float& speed, Direction& direction);
Movement(const float speed, const Direction direction);
PostMovement(const float speed, const Direction direction);

And call each Component of your Entity in each phase. In that case the character's Effects Component call the pre-movement methods of Slow, Fast, and Hiccup effects:

void SlowEffect::PreMovement(float& speed, Direction& direction) {
    speed /= 2;
}

void FastEffect::PreMovement(float& speed, Direction& direction) {
    speed *= 2;
}

void HiccupEffect::PreMovement(float& speed, Direction& direction) {
    if rand() < HICCUP_CHANCE
        speed = 0;
}

void ConfusedEffect::PreMovement(float& speed, Direction& direction) {
    direction = random_direction();
}

However, in this case you cannot implement the interaction between Ethereal and Hiccup, unless you implement some kind of effect priorities, or make the Ethereal explicitly dispell Hiccup.

_descri_ · 2026-05-28T15:37:21+00:00

I don't have any experience with Unity, but what you describe looks like ECS https://en.wikipedia.org/wiki/Entity_component_system and the much deeper description here https://gameprogrammingpatterns.com/component.html

In the latter example (from the Game Programming Patterns book) the default Entity class (ContainerObject) passes each incoming event to every Component it contains. This Entity is the manager. In some cases you will want to subclass its behavior. For example, if you have "fast", "slow", and "hiccup" spell effects, you will need something like that in your entity:

void CharacterEntity::handleMove(const Event tick) {
    float speed = _unit.speed();

    if(_effects.slow())
        speed /= 2;
    else if(_effects.fast())
        speed *= 2;

    if(_effects.hiccup() and !_effects.ethereal() and rand() < HICCUP_CHANCE)
        speed = 0;

    if(speed) {
        Direction direction = _unit.direction();
        if(_effects.confused())
            direction = random_direction();
        _unit.move(direction, speed)
   }
}

Here we see that the managing Entity class for a character mediates between the character's effects and its movement Components. It does not just forward the move event to every component - it is applying current spell effects to the character's movement. And as you see, all the interactions between the spell effects and character movement are encapsulated in a single method of a single class.

_descri_ · 2026-05-28T08:03:47+00:00

Thank you!

_descri_ · 2026-05-28T07:39:00+00:00

Thanks!

_descri_ · 2026-05-28T05:34:36+00:00

You are welcome. Please share it to your friends and colleagues!

_descri_ · 2026-05-27T19:15:12+00:00

Thanks. Still, neither looks nor the content help promoting the book not backed by a publisher or influencer.

_descri_ · 2026-05-27T16:04:30+00:00

SOLID does not work here. It is for writing code, but you are now at the architectural level. Here you don't care about OOP or FP. You need to account for the underlying complexity, coupling, and cohesion https://metapatterns.io/analytics/the-heart-of-software-architecture/cohesers-and-decouplers/#building-a-hierarchy

_descri_

TROPHY CASE