Books

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.

The best compliment a reader can pay your code is not "this is impressive" — it is "this was exactly what I expected." Beautiful but Boring teaches the discipline of writing Python that earns that compliment: precise naming contracts, type annotations that say what a function actually requires, and a framework for maintaining those standards consistently across a codebase, a team, and a career.

Keyword search misses meaning. Vector search misses precision. This book shows you how to combine them into production systems that deliver both, with architecture patterns, model selection frameworks, evaluation methodology, and operational guidance grounded in primary research.

A 1986 text adventure game written inside the Cray I/O Subsystem turns out to be architecturally isomorphic to modern transformer design. This capstone volume uses the playable game and its assembly language source as a case study in constraint-based design, including the bare metal thinking we stopped teaching around 1995.

What was so unusual and special about Cray Research? We accomplished, repeatedly, what nobody else on the planet was able to match. High-Performance Computing is not merely parallelism and large-scale systems. That is the public-facing decoy version.

Build modern, production-ready Android apps with Jetpack Compose using real-world patterns, scalable UI architecture, and professional workflows. This book goes beyond basics to show you exactly how to design, structure, and optimize apps that perform in real development environments. Perfect for developers ready to turn Compose knowledge into polished, portfolio-ready applications.

Most code generation is about saving time.This book is about eliminating entire categories of errors.Instead of writing code first, you define the system—its data, its flow, and its structure—and generate the implementation deterministically. No hidden behavior. No runtime frameworks. No guesswork.If you care about building systems that remain understandable years later, this approach changes how you think about software.

A four-phase discipline for PowerShell automation that has to actually work, built around one real, escalating case study from cover to cover.

Stop building dashboards. Start building outcomes. A guide to designing "Invisible Engines" and agentic systems for a world tired of software.

Across 30 chapters, you'll trace real code paths through nearly 400 CAS modules, learning the architecture decisions, design patterns, and implementation techniques that hold this massive system together. Whether you're a CAS contributor trying to fix a tricky bug, an architect evaluating CAS for your organization, or a Java developer who wants to study a mature, real-world Spring Boot application at scale — this book gives you the map. Written by a long-time CAS committer who has been involved since the original CAS 3.0 architecture, this book distills years of hard-won knowledge into a single, code-level reference.

Stop being a syntax typist. Master Clean Code Architecture and Algorithmic Thinking to become a professional Software Architect in 2026. This blueprint teaches you to build Scalable Systems using Binary Logic, Big O Notation, and proven Software Engineering Patterns. Perfect for the modern Backend Developer, self-taught coder, and Tech Entrepreneur looking to design high-performance software from scratch.

Vector stores don't think — they search. They find fragments that sound like your query, then forget they ever looked. Every session starts from nothing. Every context window is a memory that dissolves at sunset.But the deeper problem isn't amnesia. It's that when agents do remember, they remember in someone else's house — on servers you don't control, in formats you can't inspect, under terms you didn't write.Memory Graph is a book about building something different: persistent, structured, queryable memory that lives inside your application — no external servers, no data leaving your process, no infrastructure you don't own. An embedded graph database that travels with your agent the way a nervous system travels with a body.You'll learn how to model not just facts, but relationships between facts. Causality. Temporal ordering. The layered structure of meaning that makes memory more than a search index. You'll build ontologies that enforce what can be known and how. You'll combine graph traversal with semantic search — so your agents find not just what's similar, but what's connected.The result is an agent that remembers the way you do: structurally, contextually, privately — with memory that belongs to you.

Modern GPUs are the most complex and efficient parallel processors ever created—and this book shows you exactly how they work at the hardware level. Unlike typical graphics or programming guides, this volume takes you inside the GPU itself: how instructions flow through pipelines, how memory hierarchies sustain bandwidth, how shader cores and fixed-function units cooperate to render billions of pixels per second.