Question 1

Why are null references called a billion-dollar mistake?

Accepted Answer

Because **Tony Hoare**, who introduced the null reference into ALGOL W in 1965, later described it exactly that way — apologising publicly for a design decision that has produced an enormous quantity of crashes and defects across every language that copied it.

**His own account** was that he added it simply because it was easy to implement, and that it has since caused innumerable errors, vulnerabilities and system crashes — costing, in his estimate, something on the order of a billion dollars.

**Why it is genuinely a design flaw**, not merely a source of ordinary bugs:

**It makes every reference type secretly two types.** A parameter declared as a string is actually "a string, or nothing at all". The type system claims one thing and permits another, so it lies.

**The failure is deferred.** Nothing catches the problem at the point where the null was introduced; it surfaces later, wherever the value is finally used, frequently far from the cause.

**Nothing forces you to handle it.** The compiler is content. You discover the omission at runtime, in production, from a user.

**It conflates distinct meanings** — not found, not applicable, not yet loaded, error, and genuinely empty are all represented identically.

**How modern languages address it:**

**Option or Maybe types** — Rust's `Option<T>`, Haskell's `Maybe`, Swift's optionals. Absence becomes a **distinct type** the compiler forces you to unwrap, so the omission is a compile error rather than a crash.

**Non-nullable by default with explicit nullable types** — Kotlin, Swift, TypeScript with strict null checks, and C# with nullable reference annotations. The default becomes safe; nullability is opt-in and visible in the signature.

**Convenience syntax** so the safe path is not tedious — optional chaining, null coalescing, `if let` bindings, and pattern matching.

**The deeper lesson**, which generalises well beyond null: **make illegal states unrepresentable**. If the type system cannot express the invalid case, no amount of care is required to avoid it.

Question 2

What is the difference between a compiler error, a runtime error and a logic error?

Accepted Answer

They differ in when the problem is discovered, and that ordering is also the order of increasing cost. Compile-time errors are found before the program runs. Syntax errors, type mismatches, undefined

Question 3

What is memory safety, and why does it matter so much?

Accepted Answer

A property of a language or system guaranteeing that a program cannot access memory it should not — no reading past the end of a buffer, no using freed memory, no dereferencing invalid pointers. Its

Question 4

Can you have a memory leak in a garbage-collected language?

Accepted Answer

Yes, and this surprises people who assume garbage collection makes leaks impossible. It removes one class of leak and leaves another entirely intact. What garbage collection actually does. It

Question 5

What is the difference between a linter and a formatter?

Accepted Answer

A formatter changes how code looks. A linter analyses what code does and flags problems. They are complementary, and confusing them leads to teams configuring one to do the other's job badly. A

Question 6

How does garbage collection actually work?

Accepted Answer

By determining which objects are still reachable from your running program and reclaiming everything else. The key insight is that it does not detect garbage — it detects live data, and treats the

Question 7

Should errors be exceptions or return values?

Accepted Answer

A genuine design disagreement rather than a settled question — and the honest answer is that the two approaches differ in what they make visible in the type system and what they make easy to ignore.

Related Questions