Programming Languages - Null, Nil, and None

The concept of null was invented in 1965 by Sir Tony Hoare, who famously referred to it as his "Billion Dollar Mistake" because null reference exceptions (NullPointerException, Segmentation fault) have historically caused countless crashes and security vulnerabilities across the software industry.

Modern programming languages handle the absence of a value using fundamentally different paradigms: raw null pointers, nullish duals, or type-safe Option wrappers.

1. Raw Null Pointers

In traditional systems and object-oriented languages, any object or pointer reference can hold a magic address pointing to nothing (0x0).

Language	Keyword	Key Semantics
C++	nullptr	Replaced legacy NULL / 0 in C++11. Strongly typed (std::nullptr_t), eliminating overload ambiguities.
Java	null	Any reference type can be null. Causes NullPointerException (NPE) if dereferenced without checks.
Go	nil	The zero value for pointers, interfaces, channels, slices, maps, and function types.
Python	None	A singleton instance of NoneType. Evaluates to False in boolean contexts.

The Go "Nil Interface" Gotcha

In Go, an interface value consists of two components under the hood: Type and Value ((type, value)). An interface is only equal to nil if both components are nil:

type MyError struct{}
func (e *MyError) Error() string { return "error" }

func getError() error {
    var err *MyError = nil
    return err // Returns (*MyError, nil) -> NOT equal to nil!
}

func main() {
    if getError() != nil {
        // This branch EXECUTES because interface type is *MyError, even though pointer is nil!
    }
}

2. Dual Absence: JavaScript's null vs undefined

JavaScript has two distinct primitive values representing absence:

• undefined: Represents an uninitialized or unassigned value (e.g. variable declared with let x, missing object property, or missing function argument).
• null: Represents an intentional absence of any object value.

let a;               // undefined (not yet assigned)
let b = null;        // null (intentionally set to empty)

typeof undefined;    // 'undefined'
typeof null;         // 'object' (legacy historical bug in JS engine)

null == undefined;   // true  (loose equality with type coercion)
null === undefined;  // false (strict equality)

3. Type-Safe Absence: Option / Maybe Monads

Modern languages avoid null pointers altogether by wrapping presence or absence inside an algebraic data type (enum).

Rust: Option<T>

Rust has no null keyword for safe code. A value is either present (Some(T)) or absent (None):

enum Option<T> {
    Some(T),
    None,
}

fn find_user(id: u32) -> Option<String> {
    if id == 1 { Some("Alice".to_string()) } else { None }
}

fn main() {
    let name = find_user(2);
    // Compiler forces you to handle the None case:
    match name {
        Some(val) => println!("User: {}", val),
        None => println!("User not found"),
    }
}

Memory Optimization: Rust applies the Null Pointer Optimization (NPO). For reference types like &T or Box<T>, Option<&T> is stored as a raw nullable pointer under the hood, taking zero extra memory overhead compared to a raw pointer.

Java: Optional<T>

Introduced in Java 8 to encourage explicit return types instead of returning null:

Optional<String> user = Optional.ofNullable(findUser());
String name = user.orElse("Guest");

4. Modern Null-Safe Operators

Modern languages incorporate dedicated syntactic operators to make working with optional or nullable values concise and safe:

Optional Chaining (?.)

Short-circuits evaluation and returns undefined / null if any property in the chain is absent:

// JavaScript / TypeScript / Swift / Kotlin / C#
const street = user?.address?.street;

Nullish Coalescing (??)

Returns the right-hand operand only when the left-hand operand is null or undefined (unlike ||, which also falls back on 0, "", or false):

const port = config.port ?? 3000;

Elvis Operator (?:)

Used in Kotlin, Groovy, and PHP as shorthand for ternary null checks:

val length = text?.length ?: 0

Language Comparison

Language	Null Primitive	Safe Alternative	Null-Safe Dereference	Strict Non-nullable Types?
Rust	None (unsafe raw ptrs only)	Option<T>	? operator	Yes (by design)
Go	nil	Multiple return (T, bool)	None	No
TypeScript	null, undefined	Union T | null	?.	Yes (strictNullChecks)
Kotlin	null	Nullable type T?	?., ?:	Yes
Swift	nil	Optional<T> / T?	?., ??	Yes
Java	null	Optional<T>	Java 8 stream methods	No (Null everywhere)
Python	None	Optional[T] (typing)	None (custom getattr)	No (Dynamic typing)