Learning Paths

Choose a Path

Each journey covers one topic. The recommended paths put them in order for different goals.

All Journeys at a Glance

JourneyExercisesLevel
Core: Foundations37Beginner
Core: Error Handling26Intermediate
Core: Advanced Patterns26Advanced
Effect API17All Levels
Monad Transformers29Advanced
Concurrency: VTask28Intermediate
Concurrency: Scope & Resource20Intermediate
Context59Advanced
Effect Handlers19Advanced
Optics: Lens & Prism30Beginner
Optics: Traversals & Practice28Intermediate
Optics: Fluent & Free DSL22Advanced
Optics: Focus DSL90Intermediate
Optics: Batching & Coupled Updates13Advanced
Optics: Boundary Mapping19Intermediate
Expression: ForState13Intermediate
Expression: ForPath Parallel9Intermediate
Resilience Patterns24Intermediate
Capstone: One Line, Six Layers Grows Up7Intermediate

Start Here

Path A: Effect-First is the recommended path for most users. It teaches the primary user-facing API of Higher-Kinded-J and gets us productive quickly.

The modern approach: start with the user-friendly Effect API.

SessionJourney
1Core: Foundations
2Effect API: Fundamentals
3Effect API: Advanced
4Optics: Lens & Prism
5Expression: ForState

Total: 5 sessions

Best for: New users who want the recommended learning experience.

Path B: Quickstart

Get productive with Higher-Kinded-J quickly.

SessionJourney
1Core: Foundations
2Effect API: Fundamentals

Total: 2 sessions

Best for: Developers who want to use the library immediately without deep theory.

Path C: Practical FP

Core functional patterns for everyday use.

SessionJourney
1Core: Foundations
2Core: Error Handling
3Effect API: Fundamentals
4Optics: Lens & Prism
5Expression: ForState

Total: 5 sessions

Best for: Developers building production applications who want solid foundations.

Path D: Core Types Deep Dive

Master the theoretical foundation.

SessionJourney
1Core: Foundations
2Core: Error Handling
3Core: Advanced Patterns

Total: 3 sessions

Best for: Developers who want to understand the FP theory deeply before applying it. Pair this path with the Foundations chapter of the book; the journeys exercise the concepts that the book explains.

Path E: Optics Specialist

Master immutable data manipulation.

SessionJourney
1Optics: Lens & Prism
2Optics: Traversals & Practice
3Optics: Fluent & Free DSL
4Optics: Focus DSL
5Optics: Batching & Coupled Updates
6Optics: Boundary Mapping

Total: 6 sessions

Best for: Developers working with complex immutable data structures who want to master optics, through to the generated DTO boundary.

Path F: Full Curriculum

Everything, done properly over multiple sessions.

SessionJourney
1Core: Foundations
2Core: Error Handling
3Core: Advanced Patterns
4Effect API: Fundamentals
5Effect API: Advanced
6Monad Transformers
7Effect Handlers
8Expression: ForState
9Expression: ForPath Parallel
10Concurrency: VTask
11Concurrency: Scope & Resource
12Context
13Resilience Patterns
14Optics: Lens & Prism
15Optics: Traversals & Practice
16Optics: Fluent & Free DSL
17Optics: Focus DSL
18Optics: Batching & Coupled Updates
19Optics: Boundary Mapping
20Capstone: One Line, Six Layers Grows Up

Total: 20 sessions

Best for: Comprehensive mastery of Higher-Kinded-J.

Combined Journeys

These pairs build on each other and work well taken back to back:

Error Mastery

Combine Core: Error Handling + Core: Advanced Patterns

Focus: Complete error handling and advanced FP patterns together.

DSL Power

Combine Optics: Fluent & Free DSL + Optics: Focus DSL

Focus: Master both the Free Monad DSL and the Focus DSL together.

Effect API Complete

Combine Effect API: Fundamentals + Effect API: Advanced

Focus: Master the complete Effect Path API from basics to advanced contexts and annotations.

Concurrency Complete

Combine Concurrency: VTask + Concurrency: Scope & Resource

Focus: Master virtual threads, structured concurrency, and resource management together.

Tips for Success

  1. Pause between tutorials, not inside one. A break between tutorials or journeys helps consolidation.
  2. Don't skip the struggle. When an exercise is hard, that is where learning happens. Consult solutions only after genuine effort.
  3. Run the tests. The red-to-green feedback loop is essential. Don't just read the exercises.
  4. Revisit earlier journeys. After completing later journeys, earlier concepts often make more sense. Circle back.
  5. Apply immediately. After each journey, try using what we learned in our own code.

Previous: Expression: ForState Next: Solutions Guide