Julia Variables and Types

Julia variables are dynamically typed: x = 5 creates a binding named x to an Int64 value without any declaration, and the same name can later be rebound to a value of a completely different type, such as x = "hello". Naming conventions favor lowercase words separated by underscores for variables and functions (learning_rate), CamelCase for types and modules (LinearAlgebra), and, unusually among mainstream languages, Julia allows full Unicode identifiers, so mathematically-styled code can write α = 0.01 or μ, σ = 0.0, 1.0 directly, typed in the REPL via LaTeX-style Tab-completion like \alpha<Tab>.

Every value in Julia has a type, discoverable with typeof(x), and every type sits somewhere in a single hierarchy rooted at Any. Types are split into abstract types, which exist only to group related types and cannot be instantiated (Number, Real, AbstractFloat), and concrete types, which values actually have (Float64, Int64, Bool); for example, Float64 <: AbstractFloat <: Real <: Number <: Any, and you can check any such relationship yourself with the subtype operator, Float64 <: Number (which evaluates to true).

Type annotations with :: are optional but purposeful: function scale(x::Float64, factor::Float64) restricts which method gets called via multiple dispatch and documents intent, while x::Float64 = 5.0 inside a function or struct field enforces that the value must actually be (or convert to) that type, throwing a MethodError or TypeError otherwise. Best practice favors annotating with the most general abstract type that still lets the code work correctly (e.g., Real instead of hard-coding Float64), since this keeps a function usable for Int64, Float32, or even user-defined number types without sacrificing dispatch precision.

Julia's built-in primitive numeric types include Int64/Int32 (fixed-width signed integers), UInt8 through UInt64 (unsigned), Float64/Float32 (IEEE 754 floating point), Bool, and Char, plus String for text (which, unlike Char, can hold any number of Unicode characters). Beyond these, you define your own composite types with the struct keyword — struct Point; x::Float64; y::Float64; end creates an immutable type with fields x and y — or mutable struct when fields need to be reassigned after construction, such as a mutable struct Counter; count::Int; end whose count field you intend to increment in place.

A function is 'type-stable' when the type of its return value can be inferred from the types of its inputs alone, without depending on runtime values — this is the single most important property for Julia performance, because it lets the compiler generate specialized, allocation-free machine code instead of falling back to slow, boxed, dynamically-typed dispatch at every operation. A classic type-instability bug is a function like f(x) = x > 0 ? 1 : 1.0, which returns an Int64 or a Float64 depending on a runtime condition; the fix is usually to make both branches return the same concrete type, such as 1.0 in both cases.