Building High-Performance Systems with Julia: Numerical Computing, Multiple Dispatch, Multithreading

Julia promises you don't have to choose between code you can read and code that runs fast. This book proves it, one working system at a time.
Most programming books teach you syntax and leave you to figure out architecture on your own. Building High-Performance Systems with Julia does something different: it builds one real project across all fourteen chapters - Helios, a gravitational N-body simulator - and grows it from a four-line command-line calculator into a production system that automatically detects its own hardware and picks between single-threaded, multithreaded, distributed, and GPU execution.
You will not find disconnected toy examples here. Every function you write in Chapter 1 is still running, unmodified, inside the production platform in Chapter 14.
Inside, you'll learn to:

• Write real, idiomatic Julia - types, dispatch, structs, and modules - from a true beginner starting point, with every technical term defined once and never re-explained
• Master multiple dispatch, Julia's single most distinctive feature, and use it to build physics that extends itself without a single scattered if statement
• Diagnose and fix real performance problems with @code_warntype, @btime, and Julia's built-in profiler - not guesswork, measured evidence
• Vectorize numerical code with broadcasting and BLAS, and know exactly when vectorization is the wrong tradeoff
• Build genuinely concurrent and multithreaded programs with tasks, channels, Threads.@threads, atomics, and locks - and understand why more threads don't always mean more speed
• Scale a real workload across multiple machines with Julia's Distributed standard library, complete with fault handling for a worker that disappears mid-run
• Write and tune custom CUDA.jl kernels, including GPU shared memory tiling, and build a hybrid pipeline where your CPU and GPU work simultaneously instead of one waiting on the other
• Ship it: benchmark regression testing, PackageCompiler system images, and a runtime that adapts to whatever hardware it actually finds itself on

Written for two readers at once. If you've never touched Julia, Chapter 1 welcomes you with zero assumed jargon. If you already write production Julia, the back half - distributed computing, custom GPU kernels, hybrid CPU/GPU pipelines, production deployment - will still earn its place on your shelf. Every chapter follows the same honest discipline: every technique's real cost is measured and stated, never hand-waved.
Structured in five parts - Foundations, Core Mechanics, Concurrency and Parallelism, Distributed and GPU Computing, and Production - with a full glossary, a technical appendix, and every code example verified to run exactly as printed.
If you're ready to stop choosing between readable and fast, start here.