↑ Contents · Contents · Ch 2 →
Chapters: Ch 1 · Ch 2 · Ch 3 · Ch 4 · Ch 5
ZIO / Scala Effect Systems
ZIO Actors (John De Goes tweet) John De Goes’s tweet introducing or discussing ZIO Actors — a library for building actor-based concurrent systems on top of ZIO’s fiber runtime. Actors provide location-transparent message passing as an alternative to direct functional composition. https://twitter.com/jdegoes/status/1600917565625270272
ZIO Telemetry OpenTelemetry integration for ZIO applications: tracing, metrics, and logging emitted via the OpenTelemetry standard. ZIO Telemetry enables distributed tracing across fiber-based services without manual instrumentation plumbing. https://github.com/zio/zio-telemetry
ZIO NIO Non-blocking I/O for ZIO built on Java NIO, providing purely functional wrappers for channels, selectors, and file operations. ZIO NIO allows building high-performance I/O pipelines that compose cleanly with other ZIO effects. https://github.com/zio/zio-nio
Alvin Alexander: What Are the Benefits of ZIO and FP? — ZIO Direct Alvin Alexander’s LinkedIn post prompted by a Twitter question on ZIO/FP benefits, using ZIO Direct as the entry point. ZIO Direct enables direct-style (non-monadic) Scala code that desugars to proper ZIO effect composition, lowering the learning curve significantly. https://www.linkedin.com/posts/alvinalexander_github-ziozio-direct-direct-style-programming-activity-7247368581145923584-gS3l
ZIO 2.x Migration Guide — zio.dev Official migration guide for upgrading from ZIO 1.x to ZIO 2.x: API changes, renamed combinators, the new ZIO Layer model, and the removal of Has type-class wiring. Essential reference for any production ZIO 1 codebase planning a version upgrade. https://zio.dev/guides/migrate/zio-2.x-migration-guide/
ZIO Schema ZIO Schema enables automatic derivation of serialization, validation, migration, and diffing logic from data type definitions, without runtime reflection. It is a core component of the Kyo AI project for JSON schema derivation from Scala case classes. https://zio.dev/zio-schema/
Zymposium: ZIO 2.0 (John De Goes, Adam Fraser) In-depth technical presentation of ZIO 2.0 by its creators: the new fiber-based runtime, performance improvements, the Layer model replacing manual dependency injection, and API simplifications. Essential viewing for Scala engineers planning a ZIO 2 adoption. https://www.youtube.com/watch?v=6A1SA5Be9qw
John De Goes — Reimagining Functional Type Classes John De Goes’s exploration of how to redesign functional type class hierarchies from scratch, addressing coherence, orphan instances, and deriving. A deep dive into the theoretical tensions and practical trade-offs of type class design in Scala. https://www.youtube.com/watch?v=oluPEFlXumw
Streams in ZIO (John De Goes tweet) Tweet discussing ZIO Streams — the ZIO library’s composable streaming abstraction built on fibers. ZIO Streams unify streaming and effect composition in a way that avoids the separate streaming monad transformer stacks required in other functional ecosystems. https://twitter.com/jdegoes/status/1565001020918034432
The Effect Pattern — Michael Arnaldi (effectful.co) Michael Arnaldi’s framework for thinking about effects in functional programming: the idea that effects represent descriptions of computations rather than executions, enabling compositional and testable programs. Arnaldi later developed the Effect TypeScript library based on these ideas. https://effectful.co
Compositional Resource Management in Scala 3 with ZIO Blog post by Pierre Ricadat on managing resources (database connections, file handles, HTTP clients) in a composable way using ZIO’s scoped resources and ZLayer. Demonstrates how resource lifecycle integrates naturally with ZIO’s effect composition. https://blog.pierre-ricadat.com/compositional-resource-management-in-scala-3-with-zio
Kyo Effect System
Kyo — Scala 3 Effect System (Flavio Brasil) Kyo is a novel Scala 3 effect system by Flavio Brasil that encodes algebraic effects without monad transformers, using an intersection type approach for effect composition. Unlike ZIO’s monadic stack, Kyo effects are composable through normal function calls, enabling direct-style code without desugaring steps. https://github.com/getkyo/kyo
kyo-chatgpt Example A small application demonstrating Kyo effects integrated with OpenAI’s ChatGPT API, showing how AI interactions compose with other effects (IO, error, concurrency) in a Kyo application. Predecessor to the kyo-ai project. https://github.com/fwbrasil/kyo/tree/main/kyo-chatgpt
Kyo: Crafting Scala’s Futuristic Effects (YouTube) Conference talk by Flavio Brasil introducing Kyo’s intersection-type effect encoding, explaining why it avoids the monadic composition tax and how it achieves performance competitive with direct IO implementations. https://www.youtube.com/watch?v=cyGSLCXR4Bo
Safe Direct-Style Scala / Structured Concurrency
Safe Direct-Style Scala: Ox 0.1.0 Released (SoftwareMill) Ox is a SoftwareMill library for structured concurrency in Scala 3 using direct style — no monads, no futures, just blocking fibers with structured lifetime scopes. The 0.1.0 release announcement explains the design goals and how Ox compares to ZIO and cats-effect. https://softwaremill.com/ox-0-1-0-released-safe-direct-style-scala/
Comparing Approaches to Structured Concurrency (LambdaConf 2024) James Ward and Adam Hearn compare structured concurrency models across Scala (ZIO, cats-effect, Ox), Kotlin coroutines, and Go, examining how each handles cancellation, error propagation, and resource safety. Provides a vendor-neutral framework for evaluating concurrency abstractions. https://www.youtube.com/watch?v=g6dyLhAublQ
EasyRacer LambdaConf 2024 (James Ward) EasyRacer is a benchmark comparing how different frameworks and languages implement ten concurrent racing scenarios — selecting the first successful result from parallel tasks. Used in the LambdaConf talk to objectively compare ZIO, cats-effect, Ox, Akka, and other approaches. https://jamesward.github.io/easyracer/
Coroutines and Effects (without.boats) Withoutboats’s essay examining the relationship between coroutines (as in Rust async/await) and algebraic effects, arguing that coroutines are a restricted form of effects that compile down to state machines. Essential context for understanding why Rust chose coroutines over a more general effect system. https://without.boats/blog/coroutines-and-effects/
Scala 3 Language Features & Patterns
Scala HTMX Web Apps (Igal Tabachnik, RockTheJVM) Igal Tabachnik’s Twitter discussion and RockTheJVM content on building server-side web applications in Scala using HTMX — a hypermedia-driven approach that eliminates the need for a JavaScript frontend framework while still delivering dynamic UI interactions. https://twitter.com/igal_tabachnik
Scala 3 — End Markers, Given Instances, Sealed Traits (official docs) Official Scala 3 reference documentation for language features introduced in Scala 3: end markers for large blocks, given/using for type class instances, and sealed trait exhaustivity checking. Core reading for any developer migrating from Scala 2 to Scala 3. https://docs.scala-lang.org/scala3/reference/
Scala CLI Scala CLI is a modern command-line tool for running, compiling, testing, and packaging Scala code without a full SBT project setup. It enables single-file Scala scripts, inline dependencies, and rapid prototyping — significantly lowering the barrier for writing quick Scala utilities. https://scala-cli.virtuslab.org/
sbt-assembly SBT plugin for creating fat JARs (assembly JARs) by merging all dependencies into a single deployable artifact. Essential for deploying Scala applications to environments without Maven dependency resolution, including many data engineering and streaming platforms. https://github.com/sbt/sbt-assembly
The Evolution of Effects (Haskell’23 Keynote, Nicolas Wu) Nicolas Wu’s Haskell Symposium 2023 keynote tracing the evolution of effect systems from Haskell’s IO monad through monad transformers, free monads, and algebraic effects — contextualizing where algebraic effect systems like Kyo fit in the intellectual history of functional programming. https://icfp23.sigplan.org/details/haskellsymp-2023/10/The-Evolution-of-Effects
What Is So Unique About Unison? (Etienne Torreborre blog) Torreborre — specs2 author — explains what makes the Unison programming language unusual: content-addressed code, no dependency hell, abilities (algebraic effects), and distributed computing built into the language semantics. A thoughtful comparison with Haskell and Scala. https://etorreborre.blog/
Unison Is Crack for Backend Software Engineers (neander.tech) A detailed personal account of why Unison’s packaging and deployment model is uniquely compelling for backend engineers, eliminating dependency conflicts and enabling code to be deployed to the cloud as a first-class language operation rather than an infrastructure concern. https://neander.tech/2024-07-31-unison-is-crack
FUNARCH 2024 — Functional Architecture The Functional Software Architecture workshop at ICFP 2024, focused on methods for structuring large, long-lived software projects using functional programming principles. Covers DDD with FP, hexagonal architecture in FP, and effect system design for scalable codebases. https://functional-architecture.org/events/funarch-2024/
FP Meets OS: The Case of I/O — Vitaly Bragilevsky (LambdaConf 2024) Keynote examining how functional programming abstractions map onto operating system I/O primitives: how the IO monad, fibers, and async effects relate to kernel system calls, epoll, and OS scheduling. Bridges FP abstraction theory with systems programming reality. https://www.youtube.com/watch?v=ZGyIp8oalmE
What Does It Mean That a Language Has an “Effect System”? (langdev.stackexchange.com) Stack Exchange language design discussion explaining effect systems to those unfamiliar with the concept: what effects are tracked, how the type system encodes them, and how effect systems compare to monadic I/O and algebraic effects in terms of expressivity and ergonomics. https://langdev.stackexchange.com/questions/3726/what-does-it-mean-that-a-language-has-an-effect-system
Higher Order Company / HVM / Bend Language Higher Order Company’s HVM (Higher-order Virtual Machine) is a parallel runtime based on interaction nets that can execute functional programs on many CPU cores or GPU threads without explicit parallelism annotations. Bend is the high-level language targeting HVM. https://higherorderco.com/