Essential HFT literature

Core high-frequency trading books

“Developing High-Frequency Trading Systems” by Sebastien Donadio, Sourav Ghosh, Romain Rossier

This is perhaps the most comprehensive modern treatment of HFT system development. The authors bring real-world experience from both exchange and trading firm perspectives. While the examples are primarily in C++ and Java, the architectural principles and optimization techniques translate directly to Rust. The book covers everything from market data feeds to order management systems, making it essential reading for anyone serious about HFT development.

“High-Frequency Trading: A Practical Guide to Algorithmic Strategies and Trading Systems” by Irene Aldridge (2nd Edition)

Aldridge’s updated edition incorporates the latest research and regulatory changes in the HFT landscape. The book excels at explaining the business logic behind HFT strategies and provides practical frameworks for portfolio management and risk control. The second edition addresses many of the controversies and misconceptions surrounding HFT while maintaining technical depth.

“Handbook of High Frequency Trading” (ScienceDirect)

For those seeking an academic perspective, this handbook provides rigorous treatment of HFT from an econometric standpoint. It’s particularly valuable for understanding the market impact of HFT and the mathematical models used to analyze high-frequency data. The research-based approach complements the more practical books listed above.

Market microstructure fundamentals

“Trading and Exchanges: Market Microstructure for Practitioners” by Larry Harris

Before you can optimize a trading system, you need to understand how markets actually work. Harris provides the definitive practitioner’s guide to market structure, covering everything from order types to market making mechanics. This foundational knowledge is crucial for making intelligent architectural decisions in your HFT system.

“Market Microstructure Theory” by Maureen O’Hara

O’Hara’s academic treatment complements Harris’s practical approach by providing the theoretical framework underlying market behavior. Understanding concepts like adverse selection, market impact, and price discovery will inform better trading algorithms and risk management systems.

“Algorithmic Trading and DMA” by Barry Johnson

Johnson’s book bridges the gap between theory and practice, focusing on the mechanics of direct market access and algorithmic execution. The coverage of order routing, market impact models, and execution algorithms is particularly relevant for HFT system architects.

Mastering Rust for systems programming

Rust fundamentals

“Programming Rust: Fast, Safe Systems Development” by Jim Blandy, Jason Orendorff, Leonora Tindall (2nd Edition)

The second edition of Programming Rust has evolved into the definitive systems programming guide for Rust. What sets this book apart for HFT developers is its focus on performance characteristics and memory management. The authors demonstrate how Rust’s ownership system enables both safety and speed, with practical examples of concurrent programming patterns essential for trading systems.

“The Rust Programming Language” (The Rust Book)

Available free at https://doc.rust-lang.org/stable/book/, the official Rust book remains the best starting point for newcomers. The online format means it’s always up-to-date with the latest language features, and the progressive structure makes it accessible even for developers new to systems programming.

Performance optimization in Rust

“The Rust Performance Book” by Nicholas Nethercote

This free online resource (https://nnethercote.github.io/perf-book/) has become the go-to reference for Rust performance optimization. Nethercote, a Mozilla developer with deep performance expertise, covers profiling techniques, memory optimization, and algorithmic improvements with real-world examples from Firefox development. For HFT developers, the sections on heap allocation, CPU efficiency, and compile-time optimization are particularly valuable.

“Rust High Performance” (O’Reilly)

This book teaches optimization techniques that can bring Rust performance to C/C++ levels. The coverage of metaprogramming for performance and concurrent execution patterns directly applies to HFT scenarios where every nanosecond matters.

“Rust in Action” by Tim McNamara

McNamara’s practical approach to systems programming covers real-world scenarios including file I/O, networking, and operating system interfaces. The hands-on examples help bridge the gap between Rust language features and actual system implementation.

Systems programming mastery

Low-level performance optimization

“Systems Performance: Enterprise and the Cloud” by Brendan Gregg

Gregg’s comprehensive guide to performance analysis is essential reading for anyone building high-performance systems. The methodologies for identifying bottlenecks, the deep dives into CPU and memory subsystems, and the practical profiling techniques apply directly to HFT system optimization. The book’s focus on observability is particularly relevant as trading systems require extensive monitoring.

“Computer Systems: A Programmer’s Perspective” by Bryant & O’Hallaron

This academic text provides the hardware understanding necessary for writing truly optimized code. The coverage of memory hierarchy, CPU architecture, and assembly language helps HFT developers understand the underlying costs of different programming choices. The sections on caching and memory optimization are particularly relevant.

“What Every Programmer Should Know About Memory” by Ulrich Drepper

Drepper’s detailed treatment of memory systems is crucial for HFT developers who need to minimize cache misses and optimize memory access patterns. Understanding NUMA architectures, cache hierarchies, and memory bandwidth limitations directly impacts trading system performance.

Network programming

“UNIX Network Programming” by W. Richard Stevens

Stevens’ classic work remains the definitive guide to network programming. For HFT systems that often require kernel bypass and custom networking stacks, understanding the fundamentals of socket programming, TCP optimization, and network performance is essential.

“High Performance Browser Networking” by Ilya Grigorik

While focused on web performance, Grigorik’s book provides excellent coverage of modern networking protocols and optimization techniques that apply to financial data feeds and order routing systems.

Online resources and documentation

Rust-specific performance resources

The Rust Performance Book (https://nnethercote.github.io/perf-book/) stands out as the most practical resource for optimization techniques. Unlike generic performance guides, it focuses specifically on Rust’s unique characteristics and provides concrete examples of optimization techniques with measurable results.

Are We Fast Yet? (https://arewefastyet.rs/) tracks Rust’s performance evolution and provides benchmarks across different domains. For HFT developers, it’s useful for understanding where Rust excels and where additional optimization might be needed.

The official Rust Reference (https://doc.rust-lang.org/reference/) and Unstable Book (https://doc.rust-lang.org/unstable-book/) provide authoritative coverage of language features, including experimental features that might benefit high-performance applications.

Trading and market data resources

QuantStart offers practical tutorials on quantitative trading and system implementation. The focus on practical implementation rather than pure theory makes it valuable for developers building real systems.

CME Group Developer Resources provide official documentation for one of the world’s largest derivatives exchanges, including market data specifications and API documentation essential for connecting to live markets.

Hardware and optimization resources

Intel Developer Zone provides comprehensive guides for CPU optimization, including SIMD programming and cache optimization techniques directly applicable to HFT systems.

Agner Fog’s Optimization Resources offer some of the most detailed coverage of assembly language optimization and CPU architecture considerations available online.

The Mechanical Sympathy blog explores hardware-aware programming techniques, with many posts directly relevant to low-latency system development.

Research and academic resources

Key research papers

Understanding the academic foundation of HFT helps inform system design decisions:

• “High-Frequency Trading and Price Discovery” (Brogaard et al.) examines HFT’s impact on market quality
• “The Flash Crash: High-Frequency Trading in an Electronic Market” (Kirilenko et al.) provides insights into system behavior under stress
• “High-Frequency Trading around Large Institutional Orders” (Yang & Zhu) explores order detection and market impact

Systems research

Google’s “The Tail at Scale” paper addresses latency challenges in distributed systems that directly apply to trading infrastructure. The techniques for managing tail latencies are crucial for HFT systems where consistency matters more than average performance.