Books

Discover the power of Common Lisp through a clear, practical guide that takes you from your first S-expression to advanced macros, CLOS and the condition system. Learn not just how Lisp works but why it remains one of the world's most influential programming languages.

Erlang was created to build systems that never stop. From its origins in telecommunications to modern platforms like WhatsApp and RabbitMQ, its approach to concurrency and fault tolerance has shaped some of the world's most reliable software. This book teaches both the language and the principles behind building resilient, production-ready systems.

Discover how Elm makes modern web development simpler, safer, and more enjoyable. From functional programming fundamentals to building production-ready applications, this book provides a practical, hands-on path to mastering Elm's powerful architecture, robust type system, and elegant approach to creating reliable software.

Build reliable, scalable software with The Professional’s Guide to Elixir. Learn functional programming, BEAM concurrency, OTP fault tolerance, metaprogramming, and modern web development with Phoenix and LiveView. This book gives you the practical knowledge to create systems that scale and stay resilient.

Master Scala from the ground up with a practical guide to modern programming. Scala Masterclass takes you from core concepts and functional programming to advanced patterns, type systems, concurrency, and real-world design techniques. Build the skills to write elegant, scalable, and maintainable Scala applications with confidence.

Discover the power and elegance of OCaml, from your very first program to production-ready applications. The OCaml Handbook combines clear explanations, practical examples, and real-world insights to help students and experienced developers alike master one of the most expressive programming languages in use today.

Master Kotlin Coroutines and Flow from the ground up through real Android projects, production patterns, and best practices used by senior Android engineers.

Learn how to build fast, reliable, and maintainable software with F#. This practical guide takes you from functional programming fundamentals to advanced software engineering techniques, including asynchronous programming, domain-driven design, testing, performance optimisation, and .NET integration. Ideal for developers who want to write cleaner, safer, and more scalable applications.

A direct route from the basics to real-world Haskell. Master functions, types, and effects, structure real projects, and ship a working blog engine. Along the way, you learn design principles that make you a stronger engineer in any language.

This Developer's Guide is the "Project #1" from the also included "Building Role-Playing Browser Games" workbook. It leads you through the development of the "St. George Battles the Dragons" Role-Playing Game in both Construct v3 & v2 encoding. It's perfect for novices, experienced web developers, and anyone wanting their own bespoke game, artwork, and features.

Most blockchain books teach the theory. This one walks you through building a complete Bitcoin-style blockchain in Rust, end to end — cryptography, consensus, networking, persistence, REST API, desktop wallets, and Kubernetes deployment.

An introduction to actor-critic algorithms as dynamical systems: featuring hand-computable examples, fast-slow reductions, and machine-checked Lean 4 proofs

Clean, Hexagonal, Onion—one dependency rule, three names. Walk a runnable multi-module SaaS billing service in Scala 3 and ZIO: a pure domain ring, ports and use cases in the middle, PostgreSQL + Flyway + JDBC and a thin HTTP shell on the outside—with full source in the PDF, not truncated snippets. See how ZLayer at the composition root keeps one repository for the whole graph, how webhook idempotency stays on the right side of the boundary, and how munit and zio-test (plus optional Docker) prove the architecture you intend to defend in code review.

CRUD erases the story your system lived through; event sourcing keeps it. Build an account aggregate in Scala 3 and ZIO: past-tense events, a pure applyEvent fold, decide for invariants and idempotency, then wire an append-only PostgreSQL journal, transactions, and a balance projection—and trace one account from HTTP command to read model. When the log must leave the database, follow the same events through transactional outbox, Kafka, and at-least-once consumers without pretending you have magic consistency. For architects and implementers who want decision-grade ES + CQRS, not a toy demo.

No distributed transaction spans your whole business process—so you design steps and compensations instead. In Scala 3 and ZIO, build a full order-placement saga from domain types and service algebras to orchestration and event-driven choreography, with tests that prove compensations fire when things break. Then see what it takes to move the same design toward production: outbox, idempotency, persistence, and how to choose between central coordination and decentralized reactions.