Externally indexed torrent

If you are the original uploader, contact staff to have it moved to your account

Textbook in PDF format

Use Akka to solve the big problems of distributed systems—from multithreading and concurrency, to handling scalability and failure.
In Akka in Action, Second Edition you will learn how to:
Create basic programs with Akka
Work with clusters to build robust, fault tolerant programs
Create and maintain distributed state with strong consistency guarantees
Build microservices with Akka
Utilize concurrency and parallelism
Test Akka software
Akka in Action, Second Edition teaches you to use the latest version of Akka to solve common problems of distributed systems. Akka contributor Francisco Lopez-Sancho demonstrates Akka’s complex concepts through real-world use cases, including clustering, sharding, persistence, and deploying to Kubernetes. Discover the power of the Actor model, and how to leverage most of the Akka modules to create microservices that are reliable and fault tolerant.
Up until the middle of the ’90s, just before the internet revolution, it was completely normal to build applications that would only ever run on a single computer, a single CPU. If an application wasn’t fast enough, the standard response would be to wait for a while for CPUs to get faster no need to change any code. Problem solved. Programmers around the world were having a free lunch, and life was good. In 2005 Herb Sutter wrote in Dr. Dobb’s Journal about the need for a fundamental change. In short: a limit to increasing CPU clock speeds has been reached, and the free lunch is over. Around the year 2005 when Herb Sutter wrote this excellent article, you’d find companies running applications on clustered multiprocessor servers (often no more than two to three, just in case one of them crashed). Support for concurrency in programming languages was available but limited and considered black magic by many mere mortal programmers. Herb Sutter predicted in his article that “programming languages ... will increasingly be forced to deal well with concurrency.”
Let’s see what changed since then! Fast-forward to today, and you find applications running on large numbers of servers in the cloud, integrating many systems across many data centers. The ever-increasing demands of end users push the requirements of performance and stability of the systems that you build. Concurrency is now prevalent, and it is here to stay.
But support for concurrency in most programming languages, especially on the JVM, has hardly changed. Although the implementation details of concurrency APIs have definitely improved, you still have to work with low-level constructs like threads and locks, or fibers. Threads are notoriously difficult to work with and fibers - lightweight threads - still force you to think in low-level constructs like await, interrupt and join. Concurrency is a means to achieve scalability: the premise is that, if needed, more CPUs can be added to servers, which the application then automatically starts making use of. It’s the next best thing to a free lunch. Scalability is the measure to which a system can adapt to a change in demand for resources, without negatively impacting performance.
Akka gives you a single abstraction to deal with concurrency and scalability--the Actor Model, which is coherent semantics that let you work on your business logic without worrying about whether your program needs to run on a thousand servers or just one. about the technology
Akka is a toolkit of libraries that make it easy to implement distributed applications in Scala and Java. Akka’s Actor model avoids many of the complexities of multithreading, while making systems elastic and resilient, and provides strong consistency.
about the book
Akka in Action, Second Edition is a practical guide to building message-oriented systems with Akka. Extensively revised by Akka contributor and consultant Francisco Lopez-Sancho, this upgraded second edition comes with new coverage of Akka typed, microservices architecture, and more. You’ll learn how to build with Akka actors and why they’re the perfect solution for distributed systems. Driven by practical examples, this book is the perfect guide to creating elastic, resilient, and reactive software with Akka.
Introducing_Akka
Up_and_running
One_actor_is_no_actor
Akka_test_kit
Fault_tolerance
Discovery_and_routing
Configuration
Clustering
Sharding_and_persistence
Streams,_persistence_query_and_projections
Akka_Ports
Akka_betting_house
Clustering_II
Appendix_A._Setting_up
Appendix_B._Akka_Microservices