Introduction
Welcome to Akka, a set of open-source libraries for designing scalable, resilient systems that span processor cores and networks. Akka allows you to focus on meeting business needs instead of writing low-level code to provide reliable behaviour, fault tolerance, and high performance.
Many common practices and accepted programming models do not address important challenges inherent in designing systems for modern computer architectures. To be successful, distributed systems must cope in an environment where components crash without responding, messages get lost without a trace on the wire, and network latency fluctuates. These problems occur regularly in carefully managed intra-data center environments - even more so in vitalized architectures.
To help you deal with these realities, Akka provides:
• Multi-threaded behaviour without the use of low-level concurrency constructs like atomics or locks — relieving you from even thinking about memory visibility issues.
• Transparent remote communication between systems and their components — relieving you from writing and maintaining difficult networking code.
• A clustered, high-availability architecture that is elastic, scales in or out, on demand — enabling you to deliver a truly reactive system.
Akka’s use of the actor model provides a level of abstraction that makes it easier to write correct concurrent, parallel and distributed systems. The actor model spans the full set of Akka libraries, providing you with a consistent way of understanding and using them. Thus, Akka offers a depth of integration that you cannot achieve by picking libraries to solve individual problems and trying to piece them together.
By learning Akka and how to use the actor model, you will gain access to a vast and deep set of tools that solve difficult distributed/parallel systems problems in a uniform programming model where everything fits together tightly and efficiently.
How to get started
If this is your first experience with Akka, we recommend that you start by running a simple Hello World project. See the Quickstart Guide for instructions on downloading and running the Hello World example. The Quickstart guide walks you through example code that introduces how to define actor systems, actors, and messages as well as how to use the test module and logging. Within 30 minutes, you should be able to run the Hello World example and learn how it is constructed.
History
An actor implementation, written by Philipp Haller, was released in July 2006 as part of Scala 2.1.7. By 2008 Scala was attracting attention for use in complex server applications, but concurrency was still typically achieved by creating threads that shared memory and synchronized when necessary using locks. Aware of the difficulties with that approach and inspired by the Erlang programming language's library support for writing highly concurrent, event-driven applications, Jonas Bonér created Akka to bring similar capabilities to Scala and Java. Bonér began working on Akka in early 2009 and wrote up his vision for it in June of that year. The first public release was Akka 0.5, announced in January 2010. Akka is now part of the Lightbend Platform together with the Play framework and the Scala programming language.
Distinguishing Features
The key points distinguishing applications based on Akka actors are:
• Concurrency is message-based and asynchronous: typically no mutable data are shared and no synchronization primitives are used; Akka implements the actor model.
• The way actors interact is the same whether they are on the same host or separate hosts, communicating directly or through routing facilities, running on a few threads or many threads, etc. Such details may be altered at deployment time through a configuration mechanism, allowing a program to be scaled up (to make use of more powerful servers) and out (to make use of more servers) without modification.
• Actors are arranged hierarchically with regard to program failures, which are treated as events to be handled by an actor's supervisor (regardless of which actor sent the message triggering the failure). In contrast to Erlang, Akka enforces parental supervision, which means that each actor is created and supervised by its parent actor.
Akka has a modular structure, with a core module providing actors. Other modules are available to add features such as network distribution of actors, cluster support, Command and Event Sourcing, integration with various third-party systems (e.g. Apache Camel, ZeroMQ), and even support for other concurrency models such as Futures and Agents.
Project Structure
Viktor Klang became the technical lead for the Akka project in September 2011. When Viktor became Director of Engineering at Lightbend in December 2012, Roland Kuhn became the technical lead for Akka. The main part of the development is done by a core team employed at Lightbend, supported by an active community.[10] The current emphasis is on extending cluster support.
Relation to other Libraries
Other frameworks and toolkits have emerged to form an ecosystem around Akka:
• The Spray toolkit[11] is implemented using Akka and features a HTTP server as well as related facilities, such as a DSL for creating RESTful APIs
• The Play framework for developing web applications offers integration with Akka
• Apache Spark is built upon Akka
• The Socko Web Server library supports the implementation of REST APIs for Akka applications
• The event sourced library provides Event-driven architecture (see also domain-driven design) support for Akka actors
• The Gatling stress test tool for load-testing web servers is built upon Akka
• The Scalatra web framework is built upon Akka and offers integration with it
• The Vaadin web app development framework can integrate with Akka
• The Apache Flink platform for distributed stream and batch data processing is built upon Akka.
Akka actors are considered an integral part of the Scala standard library. There are more than 250 public projects registered on GitHub which use Akka.
Posted on Utopian.io - Rewarding Open Source Contributors