Introduction of nyssr.net

The Actor Modell

nyssr.net implements the Actor Model for operating a Wide Area Mesh Network. The Targets (or Actors) communicate 100% asynchronously via messages. These messages are sent to other Targets, which may be very far away, using dynamic, latency-based routing.

Wide Area Mesh Net

Unlike in small local Actor Networks, only neighboring Nodes are directly connected in this Mesh Network. The network can contain a huge number of Nodes. The links between the individual Nodes are maintained permanently.

Dynamic, Latency-based Routing

Messages to distant Targets are forwarded from Node to Node via dynamic, latency-based routing. They always take the fastest route to the destination. Network changes are taken into account at every single hop.

Nodes

A nyssr.net node is a Java micro-kernel that can load hundreds of plugins at startup. Nodes are small (1.4 MBytes), start quickly (200 ms) and can be executed in any number on a computer or in containers.

Services

Plugins contain local services (based on interfaces), microservices (services for the network) and nanoservices (services that only process one message type).

High-performance communication

The asynchronous messaging between nodes is optimized for speed and data efficiency. Therefore, nodes can operate off the main data highways.

Microservice resolution

Services are found automatically. Each microservice has a unique ID. A message to a microservice that has this ID in the header is automatically delivered to the service, regardless of which node the service is running on.

Load balancing

The same microservice can be used simultaneously on different nodes. The system automatically distributes the load across the instances. The same applies to applications and UI dialogs.

Like one big system

nyssr.net is designed to manage a large number of small services. Thanks to the automatic service resolution and lightning-fast communication, you will not experience any performance disadvantages, neither during development nor during operation.

No configuration

You can only control and use thousands of microservices if no configuration is necessary. The microservices only need to be present in the network.

No code sharing

Generally, no source code is shared between service providers and service consumers. This avoids dependencies on shared interfaces and eliminates the need to upgrade all services simultaneously to a new level.

100% Asynchronous Design

Everything in nyssr.net is designed with an asynchronous architecture: nodes, messages, applications, and UI. As a developer, you only respond to events. Only the internal services within nodes remain partially interface-based.

Peer-to-peer

The nyssr.net network monitors itself. All links are continuously monitored. If a node fails or new nodes are added, all other nodes are automatically notified. Broadcasts are used to automatically distribute important events.

Maximum scaling

A node network can scale as required. Additional nodes can be added during operation. We do not scale monoliths but asynchronous services.

Maximum resilience

You can operate everything redundantly: Nodes, services, UI components. If a link fails, the messages use a different route. If a node fails, the other nodes and service instances survive.

Work scaling

Host UI dialogs where the team works. The team can monitor the nodes and intervene if necessary. It can independently distribute new versions and drive further development.