Building High-Performance Systems with Julia: Numerical Computing, Multiple Dispatch, Multithreading, Distributed Computing, and GPU Programming

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.