The Best Books to Learn Julia Programming
This curriculum takes an intermediate programmer from Julia's core syntax and idioms all the way to production-grade numerical computing and high-performance data science. Each stage builds directly on the last: you first internalize Julia's unique design philosophy, then apply it to scientific computing and data workflows, and finally master the low-level performance techniques that make Julia exceptional.
Julia Foundations
IntermediateGain fluency in Julia's syntax, type system, multiple dispatch, and core standard library so you can write idiomatic, correct Julia code.
▸ Study plan for this stage
Pace: 8–10 weeks, ~25–30 pages/day (alternating between the two books; ~3–4 weeks per book with overlap for reinforcement)
- Julia's syntax fundamentals: variables, control flow, functions, and scoping rules
- Type system and type stability: concrete vs. abstract types, type annotations, and performance implications
- Multiple dispatch: method definition, type-based function resolution, and idiomatic dispatch patterns
- Core standard library: collections (arrays, dicts, tuples), string manipulation, and I/O operations
- Function design patterns: argument types, return types, and writing generic, reusable code
- Performance awareness: type inference, avoiding type instability, and profiling basics
- Practical problem-solving: translating mathematical/operational research concepts into Julia code
- How does Julia's multiple dispatch differ from single-dispatch OOP, and why is it powerful for mathematical computing?
- What is type stability, why does it matter for performance, and how do you identify and fix type-unstable code?
- How do you design a function signature that leverages multiple dispatch to handle different input types elegantly?
- What are the key differences between concrete types, abstract types, and parametric types, and when should you use each?
- How do you work effectively with Julia's standard collections (arrays, dicts, tuples) and what are their performance characteristics?
- What does idiomatic Julia code look like, and how do the two books' approaches (operations research vs. general programming) reinforce each other?
- Rewrite a mathematical algorithm (e.g., simplex method or gradient descent) from pseudocode into Julia, paying attention to type stability and dispatch
- Create a set of overloaded functions using multiple dispatch to handle scalars, vectors, and matrices for a single operation (e.g., matrix multiplication, normalization)
- Build a small optimization problem solver using Julia's syntax and type system; compare performance before and after adding type annotations
- Implement a custom data structure (e.g., a sparse matrix or graph representation) using Julia's type system and write methods that dispatch on its type
- Refactor poorly-written Julia code to be type-stable; use @code_warntype to identify instabilities and fix them
- Write a module that exports functions with clear, documented type signatures; test it with different input types to verify dispatch works as intended
Next up: This stage equips you with the syntactic fluency and type-system mastery needed to move into specialized domains—whether that's numerical computing, data science, or optimization—where you'll apply these foundations to real-world problems and libraries.
A concise, practical introduction to Julia that teaches the language through real optimization problems — ideal for someone with programming experience who wants to learn Julia's idioms quickly without starting from absolute zero.
Covers Julia's type system, multiple dispatch, and module system with careful clarity; reading it second solidifies the conceptual foundations that the first book introduced more informally.
Scientific & Numerical Computing
IntermediateApply Julia to numerical methods, linear algebra, differential equations, and scientific simulation — the core use cases that make Julia indispensable.
▸ Study plan for this stage
Pace: 8–10 weeks, ~40–50 pages/day (mix of theory and code implementation)
- Floating-point arithmetic, error analysis, and stability in numerical algorithms
- Root-finding methods (bisection, Newton's method, secant method) and convergence criteria
- Interpolation and approximation techniques (polynomial, spline, least-squares fitting)
- Numerical differentiation and integration (finite differences, quadrature rules)
- Direct and iterative methods for solving linear systems (LU decomposition, Gaussian elimination, iterative solvers)
- Eigenvalue problems and their applications to stability and dynamics
- Numerical methods for ordinary differential equations (Euler, Runge–Kutta, multistep methods)
- Data manipulation, transformation, and aggregation workflows in Julia using DataFrames and related packages
- How do floating-point rounding errors propagate through a numerical computation, and what strategies minimize their impact?
- When would you choose Newton's method over bisection, and what are the trade-offs in convergence speed versus robustness?
- How do you select an appropriate interpolation or approximation method for a given dataset, and what are the pitfalls of overfitting?
- What is the difference between direct and iterative solvers for linear systems, and when is each preferable?
- How do you assess the stability and accuracy of a numerical ODE solver, and how do step size and method order affect the solution?
- What are the key operations in a typical data analysis workflow, and how do DataFrames and related Julia packages streamline them?
- Implement bisection and Newton's method from scratch; compare convergence rates on test functions and document trade-offs
- Build a polynomial interpolation routine using Lagrange basis; test on noisy data and compare with spline interpolation
- Solve a system of linear equations using both LU decomposition and an iterative method (e.g., Gauss–Seidel); measure accuracy and runtime
- Numerically differentiate and integrate a function using finite differences and quadrature; validate against analytical results
- Implement a Runge–Kutta ODE solver and apply it to a physical system (e.g., pendulum, predator–prey); visualize and analyze stability
- Load a real dataset into a DataFrame; perform grouping, filtering, joining, and aggregation operations; export results
Next up: This stage equips you with the numerical and data-handling foundations to tackle advanced topics like optimization, machine learning, and large-scale scientific simulations in subsequent stages.
Uses Julia throughout to teach numerical analysis (rootfinding, interpolation, ODEs, linear systems), giving you both the mathematical grounding and hands-on Julia practice simultaneously.
Bridges numerical computing and data science by teaching DataFrames.jl and the broader Julia data ecosystem in depth — the natural next step after you can write solid numerical Julia code.
Data Science & Machine Learning in Julia
IntermediateBuild end-to-end data science pipelines in Julia, including data wrangling, statistical modeling, and machine learning workflows.
▸ Study plan for this stage
Pace: 8–10 weeks, ~40–50 pages/day with active coding
- Probability distributions and their parameterization in Julia using Distributions.jl
- Descriptive statistics: computing and interpreting mean, variance, skewness, and correlation
- Hypothesis testing frameworks: null/alternative hypotheses, p-values, Type I/II errors, and power analysis
- Linear regression: model fitting, interpretation of coefficients, residual diagnostics, and model validation
- Bayesian inference: prior/posterior distributions, MCMC methods, and credible intervals
- Resampling methods: bootstrap and permutation tests for robust statistical inference
- Generalized Linear Models (GLMs): logistic regression and Poisson regression for non-normal data
- Statistical workflow in Julia: data loading, cleaning, exploratory analysis, and reproducible reporting
- How do you create, sample from, and fit probability distributions in Julia using Distributions.jl?
- What are the key steps in hypothesis testing, and how do you interpret p-values and confidence intervals?
- How do you build, validate, and diagnose a linear regression model in Julia, and what do residual plots reveal?
- What is the difference between frequentist and Bayesian approaches, and how do you implement MCMC sampling in Julia?
- When and why would you use logistic regression or Poisson regression instead of ordinary linear regression?
- How do you use bootstrap and permutation tests to estimate uncertainty and test hypotheses without strong distributional assumptions?
- Load a real dataset (e.g., iris, mtcars equivalent) and compute descriptive statistics; visualize distributions and correlations
- Conduct a complete hypothesis test (t-test, chi-square, or Mann-Whitney U) on a dataset: state hypotheses, compute test statistic, p-value, and interpret results
- Fit a linear regression model to data, extract coefficients and standard errors, create residual plots, and assess model assumptions
- Implement a bootstrap confidence interval for a parameter of interest (e.g., median, correlation) and compare to parametric alternatives
- Build a logistic regression model for binary classification; compute predictions, confusion matrix, and ROC curve
- Fit a Bayesian linear regression model using MCMC (e.g., with Turing.jl); visualize posterior distributions and credible intervals
- Perform a permutation test to compare two groups; visualize the null distribution and compute the p-value
- Create an end-to-end statistical analysis pipeline: data import → EDA → model fitting → diagnostics → reporting with plots and tables
Next up: This stage equips you with rigorous statistical foundations and hands-on Julia skills for inference and modeling, preparing you to extend these techniques into advanced machine learning workflows, feature engineering, and predictive modeling in subsequent stages.
Covers probability, statistics, and simulation using Julia's scientific stack; reading it here lets you apply a solid data-handling foundation to rigorous statistical reasoning.
High-Performance & Advanced Julia
ExpertMaster Julia's performance model — type inference, memory layout, parallelism, metaprogramming, and profiling — to write production-grade, high-throughput code.
▸ Study plan for this stage
Pace: 8–10 weeks, ~40–50 pages/day (mix of dense technical content and code examples; allow time for profiling and benchmarking)
- Type inference and stability: how Julia's compiler infers types and why type-unstable code kills performance
- Memory layout and allocation: understanding heap vs. stack, struct layout, and cache efficiency
- Parallelism models: multi-threading, distributed computing, and GPU acceleration in Julia
- Metaprogramming: macros, generated functions, and reflection to write generic, reusable high-performance code
- Profiling and benchmarking: using @time, @profile, @benchmark, and flame graphs to identify bottlenecks
- Design patterns: dispatch-based design, composition over inheritance, and idiomatic Julia patterns for maintainability
- Optimization workflows: iterative profiling, type-driven refactoring, and avoiding common performance pitfalls
- Production-grade code: testing, documentation, and packaging high-performance libraries
- What is type instability and why does it cause performance degradation? How do you detect and fix it?
- How does Julia's memory layout affect cache efficiency, and what strategies minimize allocations in tight loops?
- Compare multi-threading, distributed computing, and GPU acceleration in Julia: when would you use each?
- What are macros and generated functions, and how do they enable zero-cost abstractions in Julia?
- Walk through a profiling workflow: how would you identify a bottleneck in a real application and optimize it?
- What are the key design patterns from the Kwong book, and how do they improve code clarity and performance?
- Profile a simple Julia function (e.g., matrix multiplication or sorting) using @time and @profile; identify type instabilities and refactor for stability
- Write a type-unstable function, measure its performance, then rewrite it to be type-stable and compare benchmarks
- Implement a multi-threaded version of a CPU-bound algorithm (e.g., Monte Carlo simulation) and benchmark against single-threaded baseline
- Create a macro that generates specialized code for different numeric types (e.g., Float32 vs. Float64) and verify zero-cost abstraction
- Profile a memory-heavy algorithm using @profile and flame graphs; optimize by reducing allocations and improving cache locality
- Refactor an existing Julia function to follow one of Kwong's design patterns (e.g., dispatch-based design or composition); document the improvement in readability and performance
Next up: This stage equips you with the deep technical knowledge and optimization mindset needed to architect and maintain large-scale Julia systems; the next stage will focus on applying these principles to domain-specific problems (scientific computing, data science, systems programming) and building production libraries.
The canonical reference for Julia performance: covers type stability, SIMD, multithreading, and GPU computing — essential reading once you have real Julia projects to optimize.
Teaches advanced software design — parametric types, interfaces, anti-patterns, and large-scale architecture — giving you the engineering discipline to write maintainable, high-performance Julia at scale.
Discussion
Keep reading
Paths that share books, cover the same subject, or open a related topic.
