We may earn an affiliate commission when you visit our partners.
Julien Richard-Foy,
Martin Odersky,
Konrad Malawski,
and
Roland Kuhn
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
Read more
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
Read more
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 data
Register for this course and see more details by visiting:
OpenCourser.com/course/x345cw/programming
What's inside
Syllabus
Introduction, Recap and Asynchronous Programming
This module shows you how to get started with the course. After setting up your machine to work on and to submit assignments, it will provide you with a recap of the basics of the Scala language. Finally, you will encounter the first topic of the course, asynchronous programming with Futures.
Read more
Syllabus
Introduction, Recap and Asynchronous Programming
This module shows you how to get started with the course. After setting up your machine to work on and to submit assignments, it will provide you with a recap of the basics of the Scala language. Finally, you will encounter the first topic of the course, asynchronous programming with Futures.
Read more
The Actor Model
This module presents the Actor model: after analyzing its advantages and strengths, you will learn the semantics and design principles of actor systems before learn how to concretely test actor-based programs
Handling Failure and State
This module further explores the Actor model by showing useful patterns used to create complex and resilient programs
Distributed Computing
Actors allow you to decouple a program in units that can be distributed on a single or on multiple machines. This module elaborates on the power and the consequences of distributed computation
Typed Actors
Now that you are familiar with the Actor model, this module shows how to leverage Scala's powerful type system to write programs with more confidence by using typed actor descriptions
Stream Processing
This module introduces the concept of data streams and the basic semantics of stream processing before showing how the Akka framework can be used to tackle common challenges in this domain
Advanced Stream Processing
This final module elaborates on more complex and powerful patterns in stream processing as well as how to the integrate the actor model to create custom nodes of data processing
Good to know
Good to know
Know what's good ,
what to watch for , and
possible dealbreakers
Explores Reactive Programming, which is standard in the industry for implementing scalable, resilient and responsive systems
Taught by Martin Odersky, Roland Kuhn, Konrad Malawski, and Julien Richard-Foy, who are recognized for their work in programming languages and reactive programming
Develops proficiency in concurrency, message passing, and data stream processing using Future, Akka, and Akka Stream
Suitable for intermediate-level students with some experience in Scala programming
Save this course
Save Programming Reactive Systems (Scala 2 version) to your list so you can find it easily later:
Save
Save
Reviews summary
Engaging intro to reactive systems
Learners say that this engaging course offers a solid introduction to Reactive Systems, using AKKA at its core. Students appreciate that the course provides clear explanations and plenty of examples.
Course begins with the basics of reactive systems.
"A really good introduction to Reactive Systems"
Utilizes the AKKA framework for teaching reactive principles.
"using AKKA at its core"
The lessons are well-structured with helpful illustrations.
"plenty of examples"
Concepts are presented in a clear and understandable manner.
"clear explanations"
Activities
Be better prepared
before
your course. Deepen your understanding
during
and
after
it. Supplement your coursework and achieve mastery of the topics covered
in Programming Reactive Systems (Scala 2 version) with these
activities:
Organize Course Materials
Show steps
Organize the notes, assignments, quizzes, and exams, which will help you prepare for the course and enhance your learning experience
Show steps
-
Review the course syllabus and identify the materials
-
Create a system for organizing the materials
-
Organize the materials
-
Review the organized materials
Read Designing Data-Intensive Applications
Show steps
This book provides a comprehensive overview of the challenges and techniques involved in designing and building data-intensive applications.
View
Secret Colors
on Amazon
Show steps
-
Read the book
-
Take notes
-
Discuss the book with others
Tutorial: Understanding Concurrency
Show steps
This tutorial will help you understand the concept of message-passing concurrency and how it is used in Akka.
Browse courses on
Concurrency
Show steps
-
Watch the tutorial
-
Complete the exercises
Five other activities
Expand to see all activities and additional details
Show all eight activities
Practice asynchronously passing futures using zipWith
Show steps
This practice will help you understand how to use `zipWith` to work with asynchronous computations.
Browse courses on
Reactive Programming
Show steps
-
Create a program to implement futures
-
Create a function that takes two future values and zips them together
-
Call the function to zip the futures
-
Print the result
Attend a study group or meet with other students
Show steps
Discuss the course material with other students to reinforce learning and get outside perspectives.
Show steps
-
Find a study group or other students to meet with
-
Schedule a meeting
-
Discuss the course material
Solve practice problems on reactive programming
Show steps
Solving practice problems will help you solidify your understanding of reactive programming concepts.
Browse courses on
Reactive Programming
Show steps
-
Find a set of practice problems
-
Solve the problems
-
Review your solutions
Build a simple reactive system using Akka Typed
Show steps
This project will help you apply your knowledge of Reactive Programming and Akka Typed to build a working system.
Show steps
-
Design the system architecture
-
Implement the system using Akka Typed
-
Test the system
Create a blog post or article about Reactive Programming
Show steps
Creating a blog post or article will help you synthesize your knowledge and understanding of reactive programming.
Browse courses on
Reactive Programming
Show steps
-
Choose a topic
-
Research the topic
-
Write the blog post or article
-
Publish the blog post or article
Organize Course Materials
Show steps
Organize the notes, assignments, quizzes, and exams, which will help you prepare for the course and enhance your learning experience
Show steps
Show steps
Show steps
- Review the course syllabus and identify the materials
- Create a system for organizing the materials
- Organize the materials
- Review the organized materials
Read Designing Data-Intensive Applications
Show steps
This book provides a comprehensive overview of the challenges and techniques involved in designing and building data-intensive applications.
View
Secret Colors
on Amazon
Show steps
Show steps
Show steps
- Read the book
- Take notes
- Discuss the book with others
Tutorial: Understanding Concurrency
Show steps
This tutorial will help you understand the concept of message-passing concurrency and how it is used in Akka.
Browse courses on
Concurrency
Show steps
Show steps
Show steps
- Watch the tutorial
- Complete the exercises
Five other activities
Expand to see all activities and additional details
Show all eight activities
Practice asynchronously passing futures using zipWith
Show steps
This practice will help you understand how to use `zipWith` to work with asynchronous computations.
Browse courses on
Reactive Programming
Show steps
Show steps
Show steps
- Create a program to implement futures
- Create a function that takes two future values and zips them together
- Call the function to zip the futures
- Print the result
Attend a study group or meet with other students
Show steps
Discuss the course material with other students to reinforce learning and get outside perspectives.
Show steps
Show steps
Show steps
- Find a study group or other students to meet with
- Schedule a meeting
- Discuss the course material
Solve practice problems on reactive programming
Show steps
Solving practice problems will help you solidify your understanding of reactive programming concepts.
Browse courses on
Reactive Programming
Show steps
Show steps
Show steps
- Find a set of practice problems
- Solve the problems
- Review your solutions
Build a simple reactive system using Akka Typed
Show steps
This project will help you apply your knowledge of Reactive Programming and Akka Typed to build a working system.
Show steps
Show steps
Show steps
- Design the system architecture
- Implement the system using Akka Typed
- Test the system
Create a blog post or article about Reactive Programming
Show steps
Creating a blog post or article will help you synthesize your knowledge and understanding of reactive programming.
Browse courses on
Reactive Programming
Show steps
Show steps
Show steps
- Choose a topic
- Research the topic
- Write the blog post or article
- Publish the blog post or article
Career center
Learners who complete Programming Reactive Systems (Scala 2 version) will develop knowledge and skills
that may be useful to these careers:
Software Engineer
Software Engineer
Software Engineers apply programming skills to design and develop software systems for various purposes. This course can help build a strong foundation for implementing reactive systems in Scala using Akka, which is a valuable skill set for Software Engineers.
Data Scientist
Data Scientist
Data Scientists use scientific methods to extract insights from data and develop predictive models. This course teaches reactive programming techniques that can enhance the efficiency and scalability of data processing tasks, which can benefit Data Scientists.
Machine Learning Engineer
Machine Learning Engineer
Machine Learning Engineers design and develop machine learning models and algorithms. This course teaches reactive programming techniques that can improve the performance and efficiency of machine learning systems, which is important for Machine Learning Engineers.
Technical Architect
Technical Architect
Technical Architects design and manage the architecture of software systems. This course teaches reactive programming techniques that can enhance the scalability, resilience, and performance of software systems, which is important for Technical Architects.
Data Engineer
Data Engineer
Data Engineers collect, process, and store large volumes of data and design systems that support data analysis. This course introduces Akka Streams, a tool for processing data streams, which is relevant to Data Engineers.
Big Data Analyst
Big Data Analyst
Big Data Analysts analyze large datasets to extract insights and patterns. This course introduces Akka Streams, a tool for processing data streams, which can be beneficial for Big Data Analysts.
DevOps Engineer
DevOps Engineer
DevOps Engineers bridge the gap between development and operations teams, ensuring efficient and reliable software delivery. This course introduces reactive programming, which can enhance the resilience and scalability of software systems, which is important for DevOps Engineers.
Systems Administrator
Systems Administrator
Systems Administrators manage and maintain computer systems and networks. This course introduces reactive programming, which can help build more resilient and scalable systems, which is beneficial for Systems Administrators.
Software Architect
Software Architect
Software Architects design and manage the architecture of software systems. This course teaches reactive programming techniques that can enhance the scalability, resilience, and performance of software systems, which is important for Software Architects.
Database Administrator
Database Administrator
Database Administrators manage and maintain databases. This course introduces reactive programming, which can help build more resilient and scalable database systems, which is beneficial for Database Administrators.
Business Analyst
Business Analyst
Business Analysts analyze and document business requirements and processes. This course may be helpful for Business Analysts who want to gain an understanding of reactive programming, which can enhance the efficiency and scalability of software systems.
Quality Assurance Analyst
Quality Assurance Analyst
Quality Assurance Analysts test and validate software systems to ensure they meet quality standards. This course may be helpful for Quality Assurance Analysts who want to gain experience with reactive programming techniques, which can enhance the reliability and maintainability of software systems.
Web Developer
Web Developer
Web Developers design and build websites and web applications. This course may be helpful for Web Developers who want to create responsive and scalable web systems using reactive programming techniques.
Project Manager
Project Manager
Project Managers plan and manage software development projects. This course may be helpful for Project Managers who want to gain an understanding of reactive programming, which can improve the planning and execution of software development projects.
Cloud Architect
Cloud Architect
Cloud Architects design and manage cloud computing systems. This course may be useful for Cloud Architects who want to build cloud-based reactive systems that can scale and handle high workloads.
For more career information including salaries, visit:
OpenCourser.com/course/x345cw/programming
Reading list
We've selected nine books
that we think will supplement your
learning. Use these to
develop background knowledge, enrich your coursework, and gain a
deeper understanding of the topics covered in
Programming Reactive Systems (Scala 2 version).
Provides a comprehensive guide to reactive programming with Scala and Akka. It covers the core concepts of reactive programming, such as actors, asynchronous computations, and reactive streams, and shows how to use them to build scalable, resilient, and responsive systems.
Save
Provides a comprehensive guide to designing and building data-intensive applications. It covers the core concepts of data-intensive applications, such as data modeling, data storage, and data processing, and shows how to use them to build scalable, reliable, and efficient applications.
Save
Provides a comprehensive guide to using Scala and Play to build reactive web applications. It covers the core concepts of Play, such as controllers, views, and routing, and shows how to use Scala to implement them.
Provides a comprehensive guide to using Scala for data science. It covers the core concepts of data science, such as data exploration, data analysis, and machine learning, and shows how to use Scala to implement them.
Provides a comprehensive guide to concurrency in Java. It covers the core concepts of concurrency, such as threads, locks, and synchronization, and shows how to use them to build concurrent applications that are scalable, efficient, and reliable.
Comprehensive guide to reactive programming with RxJava, the popular library for reactive programming in Java. It covers the core concepts of reactive programming, such as observables, operators, and schedulers, and provides practical examples of building reactive systems with RxJava.
Save
Provides a comprehensive overview of reactive programming and microservices, with a focus on Java. It covers the fundamental concepts of reactive programming and microservices, and provides practical examples of building reactive microservices in Java.
Provides a comprehensive overview of reactive programming in Rust. It covers the fundamental concepts of reactive programming, such as streams, futures, and tasks, and provides practical examples of building reactive systems in Rust.
Save
Provides a comprehensive overview of reactive programming in Clojure. It covers the fundamental concepts of reactive programming, such as streams, channels, and agents, and provides practical examples of building reactive systems in Clojure.
For more information about how these books relate to this course, visit:
OpenCourser.com/course/x345cw/programming
Share
Similar courses
Here are nine courses similar to
Programming Reactive Systems (Scala 2 version).
Programming Reactive Systems
OpenCourser.com/course/p5owc1/programming
Programming Reactive Systems
Most relevant
Akka Streams with Scala | Rock the JVM
OpenCourser.com/course/lvlfk5/akka
Akka Streams with Scala | Rock the JVM
Most relevant
Distributed Programming in Java
OpenCourser.com/course/he4wbz/distributed
Distributed Programming in Java
Most relevant
Akka Classic Essentials with Scala
OpenCourser.com/course/4s1dg0/akka
Akka Classic Essentials with Scala
Most relevant
Akka.NET 1 Persistence Fundamentals
OpenCourser.com/course/lruz39/akka
Akka.NET 1 Persistence Fundamentals
Most relevant
Java 8 Fundamentals: Asynchronous Programming Using CompletionStage
OpenCourser.com/course/lusjzg/java
Java 8 Fundamentals: Asynchronous Programming Using...
Reactive Programming in Java 12 with RxJava 2
OpenCourser.com/course/wwxqw9/reactive
Reactive Programming in Java 12 with RxJava 2
Getting Started with Reactive Programming Using RxJS
OpenCourser.com/course/3pr3e6/getting
Getting Started with Reactive Programming Using RxJS
Message Passing
OpenCourser.com/course/udbqyo/message
Message Passing
Effort
7 weeks, 5-7 hours per week
Level
Intermediate
Via
Coursera
Institution
École Polytechnique Fédérale de Lausanne2
Instructors
Julien Richard-Foy
Martin Odersky
Konrad Malawski
Roland Kuhn
Language
English
Good to know
Explores Reactive Programming, which is standard in the industry for implementing scalable, resilient and responsive systems
Taught by Martin Odersky, Roland Kuhn, Konrad Malawski, and Julien Richard-Foy, who are recognized for their work in programming languages and reactive programming
Develops proficiency in concurrency, message passing, and data stream processing using Future, Akka, and Akka Stream
Suitable for intermediate-level students with some experience in Scala programming
Our mission
OpenCourser helps millions of learners each year. People visit us to learn workspace skills, ace their exams, and nurture their curiosity.
Our extensive catalog contains over 50,000 courses and twice as many books. Browse by search, by topic, or even by career interests. We'll match you to the right resources quickly.
Find this site helpful? Tell a friend about us.
Affiliate disclosure
We're supported by our community of learners. When you purchase or subscribe to courses and programs or purchase books, we may earn a commission from our partners.
Your purchases help us maintain our catalog and keep our servers humming without ads.
Thank you for supporting OpenCourser.
© 2016 - 2024 OpenCourser