Akka Interview

We’ve added tons of new features since 0.10

Jessica Thornsby

JAXenter speaks to Viktor Klang on the latest release of the Akka platform.

Akka is one step closer to a 1.0 release, with the announcement
of Akka
1.0 RC3
. JAXenter caught up with Akka product owner Viktor
Klang, to find out more about the platform and its latest

JAXenter: Akka 1.0 RC3 features a refactored
Remote-API. What benefits does this
offer the user?

Viktor Klang: The new remote API has an
increased amount of feature discoverability by providing a single
point of access to all things remotely interesting: Actor.remote.*
(API for Scala) or Actors.remote().* (API for Java, Groovy, JRuby
etc). What we’ve also done with the new Remote API is to make the
transport layer pluggable, so we have a possibility to create
transport layers based on AMQP, 0MQ, JMS that can be plugged in
without changing user code.

JAXenter: What functionality is planned for the
upcoming 1.0 release?

Viktor Klang: We believe that Akka has been a
> 1.0 project in terms of reliability for quite a long time,
with production usage for more than a year in several places. But
for 1.0 release we wanted to make sure that the APIs are solid,
works for both Java and Scala and that we have set a good
foundation for future evolution.

We’ve added tons of new features since 0.10 but some of the more
notable are:

1) Akka-mist – a bridge between Servlet 3.0/Jetty Continuations
and Actors for high-performance asynchronous web services.
2) Akka-persistence has gained support for – HBase, Voldemort,
CouchDB, SimpleDB, Memcached, Membase, Terrastore, Riak as well as
improving support for the already existing ones like, Redis,
MongoDB, Cassandra.
3) Akka-FSM – a Finite State Machine API&DSL for Actors.
4) Akka now uses Scala 2.8.1 (which is backwards compatible with
2.8.0) and our releases are compiled with -optimise.
5) We have added support for onCompletion-listeners for Future,
which makes it possible to avoid doing any blocking when dealing
with Futures.
6) Session-bound remote actors – it is now possible to register
server-managed remote actors that will be created one per incoming
7) Remote actor security – you may now use Erlang-style shared
cookies to authenticate inbound connections from other nodes.
8) An even better integration with the awesome Multiverse STM, with
a big improvement of Transactors.

And that’s all in the ApacheV2-licensed open source project. On
top of that we have a commercial product called Akka-cloud which
provides the following features:

1) Dynamically clustered ActorRegistry with both automatic and
manual migration of actors.
2) Cluster membership and cluster event subscriptions.
3) Durable actor mailboxes of different sizes and shapes –
file-backed, Redis-backed, ZooKeeper-backed, Beanstalkd-backed and
with AMQP and JMS-based in the works.
4) Monitoring influenced by Dapper for cross-machine message
tracing and JMX-exposed statistics.

JAXenter: What features can the Akka platform
offer, over the competition?

Viktor Klang: Akka is an unified runtime and
programming model for:

- Scale up (Concurrency)
– Scale out (Remoting)
– Fault tolerance

One thing to learn and admin, with high cohesion and coherent
semantics. Akka is a very scalable piece of software, not only in
the performance sense, but in the size of applications it is useful
for. The core of Akka, akka-actor, is very small and easily dropped
into an existing project where you need asynchronicity and lockless
concurrency without hassle.

You can choose to include only the parts of akka you need in
your application and then there’s the whole package, the Akka
Microkernel, which is a standalone container to deploy your Akka
application in.

With CPUs growing more and more cores every cycle, Akka is the
alternative that provides outstanding performance even if you’re
only running it on one machine. Akka also supplies a wide array of
concurrency-paradigms, allowing for users to choose the right tool
for the job.

The integration possibilities for Akka Actors are immense
through the Apache Camel integration, and the Persistence module
has support for nearly all different noSQL
stores. We provide Software Transactional Memory concurrency
control through the
excellent Multiverse project, and have integrated that with Actors
and the Persistence module, creating Transactors for coordinated
concurrent transactions that can optionally store state in any of
our supported persistence stores, we have Agents and Dataflow
concurrency as well.

JAXenter: Can you give us an example use case
for Akka?

Viktor Klang:(Web, Cloud, Application) Services
– Actors lets you manage service
failures (Supervisors), load management (back-off strategies,
timeouts and processing-isolation), both horizontal and vertical
scalability (add more cores and/or add more machines). Think
payment processing, invoicing, order matching, datacrunching,
messaging. Really any highly transactional systems like banking,
betting, games. See what some of the Akka users have to say about how
they are using Akka.

comments powered by Disqus