What referential transparency and immutability mean in working Scala code, the reasoning and concurrency advantages they provide, and where controlled state remains the better engineering choice.
How lazy val, def, call-by-name parameters, LazyList and effect suspension differ, and the initialization, memory, concurrency and debugging trade-offs behind deferred work.
How case classes, sealed traits and enums form product and sum types, how they remove invalid combinations, and what they cost at API, persistence and evolving-codebase boundaries.
How FS2 represents effectful streams, controls demand, manages resources and concurrency, and turns large or continuous workloads into testable Scala programs.
How category-theoretic ideas influence map, flatMap, typeclasses and effect libraries, and how to use that vocabulary without turning application code into an abstraction exercise.
How unit and integration tests provide different evidence, where mocks and real adapters belong, and how to build a suite that stays fast without testing away production risk.
How to choose and transform immutable Scala collections, avoid accidental work, and recognise the performance and semantic differences between List, Vector, Set, Map, View and Iterator.
How recursive Scala functions use the call stack, how @tailrec makes constant-stack loops possible, and when folds or explicit work queues are the clearer design.
How implicit parameters, implicit scope and context bounds work in Scala 2.13, how Scala 3 expresses the same ideas, and where invisible dependencies become a maintenance problem.
A feature that needs shipping, an ageing service that needs attention, or a deployment that has become harder than the code. Talk to us about your problems.