Programming with Julia

Learn to install and manage Julia with the juliaup command line tool, including installing, updating, listing versions, and setting the default on Windows and other platforms.

Download the julialang.org installer and choose Windows 64-bit for the current stable release 1.7.0 or the long-term support release 1.6.4, then run the installer and add Julia to PATH.

Download the linux 64-bit julia binary from julialang.org, extract the tar on ubuntu, add julia to PATH with a symbolic link, and verify by running julia.

Install Julia and start the REPL to write expressions, access help with ?, use the package manager to add or remove packages; for large programs, switch to notebooks or IDEs.

Explore Julia editors and IDEs, including VSCode, Jupyter notebooks with IJulia, and Pluto notebooks, highlighting reactive cells, live docs, and project environments for clean dependency management.

Explore Julia's type system, an optionally typed language where variables may lack declarations, yet types can be inferred or specified for performance, with user-defined, parameterized types via the type hierarchy.

Declare and use variables in Julia, assign values, and inspect types with typeof. Use Unicode names and multi-variable assignment; declare constants with const and type annotations.

Explore the Julia type hierarchy from Any to Union, detailing abstract and concrete types, subtypes, supertypes, and how to use <: with subtypes and supertype functions.

Explore integer and floating point data types in Julia, including signed and unsigned integers, bit sizes, overflow, type conversions, bools, and handling of Inf, NaN, and epsilon.

Explore complex numbers and the imaginary unit in Julia, using a+bi notation and the complex function, and learn about conjugate, real/imag parts, and rational numbers with // and isa.

Explore Julia's text types, including char and string variants (string, substring, substitution string), Unicode handling, one-based indexing, and basic string operations like concatenation and interpolation.

Explore Julia primitive and composite types, defining primitive types with bits, using the struct keyword for composites, and leveraging unions and abstract supertypes to model data with multiple dispatch.

Explore Julia's parametric types, where type parameters define flexible field data and enforce constraints with <: Real. See ParRectangle and shape structs with fields sharing the same type.

Learn Julia basics: arithmetic operations including implicit multiplication, div and rem, and operator as function; compare values, apply boolean and bitwise operators, and use common math and trig functions.

Julia introduces data types like strings, integers, and floating point numbers, and explores structs, collections, arrays, tuples, sets, and dictionaries, including mutable vs immutable behavior and matching arrays by order.

Explore how tuples in Julia store a fixed-size, possibly mixed-type sequence, with access by index, naming options, and unpacking, plus ntuples and in and not in membership checks.

Learn how to use dictionaries in Julia to store key-value pairs, access by key, and mutate data with operations like get, haskey, delete, merge, and mergewith.

Create and manipulate ranges in Julia, from 1:10 to step and decreasing ranges, and learn how collect converts ranges to arrays and range function variants use start, stop, and step.

Explore arrays as sequences that extend strings to any data type, including vectors and matrices. Learn indexing, slicing, and common operations like push, append, deleteat, insert, and split.

Explore vectors and matrices in Julia, covering column and row vectors, indexing and slicing, and creating, reshaping, and concatenating arrays with vcat and hcat.

Explore multidimensional arrays in Julia, from three-dimensional stacks of matrices to layer indexing, creation with the Array keyword, and reshaping with undef, nothing, and missing values.

Explore Julia broadcasting and the dot syntax to perform element-wise operations on vectors and matrices, including scalar broadcasting and boolean indexing for efficient data filtering.

Learn how sets in Julia remove duplicates from arrays or tuples and compare elements without regard to order, using union, intersection, set difference, and symmetric difference.

Explore basic linear algebra in Julia, covering trace, determinant, transpose, and matrix and element-wise multiplication with dot syntax, using LinearAlgebra and inv() for inverses, plus solving systems with A \ B.

Explore how programs perform tasks in sequence, by conditions, or via loops, including nested loops, and see how these patterns are implemented in Julia.

Explore how julia executes multiple expressions in order with compound expressions, either begin end blocks or parenthesized statements with semicolons, and blocks have no scope, returning the last expression.

Explore conditional evaluation in Julia using if, else, and elseif to convert exam scores into letter grades, with nested conditions, logical operators, and the ternary shortcut for concise decisions.

Explore how Julia uses and and or operators to short circuit if conditions with a condition and statement structure, and validate data by parsing input to integers.

Master for loops in Julia to perform repetitive tasks by iterating over ranges and collections, using enumerate, zip, and nested loops to process matrices, strings, and files.

Master while loops in Julia by repeating tasks while conditions hold, updating state, and preventing infinite loops, with examples of user input until zero and printing squares.

Learn to control loops in Julia using break and continue, stopping at 999 or skipping it. Practice while loops that print even numbers and roll two dice until 6-6.

Explore Julia comprehensions to write concise for loops that build arrays, filter even numbers, nest iterations, and use generators for memory-efficient, fast large-array performance.

Automate repetitive tasks with Julia by writing functions, and compare defining them with the function keyword or a one-line form while understanding pass by sharing.

Discover how to define and call functions in Julia, including arguments, returns, tuples, anonymous and recursive forms, with examples like max, mean, standard deviation, and Fibonacci.

Discover how Julia's higher-order functions map, reduce, and filter simplify loops, with broadcast and mapreduce, and use anonymous functions and the do syntax to process programming datasets.

Explore varargs in Julia, using the ellipsis to handle arbitrary function arguments, summing all inputs, finding the minimum, and employing slurping and splatting to combine or split arguments.

Define a simple function with two arguments a and b to compute a to the power of b, using a default for b when omitted to yield square of a.

Explore how Julia handles keyword arguments, separating them from positional arguments with a semicolon, and learn that keyword arguments can be supplied in any order, unlike Python and R.

Learn how to compose and chain functions using f(g(x)) and pipe and circular chain operators, with examples like squaring 5x, summing squares, and calculating root mean square error.

Learn how Julia mutates function arguments and signals in-place changes with exclamation-mark names, comparing mutating and nonmutating sorts and padding arrays with zeros.

Explore how Julia uses methods on functions, dispatching by argument types and counts to support multiple dispatch, with examples of integer sums, float differences, and string handling, ensuring consistency.

Master multiple dispatch in Julia by defining methods for numeric types, using the abstract number, and understanding ambiguity, intersection cases, and optional arguments.

Explore parametric types and multiple dispatch in Julia, define fallbacks for mixed argument types, apply <: constraints, and implement circle and rectangle methods with a customized show function.

Define a struct with coefficients and implement a call method so instances act as functions. Call the model with inputs to compute results, illustrating function like objects (functors) in Julia.

Explore constructors in Julia, including outer and inner constructors, mutable and immutable types, and keyword-argument defaults for creating robust, validated composite type instances.

Demonstrate building a simple neural network in Julia using composite types, methods, and constructors, without a deep learning framework, via weight matrices and layerwise matrix multiplications.

Explore how to organize Julia projects with modules and packages, using export, import, and include to separate design from implementation and boost productivity.

Learn to create Julia modules for bank, customer, and transactions, implement deposit and withdraw operations, export types, and use include and load_path for module management.

Discover how the Revise package speeds Julia module development by hot-reloading changes in the REPL, saving time and ensuring updates take effect without restarts.

Learn to create Julia packages using the pkg manager and PkgTemplates, structure the project with a module file and tests, and publish and register on GitHub.

Explore meta programming in Julia, where code is data and abstract syntax trees enable macros; learn how generating new code, concise code, and automated boilerplate can boost productivity.

Explore how Julia uses literals, variables, and the colon operator to form symbols and expressions, how to evaluate, inspect, and parse expressions using head and arguments, and how interpolation works.

Discover how Julia macros take expressions as input, invoke and modify them, and output new code that expands during compilation. Compare with functions, and explore environment awareness and expression-based macros.

Explore how programs interact with the outside world in Julia by handling user input and output, file I/O, and server-client communication.

Learn how to read from standard input and write to standard output in Julia, using teletype, read and write, line-by-line and character-by-character input, with Windows prompts.

Learn how to perform file input and output in Julia by opening files, reading lines with readlines, writing with do-blocks, and managing directories by creating folders and listing contents.

Explore how TCP/IP enables device communication over a network using IP addresses, ports, and sockets, and build a Julia server and client with the listen function and async handling.