Librería Portfolio

When it comes to big data processing, we can no longer ignore concurrency or try to add it in after the fact. Fortunately, the solution is not a new paradigm of development, but rather an old one. With this hands-on guide, Java and Scala developers will learn how to embrace concurrent and distributed applications with the open source Akka toolkit. You'll learn how to put the actor model and its associated patterns to immediate and practical use.

Throughout the book, you'll deal with an analogous workforce problem: how to schedule a group of people across a variety of projects while optimizing their time and skillsets. This example will help you understand how Akka uses actors, streams, and other tools to stitch your application together.

Model software that reflects the real world with domain-driven design
Learn principles and practices for implementing individual actors
Unlock the real potential of Akka with patterns for combining multiple actors
Understand the consistency tradeoffs in a distributed system
Use several Akka methods for isolating and dealing with failures
Explore ways to build systems that support availability and scalability
Tune your Akka application for performance with JVM tools and dispatchers



Chapter 1The Actor Model
Reality Is Eventually Consistent
Deconstructing the Actor Model
All Computation Is Performed Within an Actor
Actors Can Communicate Only Through Messages
Actors Can Create Child Actors
Actors Can Change Their State or Behavior
Everything Is an Actor
Uses of the Actor Model
Defining Clear Boundaries
When Is the Actor Model Appropriate?
Conclusion
Chapter 2Introducing Akka
What Is Akka?
Akka Components
Akka's Implementation of the Actor Model
Akka's Actors in the Actor Model
The Akka Typed Project
Conclusion
Chapter 3Distributed Domain-Driven Design
DDD Overview
The Benefits of DDD
Components of DDD
Domain Entities
Domain Value Objects
Aggregates and Aggregate Roots
Repositories
Factories and Object Creation
Domain Services
Bounded Contexts
Conclusion
Chapter 4Good Actor Design
Starting Small
Encapsulating State in Actors
Ask Pattern and Alternatives
Commands Versus Events
Conclusion
Chapter 5Good Data Flow
Throughput Versus Latency
Streams
Routers
Mailboxes
Work Pulling
Back Pressure
Akka Streams
Conclusion
Chapter 6Consistency and Scalability
Transactions and Consistency
Strong Versus Eventual Consistency
Concurrency Versus Parallelism
Why Globally Consistent Distributed State Doesn't Scale
Location Transparency
Delivery Guarantees
Scalability
Cluster Sharding and Consistency
Conclusion
Chapter 7Fault Tolerance
Types of Failures
Isolating Failures
Dealing with Failures
Chapter 8Availability
Microservices Versus Monoliths
Bounded Contexts as Microservices
Fine-Grained Microservices
Cluster-Aware Routers
Distributed Data
Graceful Degradation
Deployment
Staged Deployment/Rolling Restarts
Blue/Green Deployment
Crash Recovery/Operational Monitoring
Conclusion
Chapter 9Performance
Isolating Bottlenecks
Tuning Akka
Dispatchers
Conclusion