What is the difference between Typed and UnTyped Actors in Akka? When to use what?

Question

I have tried to read the Akka documentation to find out the exact difference between Typed and Untyped actors. When to use what? I am not sure what I\'m missing. Can somebody po

Answer 1

Akka untyped actors "do not compose" and "are not usefully typed".

This defeats the very reason we use Scala: it's functional programming power. See http://noelwelsh.com/programming/2013/03/04/why-i-dont-like-akka-actors/ for in depth on this mindset.

Also, see attempts to improve this in Scala to match the Haskell way.

http://letitcrash.com/post/40198993865/makkros-first-step-towards-typed-channels http://letitcrash.com/post/45188487245/the-second-step-akka-typed-channels

Seems to still be experimental in Akka or even dropped - not clear.

This idea of typed channels makes a lot of sense because similar issues occur when one tries to build type checked data (analytics) pipelines.

Akka Typed seems to be a great evolution to a safer programming model: https://opencredo.com/akka-typed/

Answer 2

Actors (Untyped)

For actors (Scala) to receive messages, they must mixin the Consumer trait. For example, the following actor class (Consumer1) implements the endpointUri method, which is declared in the Consumer trait, in order to receive messages from the file:data/input/actor Camel endpoint. Untyped actors (Java) need to extend the abstract UntypedConsumerActor class and implement the getEndpointUri() and onReceive(Object) methods.

Actors (Typed)

Typed actors can also receive messages from Camel endpoints. In contrast to (untyped) actors, which only implement a single receive or onReceive method, a typed actor may define several (message processing) methods, each of which can receive messages from a different Camel endpoint. For a typed actor method to be exposed as Camel endpoint it must be annotated with the @consume annotation. For example, the following typed consumer actor defines two methods, foo and bar.

Reference

Answer 3

Untyped actors respond to messages sent, while typed actors respond to method calls(the parameter values are the messages).

Typed Actor Model is used in order to define strict contracts for actors that can respond to only the predefined set of messages. In this case, every message need not be encapsulated as one object; typed actors allow us to define separate methods that accept multiple inputs as defined by the contract. In Java parlance, typed actors provide the Java interface in the object-oriented world.[1]

[1] Akka Essentials

Answer 4

UntypedActor is simply the name for Actor but as the Java API.

Here are some links to documentation:

Java:

• http://akka.io/docs/akka/1.2/java/typed-actors.html
• http://akka.io/docs/akka/1.2/java/untyped-actors.html

Scala:

• http://akka.io/docs/akka/1.2/scala/typed-actors.html
• http://akka.io/docs/akka/1.2/scala/actors.html

The difference is that TypedActors have a static interface, and the invocations of the methods on that interface is transformed into message sends. UntypedActors can receive any message.

Hope that helps.

Cheers, √