Practical Reactive Streams with Akka and Java

Course Curriculum

Chapter 1: Chapter 1 – Introduction

Lecture 1: What are reactive streams?

Lecture 2: Course files

Lecture 3: How to get support for this course

Chapter 2: Chapter 2 – Creating our first stream

Lecture 1: A note about external sources

Lecture 2: Using the Akka libraries

Lecture 3: Creating a source

Lecture 4: Creating a sink

Lecture 5: Creating a flow

Lecture 6: Building and running a graph

Chapter 3: Chapter 3 – Simple Sources and Sinks

Lecture 1: Finite Sources

Lecture 2: Infinite Sources

Lecture 3: Basic source operators

Lecture 4: Creating sinks

Lecture 5: Graph convenience methods

Chapter 4: Chapter 4 – Simple Flows

Lecture 1: Map and Filter

Lecture 2: MapConcat

Lecture 3: Grouped

Lecture 4: Flows of generic data types

Lecture 5: Combining flows with sinks and sources

Chapter 5: Chapter 5 – Exercise 1 – Big Primes

Lecture 1: Exercise

Lecture 2: Walkthrough

Chapter 6: Chapter 6 – Materialized values

Lecture 1: What are materialized values?

Lecture 2: The fold method and selecting a materialized value for the graph

Lecture 3: Terminating the actor system

Lecture 4: The reduce method

Chapter 7: Chapter 7 – Stream lifecycles

Lecture 1: Re-using graph objects

Lecture 2: Converting infinite streams to finite streams with take and limit

Lecture 3: The takeWhile and takeWithin functions

Chapter 8: Chapter 8 – Logging

Lecture 1: Logging elements in a stream

Chapter 9: Chapter 9 – Back pressure and graph performance

Lecture 1: Asynchronous boundaries

Lecture 2: Introducing back-pressure

Lecture 3: Adding buffers to the graph

Lecture 4: Other overflow strategies

Lecture 5: Parallelism

Chapter 10: Chapter 10 – Exercise 2 – monitoring vehicle speed

Lecture 1: Instructions to create an optimised graph with a materalised value

Lecture 2: Walkthrough

Chapter 11: Chapter 11 – The GraphDSL

Lecture 1: Why do we need the GraphDSL?

Lecture 2: Introducing the GraphDSL Syntax

Lecture 3: Constructing a simple Graph using the GraphDSL

Lecture 4: Understanding the Graph Construction and introducing Asynchronous Boundaries

Chapter 12: Chapter 12 – Complex flow types

Lecture 1: Introducing fan-in and fan-out shapes

Lecture 2: Broadcast and merge

Lecture 3: Using Balance for parallelilsm

Lecture 4: Exercise 3 – implementing parallelism in GraphDSL

Lecture 5: Uniform fan-in and fan-out shapes

Lecture 6: Non uniform fan-in and fan-out shapes

Chapter 13: Chapter 13 – Graphs with multiple sources and sinks

Lecture 1: Combining sources with a fan-in shape

Lecture 2: Sending to an interim sink with alsoTo

Lecture 3: Diverting outliers to a different sink with divertTo

Chapter 14: Chapter 14 – Non-runnable or partial graphs

Lecture 1: Creating and combining open shapes

Lecture 2: Using open shapes outside the graphDSL

Chapter 15: Chapter 15 – Using actors in graphs

Lecture 1: Adding an actor to our project

Lecture 2: Using actors as flows

Lecture 3: Using actors as sinks

Chapter 16: Chapter 16 – Advanced backpressure

Lecture 1: Conflate

Lecture 2: Extrapolate and expand

Chapter 17: Chapter 17 – The java flow package

Lecture 1: Java's reactive streams interfaces

Chapter 18: Chapter 18 – Case Study – Blockchain mining

Lecture 1: Introducing the case study

Lecture 2: Exercise 4 – receive transactions with backpressure

Lecture 3: Walkthrough

Lecture 4: Exercise 5 – mine using actors and apply the result

Lecture 5: Walkthrough

Lecture 6: Creating a circular graph

Chapter 19: Appendix

Lecture 1: A simple introduction to blockchains

Lecture 2: Bonus lecture