Leanpub Header

Skip to main content

Filters

Category: "C and C++"

Books

  1. Deterministic Matching Engines in C++23/26
    Deterministic Matching Engines in C++23/26
    Lock-Free Order Books, Cache-Line Aligned Price-Time Priority, and Zero-Jitter Trade Execution.
    Weston Ashgrove

    The engine never crashed. Every test passed. Then the opening auction cleared, order flow jumped fivefold, and for eight minutes it matched every order correctly against a book that was already 700 milliseconds out of date. Several hundred clients got fills that were individually plausible and collectively wrong. Nothing in the logs said why.This book is about that gap between "thread-safe" and "deterministic," and how to close it: lock-free CAS design, cache-line layout measured with perf c2c, zero-allocation hot paths, jitter hunted down to the interrupt level, and proof that the same event log replays byte-for-byte identical ten thousand times, including after a crash.

  2. Build a Compiler in C++, Backwards
    Build a Compiler in C++, Backwards
    Start with twelve bytes of machine code. Finish with a compiler that draws what gcc draws.
    Hatem M.

    Build a compiler from the machine up. Start with twelve bytes of machine code you encode by hand, and finish with a compiler whose ray tracer draws exactly what gcc's build of it draws.

  3. CUDA C++: High-Performance GPU Programming

    Master the GPU from the Streaming Multiprocessor to Production-Grade High-Performance KernelsCUDA C++: High-Performance GPU Programming is an advanced technical guide to GPU programming, CUDA execution, memory architecture, kernel optimization, low-level hardware analysis, and high-throughput AI workloads.Designed for engineers who want to move beyond basic CUDA programming, this 53-chapter technical reference explores the NVIDIA GPU programming stack in depth, progressing from Streaming Multiprocessor architecture and SIMT execution to PTX/SASS analysis, Tensor Cores, asynchronous data movement, multi-GPU systems, NCCL, and production inference engines.The book takes a hardware-aware approach to performance engineering. Rather than treating CUDA as a black box, it examines how threads execute, how warps communicate, how memory transactions are formed, and how registers, caches, compiler decisions, and hardware scheduling influence performance. The emphasis is on understanding the mechanisms behind kernel behavior and using that knowledge to make informed optimization decisions.

  4. Building Advanced Algorithmic Crypto Trading Systems

    Design, Engineer, and Deploy High-Performance Algorithmic Trading Infrastructure for Digital Asset MarketsCryptocurrency markets operate continuously, generating vast streams of market data across centralized and decentralized exchanges. Competing in these markets requires far more than a collection of trading scripts. It demands a rigorous combination of low-latency systems engineering, quantitative modeling, market microstructure analysis, distributed computing, machine learning, and production-grade risk management...

  5. Linux GPU Drivers from Scratch
    Linux GPU Drivers from Scratch
    Building Real DRM Drivers for the Modern Linux Kernel
    Steve Publications

    Go beyond writing kernel modules and learn how real Linux GPU drivers are built. Starting with GPU architecture and the graphics stack, this hands-on guide walks you through creating a complete DRM driver, from a minimal module to memory management, command submission, display support and error recovery.

  6. Deriving Algorithms
    Deriving Algorithms
    Reading, Diagnosing, Building: Twenty-Seven Worked Derivations and 285 Problems That Teach You to Find an Algorithm Instead of Recalling One
    Hatem M.

    Most algorithm books are catalogues: here is a technique, here is its proof, here are exercises. This one withholds the name of every technique until after you have built it.

  7. Advanced Aerospace Engineering: Lockheed & Partners

    A comprehensive technical reference on advanced aerospace systems, stealth engineering, hypersonics, propulsion, avionics, sensor fusion, space systems, and next-generation aircraft architectures.Modern aerospace engineering brings together disciplines that once operated largely independently. Aerodynamics, electromagnetics, propulsion, materials science, avionics, autonomy, and systems engineering now interact within increasingly complex air and space platforms. Understanding these systems requires more than knowledge of individual components; it requires an appreciation of how their physical principles, computational models, and engineering constraints influence the architecture as a whole. Advanced Aerospace Engineering: Lockheed & Partners is a 52-chapter technical compendium exploring the engineering principles behind advanced aerospace and defense systems. Drawing on publicly documented technologies and established engineering methods, it examines the relationship between theoretical foundations, computational analysis, subsystem design, and system-level integration.

  8. learn Nim Programming Language basic to advance
    learn Nim Programming Language basic to advance
    Mastering Nim Programming: Build High-Performance Systems, Games, and Web Apps with Python-like Syntax and C-level Speed You’ve probably noticed that most programming books are either too theoretical or filled with outdated examples. When I first started learning Nim, I faced the same frustration. That’s exactly why I wrote this book—not just to teach syntax, but to turn you into a production-ready Nim developer. This isn’t a generic tutorial. It’s a practical, 2026-updated guide that takes you step-by-step from zero to advanced systems programming. 📘 What You’ll Master Inside We always tie theory to real code. Every chapter includes: Modern Nim Core: Understand variables, types, and control flow without boring lectures. Focus directly on patterns professional Nim devs use daily. Metaprogramming Demystified: Macros and templates are Nim’s superpower, but most books overcomplicate them. We’ll make them simple enough for you to write your own DSLs. Systems & Memory Control: Safely handle GC-free modes, manual memory management, and C/C++ interop. This is the skill that lets you build high-performance tools. Real-World Projects: No more “Hello World.” Together we’ll build an async web backend (Jester/Prologue), a 2D game prototype, and a cross-platform CLI tool. Concurrency Done Right: Implement threads, channels, and async/await in practical scenarios without fear of race conditions. 🎯 Who Is This Book For? Python Devs tired of performance bottlenecks who don’t want C++ complexity. C/C++ Programmers who want modern syntax and safety without losing speed. Rust Developers exploring Nim’s gentler learning curve and faster compilation. Students & Hobbyists aiming for careers in compilers, game dev, or embedded systems. 💡 Why This Edition Is Different 90% of Nim content online is based on Nim 1.x or older. This book is built on the 2026 stable compiler, updated standard library, and modern tooling (nimble, nimlangserver). You won’t make the same mistakes I made five years ago. ✍️ Author’s Note I’ve spent years in systems programming and open-source contribution. I wrote this book because when I was learning Nim, there was no comprehensive, up-to-date resource like this. My goal is simple: flatten your learning curve so you can achieve in weeks what took me months. Get Started Now Nim isn’t just a language—it’s a different way of thinking. If you want both clean code and raw performance, this book will be the most important step in your journey. 📥 Read the free sample chapter to see if this book is right for you!
    MFoundation

    Mastering Nim Programming: Build High-Performance Systems, Games, and Web Apps with Python-like Syntax and C-level SpeedYou’ve probably noticed that most programming books are either too theoretical or filled with outdated examples. When I first started learning Nim, I faced the same frustration. That’s exactly why I wrote this book—not just to teach syntax, but to turn you into a production-ready Nim developer.

  9. Using Linux for Software Development
    Using Linux for Software Development
    A Complete Beginner-to-Advanced Guide
    Steve Publications

    From the Linux basics to advanced development workflows, this practical guide shows you how to turn Linux into a powerful software development environment. Learn the command line, work with popular programming languages, use containers and CI/CD, debug and profile applications and build skills you can use every day.

  10. Programmable Networks with C++
    Programmable Networks with C++
    Network Automation for SDN, Intrusion Detection, Cloud, Kubernetes and AI Infrastructure with C++23
    GitforGits | Asian Publishing House

    In this book, we plan before we act, we preview before we commit, we gate on evidence rather than on hope, and we write the recovery before we take the risk. By the time you get to the last chapter, you'll be familiar with the switches over NETCONF, server provisioning, building overlays, traffic inspection, cloud network provisioning, Kubernetes resource application, RDMA fabric validation, inference traffic routing, and reporting your findings through an interface that an assistant can query.

  11. 100 LLM Autopsies
    100 LLM Autopsies
    What broke, why nobody noticed, and how it was found
    Hatem M.

    A model that crashes is a good day. The dangerous failures return answers — plausible, fluent, and wrong. 100 failures. 63 diagnostic instruments. One rule: inspect what actually happened.

  12. Modern ANSI C Programming
    Modern ANSI C Programming
    A Complete Guide to Correct, Portable, and Professional C Code
    Steve Publications

    Master C the way it is used in serious software. Modern ANSI C Programming takes you from the fundamentals to memory management, data structures, concurrency and production-ready practices, with practical examples that show what works, what breaks and why. Write C that is portable, secure, efficient and built to last.

  13. The C++ STL Handbook
    The C++ STL Handbook
    Containers, Algorithms, Iterators, Ranges, and Beyond
    Steve Publications

    Go beyond C++ syntax and learn to use the STL with confidence. Explore containers, algorithms, iterators, ranges and more through practical examples, performance insights and real-world patterns. Build a deeper understanding of how the STL works, when to use each tool and how to write cleaner, faster and more maintainable C++.

  14. Mastering Regular Expressions
    Mastering Regular Expressions
    A Complete Guide for Developers Across Languages and Platforms
    Steve Publications

    Regex doesn't have to feel like cryptic punctuation. Mastering Regular Expressions shows you how patterns really work, how to debug them when they don't and how to use them confidently across nine programming languages. Go beyond memorizing syntax and learn to write regex that's clear, efficient and portable.

  15. Vector Search from First Principles
    Vector Search from First Principles
    SIMD, Quantization, and Billion-Scale Retrieval
    Steve Publications

    Most vector search books start with the database. This one starts with the machine. Build a search engine from scratch, then push it from brute force to billion-scale retrieval with SIMD, HNSW, quantization and distributed systems. By the end, vector search won't be a black box. It'll be something you know how to build, tune and scale.