Software Architecture

A Cray Research veteran narrates how pioneers handled overwhelming complexity: pattern recognition anticipating Midway, systems thinking inventing magnetic core memory. Experience from one domain, applied in a new way, shaped supercomputing.

The book then guides readers through Virtual Private Networks (VPNs), detailing their importance, functioning, and distinct types of VPNs. It explores wireless networking and asynchronous programming, providing clear illustrations of WiFi, Bluetooth, and Zigbee setup using C++. It covers critical wireless standards and security protocols.

This book provides an introduction to the high-level concepts behind query engines and walks through all aspects of building a fully working SQL query engine in Kotlin.

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.

STOP building fragile AI wrappers. START designing resilient AI systems. Lots of companies are trying to make their small AI experiments into big products, but they don't have a good plan. Engineers need a practical guide to build these new AI systems the right way - so they can handle scale, be reliable, and won't cost too much. This book is that guide. It explains how to design systems that use AI models. This book breaks down the architecture of real AI applications, like an AI-powered code editor or a smart learning app. It gives you a deep, practical look at the real-world challenges and solutions for building these systems. It discusses system design concepts for systems that use LLMs.

This book takes you through the most common patterns and frameworks used by developers while creating software based on ROS 2. It's not a programming guide guiding you through the basic APIs, but is meant to help you organizing complex architectural patterns in robotics. It is written with an informal tone that will hopefully keep you entertained.

Ready to learn Java without getting lost in theory? Start with your first program, then work your way up to virtual threads, testing, observability and container deployment. With Java 26 and complete code that actually compiles, you’ll build the skills to create software fit for production.

A developer-friendly, practical and pragmatic guide to lightweight software architecture, technical leadership and the balance with agility.

Learn how to implement DDD, CQRS and Event Sourcing. Understand the theory and put it into practice with JavaScript and Node.js. Utilize an extensive source code bundle and an interactive execution feature for a hands-on experience.

Master Domain-Driven Design Tactical patterns: Entities, Value Objects, Services, Domain Events, Aggregates, Factories, Repositories and Application Services; with real examples in PHP. Explore the advantages of Hexagonal Architecture and understand Strategic design with Bounded Contexts and their integration through REST and message queues.

“Happily purchased. Handy to have these in one place. Thank you!” — Kent Beck “Excellent new thinking on Domain-Driven Design. It's full of real practical experience in getting the most value from domain modelling. Just like the Eric Evans' DDD book, this gives more insight each time you read it.” — Ian Russell

Residuality Theory is a new way to think about the design of software systems that explains why we experience design the way we do, why certain things seem to work only sporadically, and why certain architects get it right so often regardless of which tools they use. A new, scientific approach is defined that fuses Software Engineering, Complexity Science, and Philosophy to produce an entirely new way to think about how to design software. The result is a theoretical base that allows architecture to finally become its own discipline.

Strategy is the difference between making a wish and making it come true. To make your cloud journey a reality, and not just a wish, you’ll want to stay clear of buzzwords and product minutiae. Instead, focus on principles, decision models, and trade-offs that you can communicate broadly throughout your organization. This book tells you how. Paperback editionHardcover edition

Real software architectures, documented with the arc42 template. Helps you jumpstart your own documentation.

Most embedded teams say they “avoid OOP” and “stick to C.” But look closely at real C codebases and you’ll find function-pointer tables, opaque handles, and generic device arrays—manual object models built the hard way. Beyond Blinky shows how to embrace that reality consciously, using modern C++ to design firmware that is readable, portable, and owned—without sacrificing performance or control. This book is about moving past the blinking LED mindset and designing embedded systems as living architectures, not scripts. To blinky and beyond—Let's make your IO sing!