I read the Akka documentation about actors and streams abstraction and I
found it very enlightening and fascinating. The only aspect that I did not
completely understood is what is the best approach to deal with massive
states within actors.
Let’s say I have a client application that shows all visible assets of a
given type (e.g. connected products or sensors of some kind) for the
currently logged-in user. The list of visible assets could be seen as the
state of a persistent actor that manages the lifecycle of the assets for
specific user / tenant. Now, this state is potentially very big and it
could contains tens of thousands entries (i.e. tens of thousands of
assets). If I got it right, this actor could be seen as a projection of a
underlying event store that shows the list of user accessible machines. My
1. Is this a suitable use case for Akka? Or Akka assumes that the state
associated with an actor is small in size and lightweight?
2. The snapshots generated by the actor could be quite big: is this a
concern in terms of serialisation to and from the underlying snapshot
3. To solve snapshots ser/deser overhead one could avoid them all together.
But in this case the portion of the journal that is used by the actor
increases indefinitely. In this case I wonder what is the cost of
I understand that there are a lot of "it depends" answers for these
questions, but I would like to get the right principles to apply when
dealing with these scenarios in Akka and the potential pitfalls.
>>>>>>>>>> Read the docs: http://akka.io/docs/
>>>>>>>>>> Check the FAQ:
>>>>>>>>>> Search the archives: https://groups.google.com/group/akka-user
You received this message because you are subscribed to the Google Groups "Akka
User List" group.
To unsubscribe from this group and stop receiving emails from it, send an email
To post to this group, send email to email@example.com.
Visit this group at https://groups.google.com/group/akka-user.
For more options, visit https://groups.google.com/d/optout.