Julia

The intermediate step in Julia

A beginner course ends with programs that run. An intermediate course begins with programs that must keep running well as they gain features, data, and collaborators. That shift is the whole subject here: how Julia chooses code, how it represents data, and how you can measure what your code costs.

Multiple dispatch stops being a curiosity at this level and becomes a design tool. You will write methods that overlap, resolve the ambiguities between them, dispatch on values as well as types, and inspect the method table your own code creates. When dispatch is the structure, adding a new case means adding a method, not editing a chain of conditions.

Forty-eight lessons in ten groups assume the beginner course is complete. Nothing from it is re-taught. Concepts arrive in the order they are needed, and every example was run twice against the real Julia interpreter before publication.

What you will learn

Each group below adds one layer to the last, and the list names what each layer gives you.

• Resolve method ambiguities, write parametric methods, dispatch on values, and inspect method tables
• Design with concrete and abstract types, type parameters, unions, constraints, and parametric structs
• Prove type stability, count allocations, build function barriers, and read scaling from measurements
• Quote expressions, write hygienic macros, build generated functions, and generate code safely
• Organise modules and submodules, read project files, and follow the package workflow
• Model exception types, throw custom errors, and use finally blocks that always run
• Read CSV files, shape tables from structs, group and summarise rows, handle missing values, and join tables
• Run threaded loops, coordinate async tasks, pass values through channels, and reduce in parallel
• Finish a data pipeline, a numerical solver, a small expression language, and a config interpreter

Why Julia rewards the deeper look

Julia compiles each method for the concrete types it actually receives. That single fact explains both the speed and the surprises: a function that returns different types on different paths forces the compiler to hedge, and hedging costs allocations. Once you can see that mechanism, performance stops being folklore and becomes something you can test in a few lines.

The performance group therefore measures instead of guessing. Allocation counts after a warm-up call show whether a barrier worked. A doubling comprehension over an abstract container shows what boxing costs. Scaling counts across input sizes show whether a routine grows gently or not. No lesson asks you to trust a timing claim you cannot reproduce.

Metaprogramming earns its place the same way. Macros are not a party trick here: they remove repetition that functions cannot reach, and hygiene rules explain why a macro-introduced name stays out of your way. Generated functions appear only as a first look, with the warning that compile-time code generation is a sharp tool kept for narrow jobs.

How this course works

Every lesson opens with a short definition, shows two or three focused examples, and closes with a full program plus an exercise. The examples stay small on purpose: a three-line program that prints an allocation count teaches more than a page of advice about speed.

The course ends with four projects that combine unlike parts of the material. The data pipeline draws on CSV reading, grouping, and sorted summaries. The numerical solver draws on iteration and rounding. The expression language draws on parsing and evaluation. The config interpreter draws on dictionaries and file reading. Skipping a group shows up quickly when its project starts.

The forty-eight lessons add up to two hours and forty-eight minutes. Taken one group per sitting, the material fits comfortably into about a fortnight of evenings. No external package is required anywhere: tables are vectors of structs, CSV comes from the standard library, and parallelism uses the threads and tasks Julia ships with.

Frequently asked questions

What should I know before starting Julia Intermediate?

The beginner course, or its equivalent: variables, functions, multiple dispatch, arrays, dictionaries, structs, files, and basic error handling. This course builds directly on those lessons and does not repeat them.

What is multiple dispatch in depth?

It is the practice of designing with method selection: overlapping methods, ambiguous signatures, parametric methods, and value dispatch. The dispatch group shows how Julia picks a method and how you resolve the cases where no single method wins.

Why does Julia care about type stability?

Because the compiler specialises each method for concrete argument types. A function whose return type Julia cannot predict forces extra allocation and slower code. The performance group proves this with allocation counts you can reproduce.

Do I need to install packages for this course?

No. Every lesson uses Julia itself plus its standard library: DelimitedFiles for CSV, Test for inferred checks, and the built-in threading and task tools. Tables are plain vectors of structs, not an external frame library.

How long does Julia Intermediate take?

Timings sum to 168 minutes across the course. The four projects together need under twenty minutes of that total. One group per sitting keeps the pace gentle across roughly a fortnight.

Is the Julia intermediate course free?

Yes. The full set of forty-eight lessons, the four closing projects, and every exercise costs nothing to read, with no account or sign-up step anywhere.

Next steps

• Julia Beginner ❯ — Fifty-two lessons from first print to files and structs, the foundation this course assumes throughout.
• Haskell Intermediate ❯ — Fifty lessons in another language where types do heavy lifting, a useful second angle on the same ideas.