concept NET in category akka

This is an excerpt from Manning's book Reactive Applications with Akka .NET.
Although Akka.NET itself and how it works might be new to many developers, its underlying principles have been in development for decades, in the form of the actor model. As part of the actor model, independent entities, known as actors, are responsible for performing work. You can have multiple different types of actors within a system, and each of these types can have multiple instances running in the system. Every actor runs independently of every other actor in the system, meaning that two running actors can’t directly interfere or interact with each other. Instead, each actor is supplied with a mailbox, which receives messages, and an address, which can be used to receive messages from other actors in the system. An actor sits idle and doesn’t do anything until a new message is received in the actor’s mailbox; at this point, the actor can process the message using its internal behavior. Its behavior is the brain of the actor and defines how it should respond to each message it receives. If an actor receives more than one message, the messages are queued up in the order in which they were received, and the actor processes each message sequentially. Each actor will only process a single message at a time, although multiple actors can process their respective messages at the same time. This allows you to create highly concurrent applications without having to concern yourself with the underlying multithreading infrastructure and code that’s typically required when developing concurrent applications. It’s important to note also that actors are completely isolated, meaning that any internal information or data owned by one actor isn’t accessible by anything other than that actor.
In the systems you’ve built so far, you’ve relied on Akka.NET to guarantee that a message is delivered; but such guarantees are nonexistent in Akka.NET as it simply follows the at-most-once delivery guarantee. This guarantee says that a message will be sent and passed through the system. But if the message gets lost at any stage in the pipeline, then the sender won’t receive any feedback about the failure. You hope that each message is only processed once, but this uncertainty can be a source of difficulties.
Figure 6.12 shows how you can assign tasks to a dedicated actor that’s responsible for performing the required work and communicating with an external service. In the event that an unexpected error is encountered, Akka.NET will process the failed actor. In a typical situation, this involves restarting the actor and hoping that the issue was transient. But, given that APIs are commonly billed based on the number of operations performed against them, you would shut down the actor calling the API if it encounters an exception caused by invalid text, because you know that this is an unrecoverable error.