What's inside
The TLDR version in video form:
What is ZIO?
ZIO is a Scala toolkit that allows us to write powerful, concurrent, and high-performance applications in Scala using pure functional programming.
Zay What?!
ZIO describes what it means to perform an "effect" in your code. It is a powerful model that allows us to compose any kind of actions, deal with parallelism, concurrency and coordination, all strongly typed with Scala's unparalleled type system.
On top of the main ZIO "effect" type, the ZIO library comes with powerful tools built on battle-tested practices and design patterns, so we can write more easily composable code.
The end result is powerful applications, fewer bugs, more expressive and easily understandable code, and most importantly, more peace of mind and productivity for us as Scala developers.
This is what you'll learn in this course.
How this ZIO course works
ZIO is pragmatic and so are we.
As with anything at Rock the JVM, this course is hands-on. We start from first principles and don't assume any ZIO experience. We discover ZIO effects and how to use them, then we'll learn how to compose complex code, how to introduce parallelism and concurrency to our applications, how to run critical code flows safely and how to test everything, all through practical examples and exercises. In total, we write more than 3000 lines of code in this 13-hour course.
It's not just about the ZIO APIs, though - this course will teach you timeless principles for pure functional programming and high-performance applications so that you can take them with you even if you stop using ZIO (or Scala).
This course deconstructs and sequences all the important topics in ZIO. You don't need any other resource once you start. Just sit back and do the work with me on camera.
In this ZIO course, we go from practice to theory, until pure functional programming gets deep in your bones as a Scala developer.
You can write both Scala 3 and Scala 2 in this course, as we support both.
This ZIO course is for experienced Scala developers
I'll be upfront: some aspects of ZIO can be difficult, and this course is for advanced developers.
- You need some solid CS fundamentals: memory, threads, parallelism, maybe some design patterns. These foundations are useful to understand the underlying ZIO machinery.
- You should be very comfortable with Scala as a language, at the level of the advanced course.
Even if you're experienced, learning ZIO on your own can take months. This course took almost a year to create, but you can learn everything in a weekend.
Skills you'll get after the course
This course will give you everything you need to be productive with ZIO:
- You'll make the difference between pure/impure FP and you'll know what "effects" are
- You'll know how to build applications and composable programs with the ZIO effect
- You'll be able write parallel and concurrent code with ZIOs, Fibers and the tools on top of them
- You'll be able to manage pinpoint program control, with careful interruption mechanisms
- You'll be able to write concurrent, purely functional programs with coordination primitives
- You'll be able to design your own concurrency tools based on the built-in ones from ZIO
- You'll manage resources in a purely functional way with the acquire-release pattern
- You'll be able to write asynchronous code and compose synchronous and asychronous effects seamlessly in the same code
- You'll use battle-tested practices for dependency injection and separation of concerns
- You'll be able to test everything with powerful tools including property-based testing
After this course, you'll know everything you need to work with ZIO in your project.
Most importantly, you'll get timeless skills that you'll carry with you forever, 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 it means to write composable code
- You'll internalize language and framework-agnostic ideas about code organization, design patterns, programs-as-values and more
- You'll become more productive and happier as a developer
Hi, I'm 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 ZIO course has 37 HD lessons, totalling 13 hours of hands-on learning. In total, we write 3000 lines of code from scratch.
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 ZIO course? Will I have time for it?
The course is a whole 13 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 a tax-compliant receipt which you can use to reimburse this course with your employer.
4. Is ZIO hard?
It's not rocket science, but it's not trivial either. The learning curve is steep if you're doing it on your own. Materials are scarce. 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.
8. Where did you get the banner art for the coursse?
I'm cheating a bit because this is a made-up FAQ, but it's an opportunity to credit freepik.com for the drawing I used for the banner. Needless to say the ZIO logo belongs to the ZIO creators. I'll just keep the Rock the JVM logo.