Harness reactive programming to build scalable and fault-tolerant distributed systems using Scala and Akka
About This Book
- Use the concepts of reactive programming to build distributed systems running on multiple nodes
- Get to grips with the full range of Akka features including the upcoming and cutting edge experimental modules
- A comprehensive coverage of the principles of FRP with real-world use cases to solve scalability issues
Who This Book Is For
If you are a developer who is passionate about building fault-tolerant, scalable distributed applications using Scala and Akka, then this book will give you a jump start. You should be familiar with Scala, but no prior knowledge of Akka and reactive programming is required.
What You Will Learn
- Explore functional programming using Scala
- Design an asynchronous, non-blocking shopping cart application using Futures
- Understand the Akka actor model and the relationship between actors and threads
- Use the Actor Supervision feature to build a fault tolerant and resilient application
- Create your own distributed system framework using an Akka cluster
- Take a look under the hood to gain perspective on the Akka engine
- See a comprehensive case study of a key value store with concurrent reads and writes
- Model a finite state machine using state-driven actors
Today’s web-based applications need to scale quickly to tackle the demands of modern users. Reactive programming is the solution developed to ensure the fault tolerant and robust scaling that is essential for professional applications. Reactive programming in Scala and Akka provides a great platform to develop low latency resilient, concurrent Internet scale applications on the Java Virtual Machine.
This comprehensive guide will help you get to grips with the concepts of reactive programming in order to build a robust distributed system in Scala and Akka. Written in two parts, you will first take a walkthrough of the reactive, asynchronous, and functional concepts in Scala before focusing on Akka and getting to grips with the details of real-world use cases.
Begin with an introduction into functional reactive programming, before moving on to writing asynchronous application with non-blocking constructs in Scala. Get familiar with the concept of actor-based concurrency using Akka, and features such as Akka remoting, routing, and persistence capabilities to build distributed applications. Learn to scale applications using a multi-node Akka cluster and unit test Akka actors and get to grips with state machines and how to implement state-driven actors using Akka. Finally, put your skills to the test with a case study where you will concurrently and asynchronously store and retrieve data from a key value store. By progressively working through the Akka concepts, you will not only be able to write your own distributed system, but also appreciate the hidden complexity within the Akka ecosystem.
Style and approach
This comprehensive guide walks you through the basics of reactive programming in Scala and Akka, explaining some of the most frequently used constructs to the most advanced features, and taking you through building a full-blown distributed system with the help of real-world examples.
Table of Contents
Chapter 1. Introducing Reactive Programming
Chapter 2. Functional Reactive Programming in Scala
Chapter 3. Asynchronous Programming in Scala
Chapter 4. Akka for Reactive Programming
Chapter 5. Building Resilient Application with Akka
Chapter 6. Akka Cluster
Chapter 7. Finite State Machines with Akka
Chapter 8. Akka Unit Testing
Chapter 9. Distributed Systems and Key-Value Stores