Books

Arrays - Beginner → Intermediate → Advanced - C++ Edition brings all three volumes together: 166 array algorithms taught through plain-language explanations, C++ implementations, and step-by-step visual walkthroughs, all in full color.

What does it really take to build a web application from the ground up, without relying on layers of frameworks to do the heavy lifting? Building Modern Web Applications in C takes you from a handful of sockets to a fully functioning, secure and production-ready web service, revealing the inner workings of HTTP, databases, sessions, TLS and everything in between. Through hands-on examples and the evolution of Taskforge, you’ll learn not just how to make a web server work but how to build one you can trust, deploy and keep running in the real world.

Learn C++ Data Structures & Algorithms Visually - Volume 4 brings together 107 algorithms covering trees, linked lists, strings, and arrays, each part opened by short foundation sections on the core tree patterns,... Printed in full color.

Learn C++ Data Structures & Algorithms Visually - Volume 2 brings together 108 algorithms covering trees, linked lists, strings, and arrays, each part opened by short foundation sections on the core tree patterns,... Printed in full color.

Learn C++ Data Structures & Algorithms Visually - Volume 3 brings together 107 algorithms covering trees, linked lists, strings, and arrays, each part opened by short foundation sections on the core tree patterns,... Printed in full color.

Learn C++ Data Structures & Algorithms Visually - Volume 1 brings together 108 algorithms covering trees, linked lists, strings, and arrays, each part opened by short foundation sections on the core tree patterns,... Printed in full color.

Arrays - Vol 3 (Intermediate → Advanced) - C++ Edition teaches 57 array algorithms through plain-language explanations, C++ implementations, and step-by-step visual walkthroughs, all in full color.

Arrays - Vol 2 (Beginner → Intermediate) - C++ Edition teaches 56 array algorithms through plain-language explanations, C++ implementations, and step-by-step visual walkthroughs, all in full color.

Arrays - Vol 1 (Beginner) - C++ Edition teaches 56 array algorithms through plain-language explanations, C++ implementations, and step-by-step visual walkthroughs, all in full color.

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.

A risk check that adds 50 microseconds does not add 50 microseconds. It hands your queue position to whoever skipped the check.Most risk engines pass the quiet-market demo. Then a mutex meets a fast market, a cache line is shared by two instruments, or a covariance matrix gets rebuilt on every fill, and the check that looked cheap becomes the slowest thing in the order path. The numbers stay correct. They arrive late.This book builds the engine that doesn’t do that: lock-free position tracking, a pre-trade gate with no mutex, VaR maintained at O(k) per fill instead of recomputed, and stress tests that never touch the fill path’s cache lines. Then it proves the result with replay tests, property-based invariants, and reconciliation against an independent source.Every technique is paired with the failure it prevents, and every section ends with what it changed in the latency budget.For engineers who build the thing that has to be fast and has to be right.

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.

Learn the C++ fundamentals that connect source code, memory, ownership, build tools, and operating-system boundaries. Clear diagrams and small examples guide you toward reading, testing, and diagnosing systems-oriented programs.

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.

Every nanosecond is a decision. Most trading systems lose thousands of them before the strategy even runs.Architecting HFT Systems in Modern C++ is the build manual for the systems that don’t. Starting from bare metal, you’ll construct a complete high-frequency trading pipeline, from packet arrival to order on the wire, with zero heap allocation and zero system calls on the hot path.You’ll learn how to:Tune Linux for deterministic, low-jitter execution with isolated cores, IRQ affinity, and tickless kernelsReplace malloc with arena allocators, pre-faulted pools, and clocks that never touch the kernelWire every component through lock-free SPSC queues using only the memory ordering you actually needBypass the kernel with DPDK, ef_vi, and io_uring, reading packets exactly where DMA placed themDecode ITCH, SBE, and FAST feeds at wire speed with branchless, compile-time-dispatched parsersBuild a cache-resident order book that updates in nanoseconds, not microsecondsRun strategies through a zero-virtual-call harness and enforce risk limits in a handful of instructionsProve it all with deterministic pcap replay, a simulated exchange, and automated latency regression detectionEvery chapter ends with a Latency and Determinism Ledger, a running p50/p99/p99.9 record that shows exactly where each nanosecond went and how it was won back.No toy examples. No hand-waving. Just the architecture, the code, and the measurements behind real tick-to-trade performance.Speed without determinism is luck. This book teaches you both.Short version (for ads or the subtitle line):Build a complete HFT pipeline in modern C++, from kernel bypass to order on the wire, with zero allocation, zero syscalls, and every nanosecond measured.