Functional effect handling in Scala with Cats Effect

Functional effect handling in Scala with Cats Effect, available at $74.99, has an average rating of 4.2, with 81 lectures, 13 quizzes, based on 120 reviews, and has 786 subscribers.

You will learn about Model and compose effectful computations in a pure manner. Design an error handling strategy taking side-effects into consideration. Increase concurrency and parallelism of an application with high-level methods. Safely use and release resources such as connections, io streams, etc. Handle complex concurrent scenarios involving shared state and thread communication with purely functional primitives. This course is ideal for individuals who are Scala developers with some experience in functional programming It is particularly useful for Scala developers with some experience in functional programming.

Enroll now: Functional effect handling in Scala with Cats Effect

Summary

Title: Functional effect handling in Scala with Cats Effect

Price: $74.99

Average Rating: 4.2

Number of Lectures: 81

Number of Quizzes: 13

Number of Published Lectures: 81

Number of Published Quizzes: 13

Number of Curriculum Items: 94

Number of Published Curriculum Objects: 94

Original Price: $19.99

Quality Status: approved

Status: Live

What You Will Learn

Model and compose effectful computations in a pure manner.

Design an error handling strategy taking side-effects into consideration.

Increase concurrency and parallelism of an application with high-level methods.

Safely use and release resources such as connections, io streams, etc.

Handle complex concurrent scenarios involving shared state and thread communication with purely functional primitives.

Who Should Attend

Scala developers with some experience in functional programming

Target Audiences

Scala developers with some experience in functional programming

When you first hear about functional programming you might get the impression that it can only be used in toy examples or for very academic purposes. After all, FP is all about purity and almost every useful thing you can do in a program is impure: http calls, file IO, and so on.

In this course I’m going to show you that FP is actually amazing for dealing with effects. By separating program description from execution you will be able to build computations that are easy to compose and reason about, while at the same time keeping all the usefulness of side-effects.

In order to do so, we are going to use the amazing Cats Effect library, which provides an IO monad to model our effects, a very rich API to compose them, and a highly-performant runtime to execute them.

The course is structured in many small/medium sized sections that focus on one specific topic. At the end of each section there is a final exercise to practice what you learned, and a quiz to help check your recall and understanding of the section.

By the end of the course, you will be able to:

Write and compose computations you want to run, before actually running them.

Design an error handling strategy for your application, taking side-effects into consideration.

Increase the parallelism and concurrency of your programs without the need to handle low-level details.

Use and compose resources that need to be released (connections, io streams, etc.) in an elegant manner.

Handle complex scenarios involving concurent shared state and thread communication by using purely functional primitives.

Hopefully, you will also have some fun along way!

Course Curriculum

Chapter 1: Introduction

Lecture 1: Introduction

Lecture 2: Setting up environment

Lecture 3: How to take this course

Lecture 4: Course files

Chapter 2: Effects in Programming

Lecture 1: Introduction

Lecture 2: Referential transparency

Lecture 3: Id generator

Lecture 4: Optionality

Lecture 5: State

Lecture 6: Error handling

Lecture 7: Printing to console

Lecture 8: Writing to disk

Lecture 9: Referentially transparent IO

Lecture 10: Definitions and clarifications

Chapter 3: The IO Monad

Lecture 1: Intro

Lecture 2: Basic usage

Lecture 3: IOApp

Lecture 4: Exercise

Chapter 4: Error Handling

Lecture 1: Intro

Lecture 2: Setting up API example

Lecture 3: Validating inputs with Validated

Lecture 4: Modeling domain errors with Either

Lecture 5: Loading accounts with a Repository

Lecture 6: Adding business logic with a Service

Lecture 7: Combining logic into the final Controller

Lecture 8: Testing

Lecture 9: Ignoring Fatal Errors

Lecture 10: Exercise

Chapter 5: Concurrency and Parallelism

Lecture 1: Intro

Lecture 2: ParMapN

Lecture 3: ParTraverse

Lecture 4: Race

Lecture 5: Exercise

Chapter 6: Resource Safety

Lecture 1: Intro – Bracket

Lecture 2: Writing to files with bracket

Lecture 3: Intro – Resource

Lecture 4: Copying and encrypting files with Resource

Lecture 5: Exercise

Chapter 7: Asynchronous Computations

Lecture 1: Intro

Lecture 2: Transforming a Future by blocking

Lecture 3: Avoiding blocking with async_

Lecture 4: Using fromFuture for conciseness

Lecture 5: Running on different thread pools with evalOn

Lecture 6: Exercise

Chapter 8: Memoization

Lecture 1: Intro

Lecture 2: Setting up templates example

Lecture 3: Loading templates eagerly

Lecture 4: Loading templates on error only

Lecture 5: Memoizing templates

Lecture 6: Exercise

Chapter 9: Time

Lecture 1: Intro

Lecture 2: Handling token expirations with realTime

Lecture 3: Measuring how long computations run with monotonic

Lecture 4: Exercise

Chapter 10: Concurrent Shared State Part I – Refs

Lecture 1: Intro

Lecture 2: Loading customers

Lecture 3: Storing the logs in a Ref

Lecture 4: Using one Ref per customer

Lecture 5: Exercise

Chapter 11: Concurrent Shared State Part II – Deferred

Lecture 1: Intro

Lecture 2: Showing items in a GUI

Lecture 3: Adding parallelism with parMapN

Lecture 4: Communicating processes with Deferred

Lecture 5: Adding error handling

Lecture 6: Exercise

Chapter 12: Queue

Lecture 1: Intro

Lecture 2: Processing events with queues

Lecture 3: Exercise

Chapter 13: Thread Pools

Lecture 1: Types of Thread Pools

Lecture 2: Work stealing pools

Lecture 3: Cached Unbounded Pools

Lecture 4: Execution contexts

Lecture 5: Choosing the correct thread pool

Lecture 6: Using compute and blocking pools

Lecture 7: Exercise

Instructors

Leandro Galvan
Senior Software Engineer

Rating Distribution

1 stars: 2 votes

2 stars: 4 votes

3 stars: 11 votes

4 stars: 37 votes

5 stars: 66 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!