We may earn an affiliate commission when you visit our partners.
Course image
Julien Truffaut

Modern applications often need to describe complex workflows involving multiple external systems. These are notoriously difficult to get right as it requires handling errors, various retry strategies and non-determinism because of concurrent executions. In this course, you will learn how to solve this problem using both imperative and functional programming.

By the end of the course, you will be able to read and write code using popular Scala libraries such as cats-effect, Monix and ZIO. This skill is in high demand.

Read more

Modern applications often need to describe complex workflows involving multiple external systems. These are notoriously difficult to get right as it requires handling errors, various retry strategies and non-determinism because of concurrent executions. In this course, you will learn how to solve this problem using both imperative and functional programming.

By the end of the course, you will be able to read and write code using popular Scala libraries such as cats-effect, Monix and ZIO. This skill is in high demand.

Several companies use this curriculum to on-board and train engineers. Here is a non-exhaustive list:

  • Lunatech

  • Kaluza / OVO Energy

  • Autoscout24

  • Pirum Systems

  • Cleverbase

These companies are constantly hiring new Scala developers. Don’t hesitate to reach out to them and mention that you took this course.

I designed this content for backend developers. It is extremely practical and hands-on. Specifically, this means that you will:

  • Write lots of Scala code

  • Test it using both example-based and property-based tests

  • Experience issues caused by blocking logic and concurrent execution

  • Work your way to efficient solutions in small and incremental steps

I will guide you through all the exercises and provide a complete set of solutions. My goal is to unlock your full potential as a functional Scala developer by demystifying complex concepts using explanations that are free of confusing jargon.

For those familiar with FP-Tower courses, this course corresponds to chapter 5 of Foundations of Functional Programming in Scala.

Enroll now, and enjoy the course.

Enroll now

What's inside

Syllabus

Getting Started
Setup the Scala project
SBT 101
Property-Based Testing tutorial
Read more

Custom random generators

arbitrary lets us fetch the default random generator for a type, if there is one:

import org.scalacheck.Arbitrary.arbitrary

arbitrary[String]

// res: Gen[String] = ...

Then, we can use the methods filter or filterNot to modify an existing generator.

val invalidYesNoInputGen: Gen[String] = arbitrary[String].filter(word => word != "Y" && word != "N")

invalidYesNoInputGen is a random generator of String which will never produce the single letter String "Y" and "N".

Note that if the predicate of filter is too restrictive, it could take a long time for finding a valid value. For example, the code below generates a random Strings and discards all values that do NOT start with "abc".

arbitrary[String].filter(_.startsWith("abc"))

To prevent long or even infinite waiting time, Scalacheck throws an Exception if it discards too many values.

[Error] Gave up after 0 successful property evaluations. 51 evaluations were discarded.

If you want a generator of String starting with "abc", a better solution would be to generate a random String and then, prepend it with "abc".

arbitrary[String].map(randomString => "abc" ++ randomString)

Missing code

In the video, I mention a function called parseDate which is not included in the code.

def parseDate(line: String): LocalDate =  LocalDate.parse(line, dateOfBirthFormatter)

We can also define a corresponding formatter function

def formatDateOfBirth(date: LocalDate): String =   dateOfBirthFormatter.format(date)

References

  • Extension methods by Alvin Alexander https://alvinalexander.com/scala/implicit-extension-methods-functions-scala-2-3-dotty/

References

  • Fabio Labella — How do Fibers Work? https://www.youtube.com/watch?v=x5_MmZVLiSM

Traffic lights

Read about what's good
what should give you pause
and possible dealbreakers
Uses Scala libraries like cats-effect, Monix, and ZIO, which are valuable for building robust and scalable applications
Emphasizes hands-on coding, testing, and problem-solving, which are crucial for practical skill development
Several companies use this curriculum to onboard and train engineers, suggesting industry relevance and potential career opportunities
Focuses on handling errors, retry strategies, and non-determinism, which are common challenges in modern application development
Requires familiarity with Scala and functional programming concepts, which may necessitate prior learning for some students
Teaches property-based testing, which is a powerful technique, but may require additional learning for developers unfamiliar with it

Save this course

Create your own learning path. Save this course to your list so you can find it easily later.
Save

Reviews summary

Practical scala concurrency with fp-tower

According to students, this course is a must-take for serious Scala developers looking to master asynchronous programming and concurrency. Learners say it provides a very solid foundation, effectively teaching how to use modern libraries like cats-effect and ZIO by progressing logically from Futures to IO monads. Reviewers highlight the practical and hands-on nature with numerous coding exercises as a major strength, describing them as challenging but incredibly rewarding and essential for applying concepts. While praised for breaking down complex FP ideas clearly, some students noted the pace can be fast and the course assumes a comfortable level with intermediate Scala and basic functional programming, potentially making it difficult if you lack prior experience. Overall, it's seen as highly useful for real-world Scala backend development.
Demystifies difficult functional programming ideas.
"It really helped me understand the nuances of asynchronous programming in Scala using Futures and then transitioning to more powerful concepts with IO monads..."
"Coming from an imperative background, the transition to FP concepts, especially with IO, can be daunting. This course breaks it down beautifully."
"It's focused, practical, and demystifies complex topics like IO monads."
"The instructor explains complex ideas clearly."
Focuses on essential, modern Scala libraries.
"transitioning to more powerful concepts with IO monads from cats-effect and ZIO."
"I appreciated the coverage of cats-effect and ZIO, which are essential libraries."
"Excellent course covering Futures, cats-effect, and ZIO. The progression is logical..."
"Provides a very solid foundation on handling asynchronous operations and concurrent tasks in Scala using modern libraries."
Exercises are key to applying and reinforcing learning.
"The exercises are practical and build incrementally. The hands-on coding is a major plus."
"The exercises force you to code and apply what you learn. Great content structure and flow."
"The hands-on coding approach is perfect. This course directly applies to production code."
"Exercises are helpful, although challenging. The exercises are key to learning."
"I felt the exercises were good, though sometimes I felt they could have provided more guidance initially."
Debugging exercises may be challenging without support.
"debugging issues without a strong community forum or more detailed solutions can be frustrating."
"Exercises are useful but difficult if you get stuck."
Some learners found the course progression quick.
"The course covers important topics, but it moves quite quickly."
"The pace is too fast for someone without significant prior FP experience."
Requires prior intermediate Scala/FP knowledge.
"If you're not already comfortable with intermediate Scala and basic FP concepts, you might struggle."
"The pace is too fast for someone without significant prior FP experience."
"While it says it demystifies concepts, it assumes a certain level of comfort with abstractions."
"Requires a good understanding of Scala fundamentals."

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 Supercharge Scala Future | FP-Tower with these activities:
Review Functional Programming Concepts
Solidify your understanding of functional programming principles before diving into Scala's implementation. This will make grasping the course material easier.
Browse courses on Functional Programming
Show steps
  • Read introductory materials on functional programming.
  • Practice writing pure functions in a language you're familiar with.
  • Familiarize yourself with concepts like immutability and referential transparency.
Help Others in Online Forums
Reinforce your understanding by helping other students in online forums. Explaining concepts to others is a great way to solidify your own knowledge.
Show steps
  • Find online forums related to Scala and functional programming.
  • Answer questions from other students.
  • Provide helpful and constructive feedback.
Read 'Functional Programming in Scala'
Deepen your understanding of functional programming principles in Scala. This book is a great companion to the course.
Show steps
  • Read the book alongside the course material.
  • Work through the exercises in the book.
  • Compare the book's approach to the course's approach.
Four other activities
Expand to see all activities and additional details
Show all seven activities
Implement Retry Logic
Practice implementing different retry strategies using Scala's Future and IO monads. This will reinforce your understanding of error handling and concurrency.
Show steps
  • Implement a simple retry mechanism with a fixed delay.
  • Implement exponential backoff retry.
  • Implement retry with jitter.
  • Test your retry logic thoroughly.
Read 'Cats Effect with Scala.js'
Explore Cats Effect in the context of Scala.js. This will broaden your understanding of its applications.
Show steps
  • Read the book and try out the examples.
  • Compare the book's approach to the course's approach.
  • Consider how you might apply these concepts in your own projects.
Build a Simple Rate Limiter
Apply your knowledge of concurrent IO and error handling to build a practical rate limiter. This project will solidify your understanding of the course material.
Show steps
  • Design the rate limiter's API.
  • Implement the rate limiting logic using concurrent IO.
  • Test the rate limiter under different load conditions.
  • Document your code and design decisions.
Contribute to a Scala Library
Contribute to an open-source Scala library that uses Future or IO. This will give you valuable experience working on a real-world project and collaborating with other developers.
Show steps
  • Find a Scala library that interests you.
  • Identify a bug or feature request to work on.
  • Submit a pull request with your changes.
  • Respond to feedback from the maintainers.

Career center

Learners who complete Supercharge Scala Future | FP-Tower will develop knowledge and skills that may be useful to these careers:
Backend Developer
Backend Developers build and maintain the server-side logic and databases that power applications. This course is specifically designed for backend developers, which makes it a great fit for those individuals. Mastering Scala libraries like cats-effect, Monix, and ZIO—as taught in this course—allows a Backend Developer to manage complex workflows and concurrent executions more effectively, resulting in more scalable and reliable applications. The hands-on approach, focusing on writing and testing Scala code, directly translates to improved skills in real-world backend development scenarios.
Software Engineer
A Software Engineer designs, develops, and tests software applications. This course helps engineers master concurrent executions and error handling, essential skills for building robust systems. By learning to use Scala libraries like cats-effect, Monix, and ZIO, students enhance their ability to create efficient and reliable software. The course's emphasis on practical coding and testing is directly applicable to the daily tasks of a Software Engineer, making them more productive and effective. For those working with Scala, this course is particularly beneficial.
Software Architect
Software Architects are responsible for making high-level design choices and setting technical standards for software projects. This course helps Software Architects understand how to manage complex systems using Scala, especially mastering workflow building and concurrency. With expertise in libraries like cats-effect, Monix, and ZIO, a Software Architect can design more scalable and reliable systems. The practical exercises in this course are invaluable for ensuring that architectural designs are feasible and effective to implement.
Application Developer
Application Developers create and maintain software applications for various platforms. This course helps by teaching them how to manage complex workflows and handle errors effectively using Scala. With skills in cats-effect, Monix, and ZIO, an Application Developer can build more robust and efficient applications. The practical coding and testing exercises are critical for ensuring the reliability and performance of applications. Those wanting to improve their application development skills should consider this course.
Systems Architect
Systems Architects design the structure and components of software systems. To do so effectively, it's important to master building workflows and concurrency. This course helps Systems Architects understand how to manage complex systems using Scala, by teaching the use of libraries like cats-effect, Monix, and ZIO to handle errors and ensure reliability. The knowledge gained in this course enables architects to design more scalable and maintainable systems. Systems Architects who want to design better systems should consider this course.
Technical Lead
Technical Leads guide and mentor development teams, making key technical decisions. This course helps Technical Leads understand how to manage complex workflows and concurrent executions using Scala, especially when building workflows. Proficiency in libraries like cats-effect, Monix, and ZIO enables them to lead teams in building more reliable and efficient systems. The practical coding and testing exercises enhance their ability to guide team members in solving real-world problems. Technical Leads can greatly benefit from this course.
Platform Engineer
Platform Engineers build and maintain the underlying infrastructure that supports software applications. This course helps Platform Engineers understand how to manage complex systems and concurrent executions using Scala, especially when building workflows. Skills in libraries like cats-effect, Monix, and ZIO enable them to build more resilient and scalable platforms. The hands-on coding experience provided by the course directly improves their ability to optimize and troubleshoot platform issues. Those wanting to make highly scalable platforms should consider this course.
DevOps Engineer
DevOps Engineers streamline software development and deployment processes. This course helps DevOps Engineers understand how to manage complex workflows and ensure reliability in distributed systems by learning functional programming paradigms. Skills in Scala, along with libraries like cats-effect, Monix, and ZIO, make a DevOps Engineer more effective in automating and optimizing deployment pipelines. The focus on practical coding and problem-solving enhances their ability to tackle real-world deployment challenges.
Principal Engineer
Principal Engineers are senior-level experts who provide technical leadership and vision within an organization. To do so, Principal Engineers must be able to handle the building of complex workflows. This course helps Principal Engineers deepen their understanding of how to manage system complexity using Scala. Expertise in libraries like cats-effect, Monix, and ZIO enables smarter architectural decisions that result in more robust and scalable systems. The advanced problem-solving skills cultivated in this course are essential for tackling the most challenging technical issues.
Data Engineer
Data Engineers design, build, and maintain the infrastructure for data processing and storage. This course may be useful for Data Engineers looking to improve their ability to manage complex data workflows. Learning how to use Scala effectively, especially with libraries like cats-effect, Monix, and ZIO, enables better handling of data pipelines and concurrent processing. The skills gained in this course can help streamline data operations and ensure data reliability. Data Engineers should consider a course like this to improve their data processing skills.
Full-Stack Developer
Full Stack Developers work on both the front-end and back-end aspects of applications. While this course is more focused on backend development, understanding how to manage complex workflows and concurrent executions using Scala benefits a Full Stack Developer. Skills in libraries like cats-effect, Monix, and ZIO enhance their ability to build robust and scalable applications. The practical coding exercises provided by the course directly improve their ability to tackle full stack development challenges. Full Stack developers should consider a course like this.
Cloud Engineer
Cloud Engineers manage and maintain cloud infrastructure and services. This course may be useful for Cloud Engineers looking to improve their ability to manage complex workflows and ensure reliability in cloud-based systems. Learning how to use Scala effectively—especially with libraries like cats-effect, Monix, and ZIO—enables better handling of concurrent processes and error handling in distributed environments. The skills gained in this course can help streamline cloud operations. Those working with cloud-based systems should consider this course.
Site Reliability Engineer
Site Reliability Engineers ensure the reliability and performance of software systems in production. This course may be useful for improving an SRE's skills with Scala and functional programming. This course helps one understand how to manage complex workflows and handle errors effectively, using Scala libraries like cats-effect, Monix, and ZIO to build more resilient systems. The practical coding and testing exercises allow direct improvement in tackling real-world reliability challenges. SRE who want to improve system resilency should consider this specialization.
Performance Engineer
Performance Engineers focus on optimizing the performance of software systems. This course may be useful in helping a Performance Engineer understand how concurrent executions and error handling influence system speed. By learning Scala libraries like cats-effect, Monix, and ZIO, one can better identify and address performance bottlenecks. The practical, hands-on approach will make the Performance Engineer more effective at optimizing code for efficiency and speed. One who wants to improve system perfomance should consider this course.
Data Scientist
Data Scientists analyze and interpret complex data to inform business decisions. This course may be useful to a Data Scientist who wishes to manage complex data workflows using functional programming. Skills in Scala, along with libraries like cats-effect, Monix, and ZIO, can enhance their ability to build robust and scalable data processing pipelines. The hands-on coding experience provided by the course helps to optimize data analysis processes. Data Scientists should consider this course.

Reading list

We've selected two 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 Supercharge Scala Future | FP-Tower.
Provides a comprehensive introduction to functional programming using Scala. It covers core concepts and techniques that are directly applicable to the course material. It is commonly used as a textbook in functional programming courses. Reading this book will give you a deeper understanding of the underlying principles and how they are implemented in Scala.
Provides a practical guide to using Cats Effect with Scala.js. It covers topics such as concurrency, error handling, and resource management. While not strictly required for the course, it provides a useful perspective on applying these concepts in a front-end context. This book is more valuable as additional reading to expand your knowledge.

Share

Help others find this course page by sharing it with your friends and followers:

Similar courses

Similar courses are unavailable at this time. Please try again later.
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 - 2025 OpenCourser