Akka (toolkit)

Short description: Open-source runtime

Akka

Original author(s)| Jonas Bonér
Developer(s)| Lightbend
Initial release| July 2009 (2009-07)
Stable release|

2.9.1 / December 19, 2023; 2 years ago (2023-12-19)[1]

Written in| Scala
Operating system| Cross-platform
Platform| Java Virtual Machine
License| multiple
Website| akka.io

Akka is a source-available toolkit and runtime simplifying the construction of concurrent and distributed applications on the JVM. Akka supports multiple programming models for concurrency, but it emphasizes actor-based concurrency, with inspiration drawn from Erlang.[2]

Language bindings exist for both Java and Scala. Akka is written in Scala and, as of Scala 2.10, the actors in the Scala standard library are deprecated in favor of Akka.[3]

## Contents

* 1 History
* 2 Distinguishing features
* 3 Project structure
* 4 Relation to other libraries
* 5 Publications about Akka
* 6 References
* 7 External links

## History

An actor implementation, written by Philipp Haller, was released in July 2006 as part of Scala 2.1.7.[4] 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, the Swedish programmer Jonas Bonér created Akka to bring similar capabilities to Scala and Java. Bonér began working on Akka in early 2009[5] and wrote up his vision for it in June of that year.[6] The first public release was Akka 0.5,[7] announced in January 2010.[8] Akka is now part of the Lightbend Platform together with the Play framework and the Scala programming language.

In September 2022, Lightbend announced that Akka would change its license from the free software license Apache License 2.0 to a proprietary source-available license, known as the Business Source License (BSL). Any new code under the BSL would become available under the Apache License after three years.[9]

## 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,[10] supported by an active community.[11] 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[12] is implemented using Akka and features a HTTP server as well as related facilities, such as a domain-specific language (DSL) for creating RESTful APIs
* The Play framework for developing web applications offers integration with Akka[13]
* Up until version 1.6, Apache Spark used Akka for communication between nodes[14]
* The Socko Web Server library supports the implementation of REST APIs for Akka applications[15]
* The eventsourced[16] 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[17]
* The Scalatra web framework offers integration with Akka.[18]
* The Vaadin web app development framework can integrate with Akka[19]
* The Apache Flink (platform for distributed stream and batch data processing) RPC system is built using Akka [20] but isolated since v1.14.[21]
* The Lagom framework for building reactive microservices is implemented on top of Akka.[22]

There are more than 250 public projects registered on GitHub which use Akka.[23]

## Publications about Akka

There are several books about Akka:

* Akka Essentials[24]
* Akka Code Examples
* Akka Concurrency[25]
* Akka in Action, Second Edition[26]
* Akka in Action[27]
* Effective Akka[28]
* Composable Futures with Akka 2.0, Featuring Java, Scala and Akka Code Examples[29]

Akka also features in:

* P. Haller's "Actors in Scala"[30]
* N. Raychaudhuri's "Scala in Action"[31]
* D. Wampler's "Functional Programming for Java Developers"[32]
* A. Alexander's "Scala Cookbook"[33]
* V. Subramaniam's "Programming Concurrency on the JVM"[34]
* M. Bernhardt's "Reactive Web Applications"[35]

Besides many web articles that describe the commercial use of Akka,[36][37] there are also overview articles about it.[38][39]

## References

1. ↑ Akka Team. "Akka 23.10 Released". https://akka.io/blog/news/2023/10/31/akka-23.10-released.
2. ↑ Akka Team. "Scala Actors Introduction". https://doc.akka.io/docs/akka/current/actors.html#introduction. Retrieved 17 September 2018.
3. ↑ Jovanovic, Vojin. "The Scala Actors Migration Guide". http://docs.scala-lang.org/overviews/core/actors-migration-guide.html. Retrieved 13 March 2013.
4. ↑ "Scala Version History - Older versions". scala-lang.org. 2009-02-16. Archived from the original on 2013-01-04. https://web.archive.org/web/20130104213121/http://www.scala-lang.org/node/156.
5. ↑ Jonas Bonér (2009-02-16). "init project setup". github.com. https://github.com/akka/akka/commit/0a31ad718883ef0314de6dc8c6c2c9699eadfdae.
6. ↑ Bonér, Jonas. "Akka Actor Kernel". scala-language@googlegroups.com. http://permalink.gmane.org/gmane.comp.lang.scala/16486.
7. ↑ Jonas Bonér (2009-07-12). "v0.5". github.com. https://github.com/akka/akka/tree/v0.5.
8. ↑ Jonas Bonér (2010-01-04). "Introducing Akka - Simpler Scalability, Fault-Tolerance, Concurrency & Remoting through Actors". jonasboner.com. http://jonasboner.com/introducing-akka/.
9. ↑ Bonér, Jonas. "Why We Are Changing the License for Akka". https://www.lightbend.com/blog/why-we-are-changing-the-license-for-akka.
10. ↑ "Akka team". akka.io. http://akka.io/team/. Retrieved 6 June 2013.
11. ↑ "Akka contributors list". github.com. https://github.com/akka/akka/contributors. Retrieved 6 June 2013.
12. ↑ Doenitz, Mathias. "Spray toolkit". spray.io. http://spray.io/. Retrieved 6 June 2013.
13. ↑ "Play framework documentation: Integrating with Akka". playframework.com. http://www.playframework.com/documentation/2.0/JavaAkka. Retrieved 6 June 2013.
14. ↑ "Spark project sources". github.com. https://github.com/apache/spark. Retrieved 6 June 2013.
15. ↑ "Socko Web Server". sockoweb.org. http://sockoweb.org/. Retrieved 6 June 2013.
16. ↑ "eventsourced library". eligosource. https://github.com/eligosource/eventsourced. Retrieved 6 June 2013.
17. ↑ "Gatling stress test tool". github.com. https://github.com/excilys/gatling/wiki/Underlying-Technologies. Retrieved 6 June 2013.
18. ↑ "Akka - Scalatra". scalatra.org. https://scalatra.org/guides/2.8/async/akka.html. Retrieved 2022-10-06.
19. ↑ "Vaadin in Akka". Vaadin.com. https://vaadin.com/blog/-/blogs/vaadin-in-akka. Retrieved 26 April 2014.
20. ↑ "Apache Flink - Akka for the win !". flink.apache.org. https://cwiki.apache.org/confluence/display/FLINK/Akka+and+Actors. Retrieved 2 December 2015.
21. ↑ "Apache Flink: Scala Free in One Fifteen". 22 February 2022. https://flink.apache.org/2022/02/22/scala-free.html.
22. ↑ "Lagom - Integrating with Akka". https://www.lagomframework.com/documentation/1.4.x/java/Akka.html.
23. ↑ Tasharofi, Samira. "Akka actor project corpus at GitHub". cs.illinois.edu. http://actor-applications.cs.illinois.edu/akka.html.
24. ↑ Gupta, Munish K. (2012). Akka Essentials. Packt Publishing. pp. 334. ISBN 978-1849518284. http://www.packtpub.com/akka-java-applications-essentials/book.
25. ↑ Wyatt, Derek (2013). Akka Concurrency. Artima. pp. 521. ISBN 978-0981531663.
26. ↑ Lopez-Sancho Abraham, Francisco (2023). Akka in Action, Second Edition. Manning Publications. pp. 400. ISBN 978-1617299216.
27. ↑ Roestenburg, Raymond (2013). Akka in Action. Manning Publications. pp. 475. ISBN 978-1617291012.
28. ↑ Allen, Jamie (2013). Effective Akka. O'Reilly Media. pp. 74. ISBN 978-1449360078.
29. ↑ Slinn, Michael (2012). Composable Futures with Akka 2.0. Micronautics Research. pp. 178. ISBN 978-0984278923.
30. ↑ Haller, Philipp (2012). Actors in Scala. Artima. pp. 169. ISBN 978-0981531656.
31. ↑ Raychaudhuri, Nilanjan (2013). Scala in Action. Manning Publications. pp. 416. ISBN 978-1935182757.
32. ↑ Wampler, Dean (2011). Functional Programming for Java Developers. O'Reilly Media. pp. 90. ISBN 978-1449311032. https://archive.org/details/functionalprogra0000wamp/page/90.
33. ↑ Alexander, Alvin (2013). Scala Cookbook. O'Reilly Media. pp. 722. ISBN 978-1449339616.
34. ↑ Subramaniam, Venkat (2011). Programming Concurrency on the JVM: Mastering Synchronization, STM, and Actors. Pragmatic Bookshelf. pp. 280. ISBN 978-1934356760. https://archive.org/details/programmingconcu00subr_404.
35. ↑ Bernhardt, Manuel (2016). Reactive Web Applications: Covers Play, Akka and Reactive Streams. Manning Publications. pp. 328. ISBN 9781633430099.
36. ↑ Darrow, Barb (25 June 2012). "Juniper networks signs on with Scala". gigaom.com. http://gigaom.com/2012/06/25/typesafe-pushes-scala-as-top-language-juniper-apparently-agrees/. Retrieved 8 June 2013.
37. ↑ Ross, David. "Scaling the Klout API with Scala, Akka and Play". http://corp.klout.com/blog/2012/10/scaling-the-klout-api-with-scala-akka-and-play/. Retrieved 8 June 2013.
38. ↑ Haines, Stephen (2013-05-08). "Open source Java projects: Akka". JavaWorld. https://www.infoworld.com/article/2078775/open-source-java-projects-akka.html. Retrieved 2020-07-15.
39. ↑ "Java Magazin 6.13". jaxenter.de. Archived from the original on 13 August 2013. https://web.archive.org/web/20130813144520/https://jaxenter.de/magazines/Java-Magazin-613. Retrieved 8 June 2013.

## External links

* Official website for Akka

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Akka (toolkit). Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Software:Akka_(toolkit)&oldid=673827"