A developer-friendly, practical and pragmatic guide to lightweight software architecture, technical leadership and the balance with agility.
This book provides a simple, proven approach to drawing clear, memorable technical diagrams. The focus is on whiteboard sketches, but the principles apply to chalkboards, notebooks, and even digital tools. The techniques work for a wide range of technical disciplines including software architecture, business process modelling, and robotics.
Happy-path architecture is a myth. When downstream dependencies degrade, naive retries trigger thundering herds, thread pools exhaust in seconds, and dual-writes silently corrupt financial balances. Surviving Distributed Systems is an unvarnished, production-tested field guide for senior backend engineers. Packed with architectural diagrams and modern Java 21 code, this book teaches you how to design, isolate, and harden high-concurrency systems so they survive catastrophic cascading failures.
Structure decays because it is expensive. This book shows how to make it cheap enough to keep: models as text, telemetry kept as a model, and no infrastructure beyond a JDK.
Naming is one of the most difficult and enduring challenges in software engineering, but few of us do it well. This practical and comprehensive book provides a set of principles, rules, and application guidelines for efficiently choosing good names in your code.
Modern cloud-native applications generate massive volumes of telemetry data, making observability increasingly expensive and difficult to scale. While OpenTelemetry has become the industry standard for distributed tracing, traditional tail-based sampling architectures often require stateful collector clusters with significant memory and processing overhead. Rethinking OpenTelemetry Tail-Based Sampling explores how Event-Driven Architecture (EDA) and event mesh technologies can be used to address these challenges. Through practical examples, architectural analysis, and implementation considerations, this book examines OpenTelemetry sampling strategies and presents an alternative approach that externalizes trace buffering and sampling coordination beyond the collector layer. Whether you are an observability engineer, platform architect, integration specialist, SRE, or cloud-native practitioner, this book provides practical guidance for designing scalable, resilient, and cost-effective distributed tracing platforms.
Bisherige Architekturmuster leiden an funktionalen Abhängigkeiten. Die machen danach strukturierte Codebasen grundsätzlich schwer verständlich und schlecht testbar. Interfaces, DIP & IoC sollen dem abhelfen, doch der Effekt ist begrenzt. Die IODA Architektur packt dieses Übel an der Wurzel und strukturiert Software ohne funktionale Abhängigkeiten.
The book is a fully revised transcript of a seminar about physical memory analysis on Windows platforms. Topics include memory acquisition, memory spaces, challenges of physical memory analysis, common WinDbg commands, memory analysis patterns and their classification, common mistakes, a hands-on WinDbg analysis example, a guide to further study.
Strategy does not ship software. This is one level down: 54 field chapters of working material for the people who design, build, review, generate, test, deploy, and operate the real systems.
Explore the power of Rust with "Rust Projects: Write a Redis Clone". This hands-on guide takes you through building a Redis-inspired database from the ground up, introducing key programming concepts like TCP connections, the RESP protocol, and concurrency. Following the CodeCrafters challenge, this book gradually builds your skills, making complex topics accessible. Whether you're new to Rust or looking to deepen your understanding, this project-based journey offers practical, real-world insights into modern systems programming. The book contains 40% discount code for CodeCrafters.io!
Master the ideas behind Java concurrency, from threads, race conditions, and synchronization to CompletableFuture, virtual threads, and structured concurrency. With practical patterns, runnable examples, and a companion GitHub repository, this book helps you move from understanding concurrency to applying it in real programs.
Tired of architecture books that read like academic papers? This pragmatic guide will show you how to design robust systems that work in the real world. I have learned these lessons the hard way so you don't have to. Everything you need to know about software architecture—from core principles to advanced patterns—explained in plain English and practical examples. Paperback edition
This is not a book about best practices. It is not a manual for clean architecture or a treatise on organizational efficiency. There are enough of those. This is a book about patterns you can feel but not always name. About the loops that shape systems, and the systems that shape us. About how structure emerges, reflects, collapses, and — sometimes — regenerates. You don’t need to be an engineer to know what it’s like to live inside a system that can’t see itself. Or to feel the edge of a process that once made sense but no longer fits. You don’t need to be a leader to notice when a decision wasn’t really a decision, but a reflex encoded years ago.
Diagrams people draw and programs read: how much structure a diagram should carry, and a Java API that reads, changes and renders Draw.io documents with Draw.io's own viewer.
What is a good software architecture? Why should we bother structuring the code and spending time testing it? If you like spending hours debugging your programs or staying late at the office to recover from a buggy deploy in production this book is definitely NOT for you!