Course overview
A complete Scala 3 course for developers who already understand basic programming. Learners build strong language foundations, immutable transformations, precise domain models, reusable abstractions, controlled asynchronous workflows, and a production batch validation service.
Who this is for
You know the fundamentals and want structured practice that turns knowledge into production habits.
Prerequisites
No previous OSEKOO ACADEMY course is required. Use the optional diagnostic to confirm your starting point.
Syllabus
Each unit combines explanation, guided practice, a checkpoint, and practical evidence. Open a unit to review the exact sequence.
1. Getting Started with Scala 39 lessons
Prerequisites: Python Basics or equivalent programming experience.
Unit outcomes
- Apply the Scala 3 concepts introduced in Getting Started with Scala 3.
Unit project
Mini-Project: Command-Line Welcome Application
Lesson sequence
- What Scala Is and Where It Fits · Free preview
- Understanding Scala, Java, and the JVM
- Installing the Scala Development Environment
- Creating a Reproducible sbt Project
- Understanding the Scala Project Structure
- Running Code in the REPL and Source Files
- Writing Your First Scala 3 Application
- Reading Compiler and Runtime Errors
- Mini-Project: Command-Line Welcome Application
2. Values, Types, and Expressions10 lessons
Prerequisites: Completion of Chapter 1.
Unit outcomes
- Apply the Scala 3 concepts introduced in Values, Types, and Expressions.
Unit project
Mini-Project: Measurement Conversion Tool
Lesson sequence
- Declaring Immutable Values with val
- Using Controlled Mutation with var
- Type Inference and Explicit Type Annotations
- Working with Integers and Floating-Point Values
- Using BigDecimal for Exact Calculations
- Working with Strings, Characters, and Booleans
- Formatting Values with String Interpolation
- Understanding Expressions, Blocks, and Unit
- Parsing and Converting Values Safely
- Mini-Project: Measurement Conversion Tool
3. Control Flow and Pattern Matching10 lessons
Prerequisites: Completion of Chapter 2.
Unit outcomes
- Apply the Scala 3 concepts introduced in Control Flow and Pattern Matching.
Unit project
Mini-Project: Configurable Pricing Rules Engine
Lesson sequence
- Boolean Logic and Comparison Expressions
- Making Decisions with if and else
- Understanding Expression-Oriented Control Flow
- Introducing match Expressions
- Matching Literal Values and Wildcards
- Adding Conditions with Pattern Guards
- Repeating Operations with Ranges and for
- Using while Inside Controlled Mutation Boundaries
- Choosing the Appropriate Control Structure
- Mini-Project: Configurable Pricing Rules Engine
4. Functions and Functional Foundations10 lessons
Prerequisites: Completion of Chapter 3.
Unit outcomes
- Apply the Scala 3 concepts introduced in Functions and Functional Foundations.
Unit project
Mini-Project: Functional Text Processing Toolkit
Lesson sequence
- Defining and Calling Functions
- Understanding Parameters and Arguments
- Default and Named Parameters
- Return Types and Unit Functions
- Local Functions and Scope
- Function Values and Lambda Expressions
- Writing Higher-Order Functions
- Understanding Closures
- Currying and Partial Application
- Mini-Project: Functional Text Processing Toolkit
5. Immutable Collections and Data Transformations11 lessons
Prerequisites: Completion of Chapter 4.
Unit outcomes
- Apply the Scala 3 concepts introduced in Immutable Collections and Data Transformations.
Unit project
Mini-Project: Transaction Analytics Pipeline
Lesson sequence
- Understanding Scala's Collection Hierarchy
- Choosing Between List and Vector
- Working with Seq and Array
- Enforcing Uniqueness with Set
- Storing Key-Value Data with Map
- Transforming Elements with map
- Selecting Elements with filter and collect
- Expanding and Removing Values with flatMap
- Aggregating Data with fold and reduce
- Grouping and Summarising Data
- Mini-Project: Transaction Analytics Pipeline
6. Domain Modeling with Classes and Algebraic Data Types10 lessons
Prerequisites: Completion of Chapter 5.
Unit outcomes
- Apply the Scala 3 concepts introduced in Domain Modeling with Classes and Algebraic Data Types.
Unit project
Mini-Project: Order Lifecycle Model
Lesson sequence
- Defining Classes and Creating Instances
- Constructors, Fields, and Visibility
- Modeling Immutable Data with Case Classes
- Companion Objects and Factory Methods
- Defining Closed Domains with Enums
- Building Algebraic Data Types
- Pattern Matching on Domain Models
- Representing Optional Values with Option
- Updating Immutable Objects with copy
- Mini-Project: Order Lifecycle Model
7. Traits, Composition, and Object-Oriented Design10 lessons
Prerequisites: Completion of Chapter 6.
Unit outcomes
- Apply the Scala 3 concepts introduced in Traits, Composition, and Object-Oriented Design.
Unit project
Mini-Project: Repository-Based Inventory Service
Lesson sequence
- Defining Behavior with Traits
- Abstract and Concrete Trait Members
- Using Trait Parameters
- Composing Behavior with Mixins
- Understanding Method Resolution and Linearization
- Using open, final, and sealed
- Choosing Between Inheritance and Composition
- Designing Small and Focused Interfaces
- Separating Domain Logic from Infrastructure
- Mini-Project: Repository-Based Inventory Service
8. Error Handling, Validation, and Resource Safety10 lessons
Prerequisites: Completion of Chapter 7.
Unit outcomes
- Apply the Scala 3 concepts introduced in Error Handling, Validation, and Resource Safety.
Unit project
Mini-Project: Typed CSV Validation Service
Lesson sequence
- Classifying Expected and Unexpected Failures
- Throwing and Catching Exceptions
- Representing Fallible Operations with Try
- Modeling Recoverable Failures with Either
- Creating Typed Domain Errors
- Composing Validation with For-Comprehensions
- Fail-Fast and Error-Accumulation Strategies
- Managing Files and Resources Safely
- Translating Infrastructure Failures at Boundaries
- Mini-Project: Typed CSV Validation Service
9. Generics and the Scala Type System11 lessons
Prerequisites: Completion of Chapter 8.
Unit outcomes
- Apply the Scala 3 concepts introduced in Generics and the Scala Type System.
Unit project
Mini-Project: Type-Safe Identifier Library
Lesson sequence
- Writing Generic Functions
- Creating Generic Classes and Traits
- Upper and Lower Type Bounds
- Understanding Covariance and Contravariance
- Working with Union Types
- Working with Intersection Types
- Type Aliases and Opaque Types
- Modeling Valid States with Precise Types
- Understanding Type Erasure on the JVM
- Reading Advanced Compiler Type Errors
- Mini-Project: Type-Safe Identifier Library
10. Contextual Abstractions and Reusable APIs10 lessons
Prerequisites: Completion of Chapter 9.
Unit outcomes
- Apply the Scala 3 concepts introduced in Contextual Abstractions and Reusable APIs.
Unit project
Mini-Project: Extensible Data Encoding Toolkit
Lesson sequence
- Understanding Contextual Parameters
- Declaring Context with given
- Requesting Context with using
- Finding Context with summon
- Introducing the Type Class Pattern
- Defining Extension Methods
- Organizing Type Class Instances
- Deriving Standard Behavior
- Avoiding Ambiguous and Hidden Dependencies
- Mini-Project: Extensible Data Encoding Toolkit
11. Concurrency, Testing, and Production Tooling12 lessons
Prerequisites: Completion of Chapter 10.
Unit outcomes
- Apply the Scala 3 concepts introduced in Concurrency, Testing, and Production Tooling.
Unit project
Mini-Project: Asynchronous Enrichment Pipeline
Lesson sequence
- Understanding Concurrency and Parallelism
- Representing Asynchronous Results with Future
- Managing Execution Contexts
- Composing Futures Without Blocking
- Sequencing and Traversing Asynchronous Operations
- Handling Asynchronous Failures
- Limiting Concurrency and Protecting Dependencies
- Designing Timeouts, Retries, and Idempotency
- Writing Automated Tests with MUnit
- Testing Asynchronous and Failure Scenarios
- Formatting, Static Analysis, and Compiler Warnings
- Mini-Project: Asynchronous Enrichment Pipeline
12. Final Project: Production Batch Validation Service12 lessons
Prerequisites: Completion of Chapter 11.
Unit outcomes
- Apply the Scala 3 concepts introduced in Final Project: Production Batch Validation Service.
Unit project
Final Project Review and Operational Runbook
Lesson sequence
- Defining Requirements and Acceptance Criteria
- Designing the Application Architecture
- Modeling the Domain with Precise Types
- Parsing CSV Input Records
- Implementing Typed Validation Rules
- Separating Accepted and Rejected Records
- Creating Deterministic Data Transformations
- Implementing Safe and Idempotent Output
- Adding Structured Errors, Logs, and Metrics
- Writing Unit, Integration, and Boundary Tests
- Packaging the Application and Configuring CI
- Final Project Review and Operational Runbook