Typelevel Rite of Passage

Create a full-stack Scala application using the Typelevel stack in our comprehensive course: learn to integrate features like credit card checkout and emails. Perfect for hands-on, real-world development experience.

Take this course

What's inside?

Goal

Build a Full-Stack Application with Scala 3 and the Typelevel Stack

Just as Scala has transformed the way we build applications with functional programming, the Typelevel stack is changing how we build strong, testable and provably correct APIs.

With a focus on functional Scala and a real world application, this course is a start-to-finish way to learn Full Stack Scala 3 with Cats, Cats Effect and friends.

Join me as I show you how to build a full stack jobs platform with the latest evolution of Scala and functional libraries.

What is Typelevel?

Typelevel is a set of Scala libraries for building robust, scalable and high-performance applications.

Say what?

The foundation for Typelevel is pure functional programming and Scala’s unmatched type system. With these tools, we can let the Scala compiler work in our favor, so we can write more modular code and in the end become more productive and happier as developers.

We will use all major Typelevel tools and libraries in this course.

How This Course Works

What will you build?

Together we will build the Rock the JVM Jobs Board, a full stack online jobs platform with credit card integration. Users can create and manage their account, post and view jobs, and apply for them.

We will build the application from scratch, using a decoupled layered architecture on the backend, and an Elm-like architecture on the frontend with ScalaJS.

The app includes many server-side bits including authentication, permissions, sending email, uploading images, and charging credit cards. We have almost complete test coverage in the backend, and we develop some core modules with test-driven development (TDD).

The frontend is built as a single-page application, organized for for scalability if you want to add new pages or functional components.

For a full list of topics covered, see below.

”Real-Life” means Real-LIVE

I want to put my code where my mouth is.

The application that you learn to build in this course is fully deployed and live here:

jobs.rockthejvm.com

Yes, it’s a real jobs platform that I will personally use for my students at Rock the JVM!

If you’re a company and want to promote your jobs to the Rock the JVM community, go ahead and use it!

And before you ask: yes, I’ll teach you to do EVERYTHING from an empty dir to deploying on your own domain.

This isn’t even a “project-based” course. You will learn to build a full-blown product that people can use and pay for. You can build your startup with what you learn in this course.

Who Is This Course For?

Scala developers who want to expand their Scala skills with a full-blown product as a full-stack application.

You should be comfortable writing any sort of Scala code, as we don’t go over the Scala fundamentals. The beginner and advanced Scala courses focus on the language.

You should already be familiar with Cats and Cats Effect. We’ll do a round of recap at the beginning of the course, but we’ll focus more on the project.

The frontend is written in ScalaJS with Tyrian. Any experience with them is nice, but 100% not needed.

To sum up, this course is for

anyone looking for a complete end-to-end Scala project
backend developers looking to go full-stack on Scala
Scala developers looking to advance their skills and career
anyone who wants to get better at Scala, full-stack architecture or functional programming

Not sure if it’s for you? 100% money back if it’s not a fit for you 💰

In any case, don’t be scared. We’ll build something great together.

100% Practical

This course is long so we waste no time. This screenshot shows you what you’ll write.

As with anything at Rock the JVM, this course is hands-on. We start by recapping the fundamentals of major Typelevel libraries (Cats, Cats Effect, Doobie, Http4s etc) and then we get started.

We’ll build the project from scratch, starting from a blank directory and from first principles. As our code becomes more complex, we will modularize as necessary.

We will arrive at our decoupled layered architecture organically, without my imposing any style on you from the start. You will find it quite extensible and modular.

A big chunk of the backend is written in test-driven development style. We also have chunks where we write tests after the implementation, so that you feel the difference first-hand. In any event, we do extensive testing and our app will be robust.

As for the frontend, we will add ScalaJS support from scratch, then we’ll start scaffolding our app for scalability so you can easily add a new page or stateful component.

We will also design our domain in a careful way so that the frontend and backend share the same definitions, eliminating nasty bugs due to schema mismatches.

The Tech Stack

Cats

The functional programming library for Scala. We will use it to make our code modular, expressed in terms of capabilities.

Cats Effect

The Scala library that allows us to write composable and high-performance applications with pure functional programming. Every action we perform is built with Cats Effect.

Doobie

The Typelevel library that allows us to work with databases, using type-safe queries. We will use PostgreSQL as an actual database.

Http4s

With this Typelevel library we'll build our REST APIs with JSON payloads, automatic validation, incremental content loading with pagination etc., as well as manage authentication, authorization with JWTs and role-based access control.

Tyrian

A lightweight Scala 3 library for single-page applications in a purely functional way, Elm-style. While not "officially" a Typelevel project, it is based on Cats Effect and FS2 to manage application state. Our entire frontend is built with Tyrian (routing, authentication flow, checkout, error/success UI state, fetching data from backend)

Honorable Mentions

PureConfig for configuration
FS2 for incremental loading on the backend
FS2 for SPA history management on the frontend
TSec for JWT authorization and RBAC
Circe for JSON
Log4Cats for purely-functional logging
ScalaTest with TestContainers wrapped in Cats Effect

Skills You'll Learn

Skills You’ll Learn & Practice

In each video, we learn and implement a concept into our application. We’ll sometimes use these repeatedly to solve new problems.

Because we build a full-stack Scala application, this course covers a ton. Here are some of the things you can expect to learn:

REST APIs
Authentication
Authorization with JWTs
Role-Based Access Control
Sending Email
Validating/Invalidating User Sessions
User Input Sanitizing & validation
Charging Credit Cards
Hosting and Transforming Images
Incremental Loading and Pagination
Complex Backend Filters
Loading and Error states
Elm Frontend Architecture
Routing
Asynchronous Effects
Webhooks
Layering and Decoupling Modules
Configuration
Shared domain models
Test-driven development
Mocking
Test Containers
Building & Configuring for Dev, Staging and Prod
Deployment With Custom Domains

Meet Rock the JVM

Daniel Ciocîrlan

I'm a software engineer and the founder of Rock the JVM.

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 February 2024, I've taught Java, Scala, Kotlin and related tech (e.g. Cats, ZIO, Spark) to 100000+ students at various levels and I've held live training sessions 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 35000 kids to code.

I have a Master's Degree in Computer Science and I wrote my Bachelor and Master theses on Quantum Computation. Before starting to learn programming, I won medals at international Physics competitions.

In Collaboration with Riccardo Cardin

Riccardo Cardin is a proud Rock the JVM alumnus and senior software engineer focusing on high-performance systems in Scala, Kotlin and Java.

He is also one of the two leading lecturers of the Software Engineering course inside the Computer Science BSc, hosted by Dipartimento di Matematica of the University of Padova.

Riccardo is actively interested in the application of design patterns and design best practices. He is constantly increasing his knowledge of the software's design and development continuously, which brought him to Rock the JVM.

With Special Thanks To

Dave Smith, the maintainer of Tyrian, for quickly reviewing and merging my PR that injects custom HTML. This allows our app to render Markdown on the frontend (pretty cool!).

@fellownoodle for the amazing Rite of Passage banner.

What's Included

Loading...

Take this course now!