Scala Language

Scala 3 contextual abstraction

Deep-dive on Scala 3's redesigned implicits: given instances and using clauses, type-class composition and Mirror-based deriv…

Scala 3 metaprogramming

Deep-dive on Scala 3 metaprogramming: inline defs and compile-time branching, typed quotes and splices, macro construction, Mirror-based structural re…

Scala 3 Deprecations

What's dropped from Scala 2.

Scala 3 Enums

Sealed + case classes shorthand.

Scala 3 Extension Methods

extension def block. Cleaner than implicit class.

Scala 3 Given + Using

Modern implicit replacement.

Scala 3 Indent-Based Syntax

Braces optional. Python-like.

Scala 3 Match Types

Type-level pattern matching.

Scala 3 Migration Guide

-source:3.x compiler flags.

Scala 3 Stability + Roadmap

Where language is heading.

Scala 3 Top-Level Definitions

def, val outside object/class.

Scala 3 Transparent Inline

Compile-time inlining.

Scala Akka Actors Introduction

Actor model. Untyped legacy.

Akka Cluster architecture

Deep-dive on Akka Cluster: seed nodes, gossip convergence, phi-accrual failure detector, split brain resolver, cluster sharding, singleton, distribute…

Akka HTTP -- streaming-first HTTP on actors and streams

Deep-dive on Akka HTTP: the composable directive routing DSL, marshalling, the Akka Streams entity foundation, end-to-end backpressure, connection poo…

Akka

How Akka implements the actor model for Scala and Java, powering distributed systems.

Akka Persistence architecture

Deep-dive on Akka Persistence: EventSourcedBehavior command/event handlers, journal plugins and sequence integrity, snapshot-bounded recovery, seriali…

Akka Streams

Backpressure. Reactive Streams.

Akka Streams architecture

Deep-dive on Akka Streams: Source/Flow/Sink blueprint algebra, materializer and operator fusion, Reactive Streams demand signaling, async boundaries, …

Akka Typed Actors

Compile-time message type safety.

Akka Typed architecture

Deep-dive on Akka Typed: sealed message protocols, Behavior[T] as functional state transitions, ActorRef[T] and compile-time mailbox safety, ActorCont…

Scala Array

JVM primitive. Fast.

Scala Arrays + Buffers

ArrayBuffer for dynamic. ListBuffer.

Scala Await

Await.result. Rare in prod code.

Scala blocking Block

Signal blocking to EC.

Scala Case Classes

How case classes model immutable data, why they include equality, copy, and pattern matching for free, and how to design case class hierarchies.

Cats Effect

How Cats Effect provides the effect system that underlies many Scala functional libraries.

Cats Effect runtime architecture

Deep-dive on Cats Effect 3: the IO run loop, work-stealing pool with per-worker timers, IO.blocking isolation, cancellation and Poll, Resource lifecyc…

Scala Cats Library

Type classes for FP.

Scala Circe

How Circe provides purely functional JSON handling in Scala.

Scala Classes

class with primary constructor in signature.

Scala Closures

Functions capture outer variables.

Scala Collections

The Scala collections library: List, Vector, Map, Set, and when to use each. Immutable versus mutable trade-offs.

Scala collections performance

Deep-dive on Scala collections performance: List/Vector/Array/Map operation costs, strict vs view vs iterator transforms, intermediate-collection allo…

Scala Companion Objects

object with same name as class.

Scala Compiler Plugins

How Scala compiler plugins extend behavior at compile time.

Scala Control Flow

if/else as expression. while. for.

Coursier

Fetches artifacts. cs setup.

Scala Currying

Partial application. def add(a)(b) form.

Scala Doobie

How Doobie provides purely functional JDBC access for Scala.

doobie architecture

Deep-dive on doobie: the sql interpolator and fragment algebra, ConnectionIO composition as transaction boundaries, Transactor and Hikari pool alignme…

Scala DSL Design Patterns

Method chaining + infix + implicits.

Scala Effect Systems Compared

How ZIO and Cats Effect compare as Scala effect systems.

Scala Either

Left = error, Right = value.

Scala ExecutionContext

Where Futures run.

Scala Existential Types

Forall for type parameters. Scala 3 removed.

Scala Extension Methods

Add methods to existing types.

Scala Factory Pattern

apply on companion. Constructor hidden.

Finagle architecture — Service/Filter composition, P2C load balancing, retry budgets, and Mux

Deep-dive on Finagle RPC: the Service-as-function abstraction, filter and stack composition, name resolution and dtabs, power-of-two-choices and apert…

Scala fold + map + filter

Standard collection HOFs.

Scala For-Comprehensions

Syntactic sugar for flatMap/map/filter.

Scala Free Monads

Programs as data. Interpreter pattern.

Scala Free Monads Deep

Program = data, interpreter runs.

Scala fs2

How fs2 provides functional streaming for Scala on Cats Effect.

fs2 streaming architecture

Deep-dive on fs2: the Pull-based demand-driven core, chunked throughput, scoped resource safety, merge/parEvalMap/concurrently semantics, fs2-io and f…

Scala Functional Error Handling

Either/Try/Validated over throw.

Functions as Values

First-class. Store, pass, return.

Functor + Applicative

map + ap building blocks.

Scala Futures

How Scala Futures represent async computations, how map/flatMap chain them, and how ExecutionContext controls concurrency.

Scala Futures and ExecutionContext

Deep-dive on scala.concurrent.Future: eager memoized async values, ExecutionContext thread pools, blocking isolation, map/flatMap composition and comb…

Scala Generic Types

Type parameters. Variance annotations.

Scala groupBy + Partition

Group elements by key.

Scala Higher-Kinded Types

Types with type parameters.

Scala Higher-Order Functions

How Scala treats functions as first-class values, the common HOFs (map/filter/fold), and how they enable functional-style data pipelines.

Higher-Order Functions in Scala

Functions as first-class values.

Scala http4s

How http4s provides purely functional HTTP client + server for Scala.

http4s architecture

Deep-dive on http4s: HttpRoutes as Kleisli functions, middleware stacks as composition, entity codecs, fs2 streaming bodies with end-to-end backpressu…

Scala Immutable vs Mutable Collections

Default immutable. Explicit mutable via import.

Scala Implicits

How Scala implicits enable type classes, extension methods, and DSL construction. Powerful but easily abused.

Scala Implicits (2) vs Given/Using (3)

Type class + DI mechanism.

Scala iron

How iron provides modern refinement types for Scala 3.

Scala Iterators

Single-pass. Lazy.

Scala kittens

How kittens automatically derives Cats type classes for case classes.

Scala Lagom

How Lagom provides reactive microservices for Scala/Java.

Scala Lazy Evaluation

lazy val + LazyList + views.

Scala LazyList (was Stream)

Lazy immutable list. Infinite possible.

Scala List

Cons + Nil. Head-append optimal.

Scala Macros

Compile-time metaprogramming.

Scala Map

HashMap default. Multiple impls.

Scala Memoization Patterns

Cache results. mutable.Map or 3rd-party.

Scala Metals

How Metals provides fast, lightweight IDE features for Scala via LSP.

Scala Metaprogramming

How Scala's macros and mirrors enable compile-time metaprogramming.

Scala Methods vs Functions

def vs val = (x) =>. Distinct concepts.

Scala Mill Build Tool

Modern faster alternative to sbt.

Scala Mixins

Compose traits. Diamond linearization.

Scala Monadic Composition

flatMap + map chains.

Scala Monads

How Option, Either, Try, and Future embody the monad pattern for context-aware computation.

Scala Monads Introduction

Option, Either, List, Future all monadic.

MUnit

Fast + simple. JUnit-compatible.

Scala 3 Opaque Types

Type alias with hidden implementation.

Scala Option

Some or None. Explicit optionality.

Scala Ordering + Sorting

Ordered trait + Ordering type class.

Scala Overview

What Scala is, why it fused functional and object-oriented paradigms on the JVM, and where it fits versus Java, Kotlin, and pure functional languages.

Scala Parallel Collections

.par for parallelism.

Scala Partial Application

Apply some args now, rest later.

Scala Path-Dependent Types

Types depending on values.

Scala Pattern Matching

How pattern matching works: literals, constructors, guards, extractors, and how sealed hierarchies enable compile-time exhaustiveness checking.

Scala Phantom Types

Compile-time-only type tags.

Scala Play Framework

How Play provides async Scala web dev with Akka underneath.

Play Framework architecture

Deep-dive on Play Framework: typed routing and reverse routes, Action composition and body parsers, the default vs blocking execution-context discipli…

Scala Promise

Write-once handle for Future.

Scala 3 Quotes + Splices

Modern metaprogramming.

Scala Ranges

1 to 10, 1 until 10. Efficient sequences.

Referential Transparency

Same input → same output. Foundation of FP.

Scala refined

How refined provides refinement types (predicates + values) for Scala.

Scala Reflection

Runtime + compile-time.

Scala Sangria

How Sangria provides GraphQL server implementation for Scala.

sbt

How sbt handles Scala builds: dependencies, compilation, testing, packaging.

sbt architecture

Deep-dive on sbt internals: load-time settings graph vs per-run task DAG, scope axes and delegation, Zinc API-hash invalidation, Coursier resolution, …

Scala 3

The major changes in Scala 3: enums, given/using, extension methods, cleaner syntax.

ScalaCheck Property Testing

Generate test cases. Find edge cases.

Scala scalafix

How scalafix lints + auto-refactors Scala code.

Scala.js

How Scala.js compiles Scala to efficient JavaScript for full-stack Scala.

Scala Native

How Scala Native compiles Scala to native binaries via LLVM.

ScalaTest Framework

Popular testing library.

Scala scodec

How scodec provides type-safe binary encoding/decoding.

Scala Sealed Traits + ADTs

Algebraic Data Types via sealed.

Scala Self Types

this: T => declares dependency.

Scala Set

HashSet default. TreeSet sorted.

Scala Shapeless

How Shapeless enables generic programming with HLists + case class magic.

Scala Shapeless 3

How Shapeless 3 adapts shapeless to Scala 3.

Scala sliding + grouped

Windowed views over collection.

Scala Streams

How Scala LazyList (Stream in Scala 2) provides lazy sequence processing.

scala_string_interpolation

Scala Structural Types

Duck typing at compile time.

Scala Tagless Final

Modern effect polymorphism.

Scala Tail Recursion

@tailrec annotation. No stack overflow.

Scala Tapir

How Tapir enables describing APIs as data + deriving server + client + docs.

Tapir architecture

Deep-dive on Tapir: the Endpoint[I,E,O] description algebra, schema and codec derivation, server/client/OpenAPI interpreters from one value, oneOf err…

Scala Testing

The main Scala testing frameworks and property-based testing.

Scala Traits

Multiple inheritance safe. Diamond OK.

Scala Traverse + Sequence

Turn F[G[A]] into G[F[A]].

Scala TrieMap

Lock-free hash trie map.

Scala Try

Success or Failure. Bridges exceptions.

Scala Tuples

Fixed-size heterogeneous groups.

Scala Type Classes

Ad-hoc polymorphism via implicit.

Scala Type Inference

Omit types where obvious. Compiler infers.

Scala Type-Level Programming

Encode logic in types.

Scala Type System

The Scala type system: generic types, variance annotations, higher-kinded types, and type classes. Why it enables libraries like Cats.

Scala Type Class Patterns

How type classes enable extensible polymorphism in Scala, and the patterns that make them work.

Scala val vs var

Prefer val. Immutable references.

Scala Value Classes

AnyVal wrapper. No allocation cost.

Scala Vector

32-way trie. O(log32) access.

Scala Views

.view then transform. .to force.

Scala ZIO Fibers

Lightweight concurrency. Cancelable.

ZIO Introduction

How ZIO provides functional effect system for Scala with excellent ergonomics.

ZIO runtime architecture

Deep-dive on the ZIO runtime: effect values and the interpreter, fiber scheduling and work stealing, blocking pool isolation, typed error causes, inte…