Appendices

Syntax cheat sheet, keywords, operator reference, Julia version highlights, learning resources and suggested study plan (12 weeks).

Appendices

43.1 Syntax cheat sheet baremodule begin break catch const continue do else elseif end export false finally for function global if import let local macro module quote return struct true try using while

Also reserved in context: abstract type, mutable struct, primitive type, where, in, isa, outer, public (1.11+).

43.3 Operator reference arithmetic (\ = left division) .op (e.g. .+, .*, .=) type annotation/assertion subtype / supertype adjoint (transpose for real matrices) interpolation (strings, expressions) ranges, symbols, quoting 43.4 Julia version highlights stable language, new Pkg, iteration protocol composable multi-threading (Threads.@spawn) @ccall, struct layout improvements parallel precompilation, faster loading, import X as Y property destructuring, new RNG (Xoshiro), @atomic typed globals, allocation profiler, @noinline call sites native code caching (package images), package extensions faster loading, parallel GC, new parser (JuliaSyntax)

public keyword, Memory type, @main entry point juliac (experimental), further latency & threading improvements 43.5 Learning resources

Official: julialang.org, docs.julialang.org (Manual — especially *Performance Tips*, *Types*, *Methods*), Julia Discourse (discourse.julialang.org), JuliaHub, JuliaCon talks (YouTube)

*Think Julia* — Ben Lauwens & Allen Downey (free online) *Julia as a Second Language* — Erik Engheim

*Hands-On Design Patterns and Best Practices with Julia* — Tom Kwong

*Julia for Data Analysis* — Bogumił Kamiński *Statistics with Julia* — Nazarathy & Klok

*Algorithms for Optimization* / *Algorithms for Decision Making* — Kochenderfer et al. (Julia code, free PDFs)

*Julia High Performance* — Avik Sengupta *Parallel Computing and Scientific Machine Learning* — Chris Rackauckas (MIT 18.337 notes, free)

*Computational Thinking with Julia* — MIT 18.S191 course (free, Pluto-based)

Practice: Exercism Julia track, Advent of Code, Project Euler, JuliaAcademy courses (free)

Community: Julia Slack & Zulip, Discourse, JuliaCon, local Julia meetups, Julia Forem/blog posts 43.6 Suggested study plan (12 weeks) Install, REPL modes, variables, numbers

Strings, control flow, functions, collections — Part I exercises Arrays, broadcasting, linear algebra

Types, structs, multiple dispatch, interfaces Modules & environments, errors, missing, I/O, dates, testing — Part II exercises, Project 1 Performance & profiling Metaprogramming, traits — Project 8

Tasks, threads, distributed, GPU — Project 4 Interop, AD, optimization (JuMP) — Project 5

Differential equations, ML, compilation/deployment — Project 6

DataFrames, visualization, notebooks — Project 2 Package development, web/databases, best practices — Project 3 or 7 🎓 Final Words

You've gone from println("Hello") to multiple dispatch, type-stable kernels, macros, GPU code, differential equations, and package development. Julia rewards understanding its compiler: write generic, type-stable functions and let multiple dispatch compose libraries for you. Join the Discourse community, explore the SciML and JuMP ecosystems, and build the capstone projects. Happy computing! 🟣🟢🔴

# Variables & types
x = 1; y::Float64 = 2.0; const C = 3; typeof(x); x isa Int
s = "str $x"; c = 'c'; sym = :name; t = (1, 2); nt = (a=1, b=2); d = Dict(:a => 1)

# Control flow
if cond ... elseif ... else ... end
cond ? a : b
for i in 1:n ... end;  while cond ... end;  break; continue

# Functions
f(x) = x^2
function g(x, y=1; z=2) ... end
h = x -> x + 1
map(x -> x^2, v); filter(iseven, v); reduce(+, v)
f.(v)                       # broadcast
v |> sum                    # pipe
(f ∘ g)(x)                  # compose

# Arrays
v = [1, 2, 3]; M = [1 2; 3 4]; zeros(3); rand(2, 2)
v[1]; v[end]; M[:, 1]; @view M[1, :]; push!(v, 4)
[x^2 for x in 1:5 if isodd(x)]

# Types & dispatch
abstract type A end
struct S <: A; x::Int; end
mutable struct M; x::Int; end
f(a::S) = a.x;  f(a::A) = 0
struct P{T}; x::T; end

# Modules & packages
module MyMod; export f; f() = 1; end
using .MyMod; import Base: show
] add Pkg; ] activate .; ] st

# Errors
try ... catch e ... finally ... end
throw(ArgumentError("msg")); error("msg"); @assert cond

# Macros & metaprogramming
ex = :(a + b); eval(ex); macro m(x) :($(esc(x)) * 2) end; @m 3

# Parallelism
@async ...; @sync ...; Threads.@threads for ...; Threads.@s
…