Performance Engineering

Go beyond basic Linux tuning and learn how performance really works under the hood. Explore kernel internals, hardware behavior, benchmarking and production optimization with practical tools, real trade-offs and copy-paste-ready examples. Build the skills to diagnose bottlenecks and solve performance problems with confidence.

Building fast LLM inference is about far more than turning the right knobs. This book takes you inside vLLM and the systems behind it, showing how memory, scheduling, GPUs and distributed serving shape real-world performance. Learn how to measure what matters, find bottlenecks and build inference infrastructure that scales without wasting money.

What does it take to run an LLM on hardware that barely has enough memory to breathe? This practical guide takes you from transformer math and model compression to inference runtimes, benchmarking and real-world deployment, with hands-on case studies for building fully offline LLM systems on tiny devices.

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.

Your matching engine passed every test. Your risk engine rejects every bad order. Your FPGA gateway hits its latency target on the bench.On day one, all four components ran together against live order flow, and the system breached its exposure limit by several multiples.No component was wrong. The seams between them were.This book is about those seams.

Your CPU has been waiting.Every numeric loop you have ever shipped processed one value at a time on hardware that was built to process sixteen simultaneously. The gap between what your code does and what the silicon is capable of is not a compiler limitation or a language restriction. It is a knowledge gap, and it has a precise cost you can measure in cycles per element.This book closes it.You will learn to read hardware the way the processor reads it: in lanes, in registers, in parallel. You will understand why your data layout is the first performance decision and the last one most engineers make. You will write branchless conditional logic that executes at full vector throughput, navigate AVX-512’s predication model without triggering the frequency trap that makes wider vectors slower, and build ARM NEON kernels that exploit interleaved memory instructions x86 has no equivalent for.By the time you reach the final chapter, you will have the complete toolkit: a portable abstraction layer that compiles to native instructions with zero overhead, a compiler collaboration discipline that turns the auto-vectorizer from an unreliable guess into a predictable collaborator, a benchmarking methodology that measures real throughput instead of measuring the speed of nothing, and a fat binary deployment architecture that ships the right implementation to every machine in your fleet without a separate binary per hardware class.The hardware is fast. It has always been fast. This book teaches you to use it.

We will define the developer contract first, and we will then build the platform underneath it together, step by step, using decisions that hold up in regulated environments and in small startups alike. Along the way, we will provision clusters, wire delivery, publish a developer API, enforce policy and ship observability, and we will do all of it where you can see every command, every manifest and every failure. Nothing here stays theoretical, because platform problems only show their true shape where an abstraction meets a real cluster.

Your C++ gateway is fast. It still loses races. The cost sits below your code, in kernel network stacks, PCIe round trips, and OS scheduling jitter that no profiler shows and no rewrite removes.This book moves market data ingestion and a bounded slice of decision logic into FPGA fabric, cutting a typical 3 to 7 microsecond software path to roughly 0.7 to 1.1 microseconds, with every number measured end to end, not assumed.

What really makes software fast? This book takes you inside the modern CPU to show what happens to your code at the hardware level. Learn how to measure performance, find bottlenecks and turn slow code into faster code using practical techniques, real tools and real hardware.

Build real systems software with Odin. This practical guide takes you from the language basics to memory, concurrency, networking and performance. Learn how Odin works under the hood while building parsers, allocators, simulations and more, with complete examples and clear comparisons to C, C++, Rust and Go.

Build a real LLM inference engine from the ground up in portable C. Learn how transformers work, load SafeTensors weights, implement KV caching and optimize inference on the CPU. By the end, you will run TinyLlama locally and generate text with a complete working runtime.

What if you could build an AI that writes just like you? In Building Your LLM Twin, you'll follow a hands-on journey from raw writing data to a fully deployed AI that captures your unique voice. Learn to build, fine-tune and scale real-world LLM systems with practical code, proven techniques and the tools to take your project from concept to production.

Kill N+1 queries, read EXPLAIN-friendly EF patterns, and ship faster ASP.NET APIs with a dense EF Core performance cookbook.

What happens when AI starts making the decisions behind your database queries? This practical guide explores how modern optimizers work, then shows how machine learning and reinforcement learning can improve them. Learn to build, test and deploy AI-driven optimization systems that deliver real performance gains.

Go beyond writing code that works. Learn what really happens inside .NET, from C# and the JIT to memory, CPU execution and the operating system. This practical guide shows experienced developers how to measure performance, find real bottlenecks and make targeted improvements that hold up in production.