We've added tons of new features since 0.10
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 release.
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 connection.
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.