ANNOUNCE: OMG! Akka 2.0-RC1 available!

Ladies and gentlemen,

We, the Akka committers, are proud to announce the availability of Akka 2.0 RELEASE CANDIDATE 1 — the next generation of Akka!

Building on the experiences from the Akka 1 series, we take Akka to the next level — resilience by default, scale up and out by configuration, extensibility by design and with a smaller footprint.


Highlights of Akka 2.0 RELEASE CANDIDATE 1:
* 26 tickets closed in 8 days (190 files changed, 3765 insertions(+), 2041 deletions(-))

 * Docs
   – Http documentation updated
   – Java documentation for 0MQ module
   – JMM docs regarding Akka Futures
   – Minor edits overall


 * Routing
   – Erronous resize resolved in Resizers


 * Dispatchers
   – BalancingDispatcher now has a config option for "attempt-teamwork"
   – BalancingDispatcher race condition resolved


 * Futures
   – Future.blocking() now has a Java API in Futures.blocking()
   – Future.blocking() now doesn't require an ExecutionContext


 * Config
   – Updated to latest HOCON version (configs are now Serializable)
   – Added setting for shutting down the JVM on fatal problems (jvm-exit-on-fatal-error)
   – Serializer config has changed to be more convenient for the best–effort search


Highlights of Akka 2.0 Milestone 4:


 * 57 tickets closed in 13 days. (447 files changed, 20231 insertions(+), 15202 deletions(-))


 * Docs
  – Akka now has 337 pages of documentation (vs. 305 in M3) Available both as html and as pdf.


 * Actor
   – Default dispatcher based on new ForkJoinPool destined for Java8, extremely better scalability.
   – ActorPath.fromString — easier creating of ActorPaths
   – Remove FSM Ev()


 * Futures
   – Brand new Java API supporting all operations on Future
   – Future.recoverWith — the "flatMap" of "recover"
   – Future.fallbackTo — the harmonized name of what was previously or/orElse
   – Promise.complete — now throws an IllegalStateException if already completed, use tryComplete for conditional complete
   – Future.andThen — makes it possible to create ordered asynchronous side effects
   – All callbacks are now friendlier to the type inferencer


 * Remote
   – Read timeout tracking now supports read timeouts, write timeouts and both, and can be turned off completely
   – No need to configure nodename anymore


 * Serialization
   – Serialization now supports best–effort lookup of suitable Serializer, see docs for more info


 * Misc
   – Better Android compatibility
   – Lots of minor bugfixes
   – Lots of small performance improvements
   – Reworked class loading strategy to be more unified



Highlights of Akka 2.0 Milestone 3:



 * Almost 90(!) tickets closed in 3 weeks. (505 files changed, 13617 insertions(+), 8636 deletions(-))


 * Docs – Akka now has 305 pages of documentation (vs. 254 in M2) Available both as html and as pdf.


 * Patterns
   – "Ask/?" being moved out to a Pattern" — for Scala add 'import akka.pattern.ask' (which will provide suitable implicit conversions to support nearly the same methods, check with 'import akka.migration.ask' first for deprecations; and for Java use akka.pattern.Patterns.ask().
   – gracefulStop
   – pipeTo


 * Actor
   – Removed timeout from Props
   – Removed FaultHandler from Props
   – Renamed FaultHandler to SupervisorStrategy to be more clear
   – Improved SupervisorStrategy creation and parametrization


* ActorSystem
  – ActorSystemImpl renamed to ExtendedActorSystem for Extensions
  – Now has awaitTermination
  – Can now be configured to only create threads that are daemons


 * TypedActor
   – TypedActorProps that is used with typedActorOf, instead of overloading
   – Possibility to proxy any ActorRef (think Remote etc)
 
 * Futures
   – "orElse" is replaced with "or"
   – "zip" has been added
   – Reduced memory footprint per Future


 * Remote
   – Support for starting up Akka on a randomly chosen port
   – Lots of optimizations


 * Akka STM
   – Now uses ScalaSTM instead of Multiverse directly


 * IOActor
   – Many improvements for 2.0


 * Routers
   – Custom Routers (create your own!)
   – Remote Routers, any Router can now be remote
   – Resizers, replaces the old Actor Pool API, add Resizer to Router to get Actor Pool functionality
   – Resizers, configure them in config file
   – Resizers, also usable from Java, so now there's a Java API for "Actor Pools"


 * ømq
   – This module is now ported from Akka 1.3 for Scala


 * Akka FSM
   – There is now documentation on how to use Akka FSM from Java!


 * Migration
   – We now have a draft of a migration package that will help you from 1.x to 2.0, try it out and give us feedback


And much, much more!




Highlights of Akka 2.0 Milestone 2:


* 70 closed tickets since M1


* More documentation, 254 pages vs 216 for M1
  – Serialization API
  – EventBus API
  – Agents
  – Dead Letters
  – General docs improvements


* More samples (Remoting etc)


* Remoting
  – Remote Death Watch
  – Improved logging
  – Improved performance
  – More configuration options


* Routers
  – Load from config
  – BroadcastRouter


* Decoupled Futures from Dispatchers, use any old ExecutorService or Executor


* Akka now uses Scala STM


* Improved Java APIs


* Many minor improvements, bugfixes and tweaks





Highlights of Akka 2.0 Milestone 1:


* Asynchronous by design — most actor related operations are now asynchronous


* Removing all global state — introducing ActorSystem


* Mandatory Parental Supervision — fault-tolerant default and automatic


* Remote Supervision — children spawned on other nodes are supervised


* Actor Tree Hierarchy — file-system like addressing, with wildcards etc.


* Props — Actor configuration is immutable, sharable and reusable


* Futures & Promises — simpler and more powerful, blocking API refactored out


* Actor Routing — completely revamped, load balancing made much simpler


* Death Watch — react to the death of any actor


* Typed Actors — 0 dependency JDK Proxy based implementation


* EventBus API — publish-subscribe to anything you want


* Extensions — add new functionality to Akka


* Pluggable remote transport layer — Netty/TCP built–in


* General API unification and simplification — less to remember


* Simpler actor life-cycle semantics and management


* Slimmer footprint — around 2.7 million Actors per GB of memory


* Lots of performance and scalability improvements





Akka is released under the Apache V2 license.

Akka website: http://akka.io

Akka Maven repository: http://akka.io/releases

Akka binary distribution: http://akka.io/downloads

Akka 2.0-RC1 documentation: http://akka.io/docs/akka/2.0-RC1/

Issue tracker: http://www.assembla.com/spaces/akka/milestones/1016783-2-0-rc1

Akka mailing list: https://groups.google.com/group/akka-user


Happy hAkking!

√