What is Cats Effect?
Cats Effect is a Scala library that allows us to write composable and high-performance applications with pure functional programming.
What?!
Cats Effect comes with a powerful tool called the IO monad, which gives us the power to compose any kind of actions, aka "effects". Besides that, we get great support for concurrency, parallelism and coordination, all with a strongly typed system (it's Scala of course).
On more general terms, Cats Effect comes with a group of abstractions that make clear distinctions between different kinds of effects, so we can write more composable code.
The end result is more expressive power, higher performance, fewer bugs, less boilerplate, and most importantly, more happiness and productivity for us as Scala engineers.
This is what you'll learn in this course.
How this Cats Effect course works
Two words: writing code.
This course is as hands-on as you can get. We learn everything from first principles, not assuming any pre-existing Cats Effect experience, and we build up from there. We discover what effects are, how we can use them, how to compose code, how to design parallel and concurrent applications and how to generalize and make the code modular, all through practical examples. We write 3000 lines of code from scratch.
In this course, we have both theory and practice, so you can not only learn Cats Effect as a tool, but you internalize timeless principles for pure functional programming and high-performance applications.
The course was specifically designed to give you a smooth learning curve by deconstructing Cats Effect and sequencing the topics carefully. Nothing too steep or too boring.
In this Cats Effect course, we go from practice to theory, until pure functional programming gets deep in your bones as a Scala developer.
This course is 100% compatible with Scala 2 and Scala 3.
This Cats Effect course is for experienced Scala developers
Make no mistake - Cats Effect can be difficult, and this course is for advanced developers.
- Solid computer science fundamentals are a must: how memory works, how threads work, and some general concepts about parallelism so that you understand the magic machinery of Cats Effect.
- You should be very comfortable with Scala as a language, at the level of the advanced course.
- As a bonus, if you are familiar with Cats, that'll help a lot, especially in the later parts of the course.
Even if you're experienced, learning Cats Effect on your own can take months (I certainly did when I started). This course will compress your learning time to 2-3 days if you're committed.
Skills you'll get after the course
First of all, this course will give you everything you need to be productive with Cats Effect:
- You'll deeply understand pure functional programming and what "effects" are
- You'll know how to build all sorts of composable programs with IO
- You'll be able write parallel and concurrent code with IOs, Fibers and the tools on top of them
- You'll be able to manage pinpoint program control, with tools like cancellation
- You'll be able to write concurrent, purely functional programs with concurrency primitives
- You'll be able to design your own concurrency tools based on those from Cats Effect
- You'll manage resources in a purely functional way
- You'll be able to write asynchronous code and compose synchronous and asychronous effects seamlessly
- You'll be able to generalize your code for any effect type and still maintain its properties and meaning
After this course, you'll be able to read and write any code, however complex, that has Scala with Cats Effect in it.
But most importantly, you'll develop timeless skills that you'll carry with you for your entire career, regardless of which language or tool you'll end up using:
- You'll deeply understand the practical benefits of pure functional programming in day-to-day projects
- You'll get a new perspective on what composability means
- You'll internalize timeless principles about reusability, effects-as-values, generic and composable code, functional design patterns and more
- You'll become more productive and happier as a developer
Meet Daniel
I'm a software engineer and the founder of Rock the JVM. I started the Rock the JVM project out of love for Scala and the technologies it powers - they are all amazing tools and I want to share as much of my experience with them as I can.
As of June 2021, I've taught Java, Scala and related tech (e.g. Akka, Cats, Spark) to 41000+ students at various levels and I've held live trainings for some of the best companies in the industry, including Adobe and Apple. I've also taught university students who now work at Google and Facebook (among others), I've held Hour of Code for 7-year-olds and I've taught more than 20000 kids to code.
You're on good hands in this course. I'll guide you every step of the way, and our private community at Rock the JVM is full of passionate people just like you.
Videos and Chapters
This Cats Effect course has 40+ HD videos, totalling 15 hours of hands-on learning. In total, we write 3000 lines of code from scratch.
- Ref (21:13)
- Ref: Exercises (13:39)
- Deferred (30:41)
- Deferred: Exercises (23:11)
- Ref + Deferred Exercise: A Purely Functional Mutex (24:18)
- Ref + Deferred Exercise: A Purely Functional Mutex, Part 2 (14:23)
- Semaphore (19:01)
- CountDownLatch (27:40)
- CountDownLatch Exercise: Writing Our Own (11:37)
- CyclicBarrier (18:25)
- Polymorphic Cancellation: MonadCancel (18:50)
- Polymorphic Cancellation: Exercise (18:28)
- Polymorphic Fibers: Spawn (23:55)
- Polymorphic Coordination: Concurrent (16:26)
- Polymorphic Coordination: Exercise (21:14)
- Polymorphic Timeouts: Temporal (10:24)
- Polymorphic Synchronous Effects: Sync (22:17)
- Polymorphic Asynchronous Effects: Async (23:21)
Course Bundles
Look at the options below - they give you access to more courses at a more affordable price.
Risk-free: 100% money back guarantee.
If you're not happy with this course, I want you to have your money back. If that happens, email me at [email protected] with a copy of your welcome email and I will refund you the course.
Less than 0.1% of students refunded a course on the entire site, and every payment was returned in less than 72 hours.
FAQ
1. How long is the Cats Effect course? Will I have time for it?
The course is a whole 15 hours in length, and we write 3000 lines of code from scratch. I recommend going through the course in sessions of at least 30 minutes each.
2. What does a typical lesson contain?
The course is hands-on, so most of the time will be spent writing code. I'll guide you every step of the way, explaining what each bit means. We'll also have some theoretical sections in the lessons as appropriate.
3. Can I expense this at my company?
Of course! After you enroll, you'll automatically get an invoice which you can use to reimburse this course with your employer.
4. Is Cats Effect hard?
Usually. The learning curve is steep if you're doing it on your own. That's why I made this course, to compress your learning time to just a couple of days, with a smooth progression and lots of practice.
5. What if I'm not happy with the course?
If you're not 100% happy with the course, I want you to have your money back. It's a risk-free investment.
6. Daniel, I can't afford the course. What do I do?
Check out the membership. It gives you access to everything on the site at an affordable price, and you'll be done with the course no problem.
7. I'm just getting started with Scala. Can I take this course?
Short answer: probably not. Longer answer: we have some Scala starter code at the beginning of the course, but that won't replace the kind of experience we need for this course. I recommend you check out the Scala essentials and advanced courses first before coming back here.