Programming Reactive Systems (Scala 2 version)
Reactive programming is a set of techniques for implementing scalable, resilient and responsive systems as per the Reactive Manifesto. Such systems are based on asynchronous message-passing, and their basic building-blocks are event handlers.
Monthly Subscription Starting at AED 99 + VAT
- Level Professional
- Duration 51 hours
- Course by École Polytechnique Fédérale de Lausanne
-
Offered by
About
Reactive programming is a set of techniques for implementing scalable, resilient and responsive systems as per the Reactive Manifesto. Such systems are based on asynchronous message-passing, and their basic building-blocks are event handlers. This course teaches how to implement reactive systems in Scala and Akka by using high-level abstractions, such as actors, asynchronous computations, and reactive streams. You will learn how to: - use, transform and sequence asynchronous computations using Future values - write concurrent reactive systems based on Actors and message passing, using untyped Akka and Akka Typed - design systems resilient to failures - implement systems that can scale out according to a varying workload - transform and consume infinite and intermittent streams of data with Akka Stream in a non-blocking way - understand how back-pressure controls flows of dataModules
Welcome
-
1
Videos
-
1
Readings
1
Videos
- Introduction to Programming Reactive Systems
1
Readings
- Course structure
Practical information
-
3
Videos
-
8
Readings
-
1
Programming
- Example Assignment
3
Videos
- Tools Setup for Linux
- Tools Setup for Mac OS X
- Tools Setup for Windows
8
Readings
- Evaluation
- Tools Setup (Please read)
- Cheat Sheet
- IntelliJ IDEA Tutorial
- SBT tutorial and Submission of Assignments (Please read)
- Learning Resources
- Scala Tutorial
- Scala Style Guide
Scala Recap
-
2
Videos
2
Videos
- Lecture 1.2-Functions and Pattern Matching
- Lecture 1.3-Collections
Asynchronous Programming
-
2
Videos
2
Videos
- Lecture 1.4-Asynchronous Programming
- Lecture 1.5-Futures
Programming with Futures
-
2
Programming
- Programming with Futures (audit track)
- Programming with Futures (verified track)
The Actor Model
-
5
Videos
5
Videos
- Lecture 2.1-Introduction: why actors?
- Lecture 2.2-The Actor Model
- Lecture 2.3-Message Processing Semantics
- Lecture 2.4-Designing Actor Systems
- Lecture 2.5-Testing Actor Systems
Binary Trees
-
2
Programming
- Binary Trees (verified track)
- Binary Trees (audit track)
Handling Failure and State
-
3
Videos
3
Videos
- Lecture 3.1-Failure Handling With Actors
- Lecture 3.2-Lifecycle Monitoring and The Error Kernel
- Lecture 3.3-Persistent Actor State
Replicated Key-Value Store
-
2
Programming
- Replicated Key-Value Store (verified track)
- Replicated Key-Value Store (audit track)
Distributed Computing
-
6
Videos
6
Videos
- Lecture 4.1-Actors Are Distributed (part 1)
- Lecture 4.2-Actors Are Distributed (part 2)
- Lecture 4.3-Eventual Consistency
- Lecture 4.4-Actor Composition
- Lecture 4.5-Scalability
- Lecture 4.6-Responsiveness
Typed Actors
-
6
Videos
6
Videos
- Lecture 5.1-Introduction to Protocols
- Lecture 5.2-Protocols in Akka Typed
- Lecture 5.3-Testing Akka Typed Behaviors
- Lecture 5.4-Akka Typed Facilities
- Lecture 5.5-Akka Typed Persistence
- Lecture 5.6-Supervision revisited
Transactor
-
2
Programming
- Transactor (verified track)
- Transactor (audit track)
Stream Processing
-
4
Videos
4
Videos
- Lecture 6.1-Stream Processing
- Lecture 6.2-Introducing Reactive Streams Semantics
- Lecture 6.3-Akka Streams
- Lecture 6.4-Failure handling and processing rate
Streaming assignment
-
2
Programming
- Streaming assignment (verified track)
- Streaming assignment (audit track)
Advanced Stream Processing
-
4
Videos
4
Videos
- Lecture 7.1-Streaming Protocols & Stream Composition
- Lecture 7.2-Stateful operations and materialized values
- Lecture 7.3-Fan-in and Fan-out operations
- Lecture 7.4-Integrating Streams with (Typed) Actors
Followers
-
2
Programming
- Reactive followers (verified track)
- Reactive followers (audit track)
Auto Summary
Unlock the potential of scalable, resilient, and responsive systems with the "Programming Reactive Systems (Scala 2 version)" course. This professional-level course, offered by Coursera, dives deep into the domain of IT & Computer Science, focusing on the principles and practices of reactive programming as outlined in the Reactive Manifesto. Guided by expert instructors, you'll master the art of implementing reactive systems using Scala and Akka. The curriculum covers high-level abstractions including actors, asynchronous computations, and reactive streams. Key learning outcomes include: - Handling, transforming, and sequencing asynchronous computations with Future values. - Crafting concurrent reactive systems through Actors and message passing, utilizing both untyped Akka and Akka Typed. - Designing systems that are resilient to failures and can efficiently scale with fluctuating workloads. - Managing infinite and intermittent data streams using Akka Stream in a non-blocking manner. - Understanding and applying back-pressure to control data flow. With a comprehensive duration of 3060 minutes, this course offers flexible subscription options through Starter and Professional plans, catering to IT professionals seeking to enhance their skills in building advanced reactive systems. Whether you're aiming to advance your career or enhance your technical expertise, this course provides the knowledge and tools to excel in the dynamic field of reactive programming.
Julien Richard-Foy
Martin Odersky
Konrad Malawski
Roland Kuhn