Effective Akka (Paperback)

content<div><p>Avoid common mistakes when building distributed, asynchronous, high-performance software with the Akka toolkit and runtime. With this concise guide, author Jamie Allen provides a collection of best practices based on several years of using the actor model. The book also includes examples of actor application types and two primary patterns of actor usage, the Extra Pattern and Cameo Pattern. </p><p> Allen, the Director of Consulting for Typesafe—creator of Akka and the Scala programming language—examines actors with a banking-service use case throughout the book, using examples shown in Akka and Scala. If you have any experience with Akka, this guide is essential. </p><ul><li>Delve into domain-driven and work-distribution actor applications </li><li>Understand why it’s important to have actors do only one job </li><li>Avoid thread blocking by allowing logic to be delegated to a Future </li><li>Model interactions as simply as possible to avoid premature optimization </li><li>Create well-defined interactions, and know exactly what failures can occur </li><li>Learn why you should never treat actors as you would an ordinary class </li><li>Keep track of what goes on in production by monitoring everything </li><li>Tune Akka applications with the Typesafe Console </li></ul></div>sourceProduct Descriptioncontent<div class="aplus"> <h4>Q&A with Jamie Allen, author of "Effective Akka: Patterns and Best Practices"</h4> <p><strong>Q. Why is this an important book for people to read now</strong></p> <p>A. The advent of the many-core platform means that developers have more processing resources in the form of "cores" at their disposal than ever before. Traditional programming constructs do not allow developers to leverage these cores. As computers add more and more cores with each new platform released by hardware manufacturers, developers will need to find ways to maximize the utilization of these resources. Akka provides a platform for doing just that, and allowing your application to scale up and out as more resources become available.</p> <p><strong>Q. What will readers walk away with after reading "Effective Akka?"</strong></p> <p>A. After reading "Effective Akka," readers should have a firm grasp of the kinds of coding issues they may encounter when developing with actors, regardless of whether they're using Scala/Akka or Erlang. Many of the concepts are relevant to developers who are writing asynchronous code without actors as well. Effective Akka provides guidance with respect to coding style and best practices so that developers are able to avoid common pitfalls. </p> <p><strong>Q. What's so exciting and important about patterns and best prices?</strong></p> <p>A. The move to "reactive" solutions. Developers can perform much more work nowadays by using asynchrony-- not wasting threads that spawn blocking operations, instead defining work that can be applied automatically when such work is completed. Many technologies are emerging in this space, such as ReactiveJava, Node.js, Go, Clojure's core.async and Scala's futures, actors and async support. Never before have developers had so many useful tools at their disposal to write applications that are interactive, low-latency, fault tolerant, and scalable. Every language and platform is looking to provide a solution in this space. </p> <p><strong>Q. Can you give us a few tips when building high-performance software with Akka?</strong></p> <p><ol><li>Be very careful about closing over state from outside of a code block. Capture and stabilize such state by placing it into local values so that you know you will have an unchanged value at the time you actually need it.</li> <li>Keep your code simple. Make more atomic methods and functions that do only one thing, and combine them to accomplish your goals.</li> <li>Never reference the keyword "this" from inside an actor. Don't use it and don't register it elsewhere. Pretend the concept does not exist, where possible. Learn to think in terms of "ActorRef" and use them at all times, even when communicating with yourself.</li> <li>Create failure zones in your application by assigning thread pool resources to specific groups of actors. This way, if one actor is monopolizing a thread with a computationally-intense activity, only a limited subset of other actors are affected by not having that resource available to them.</li> <li>Avoid blocking as much as possible. Always write code to be asynchronous unless there is a specific block of code where blocking must occur. Put any such blocking tasks on their own threads, or use Scala's Managed Blocking to keep other resources from being starved of a thread.</li> </ol></p> </div>sourceAmazon.com Review