Question 1

What does "immutable" mean and why does it help?

Accepted Answer

An **immutable** value cannot be changed after it is created. Operations that appear to modify it return a **new** value instead, leaving the original intact.

**Why this helps, and the reasons compound:**

**You can reason locally.** If a value cannot change, you know what it holds without tracing every function it was passed to. Mutable values require you to consider everything that might have modified them, and that reasoning cost grows with the size of the codebase.

**No spooky action at a distance.** Passing a mutable object to a function that modifies it produces changes the caller did not expect — one of the most common sources of subtle bugs, particularly when the modification is incidental to the function's purpose.

**Thread safety is automatic.** Data races require concurrent **writes**. If nothing can be written, immutable data can be shared freely across threads with no locks. This is a substantial simplification and a major reason immutability is central to concurrent and functional programming.

**Cheap change detection.** If a value is never modified in place, reference equality is sufficient to detect change — you compare pointers rather than contents. This is exactly why React's rendering model and state libraries depend on immutable updates, and why mutating state in place causes re-renders to be missed.

**Easier debugging, undo and time travel.** Keeping previous versions costs nothing extra, since they were never overwritten.

**Safe caching and memoisation**, since a key cannot change underneath you.

**The costs, honestly:**

**Allocation.** Creating new values rather than mutating generates garbage. **Persistent data structures** mitigate this by **sharing unchanged parts** rather than copying wholesale, which makes the cost far smaller than it appears.

**Verbosity** in languages without good support for it.

**Genuinely hot loops** may need mutation for performance — a local, contained exception.

**Watch for shallow immutability.** Freezing an object does not freeze nested objects, which catches people out.

Question 2

Why does a mutable default argument cause bugs in Python?

Accepted Answer

Default argument values are evaluated once, when the function is defined, not each time it is called. For immutable defaults such as numbers, strings or None this is invisible. For a list, dictionary

Question 3

What is state management, and why is it hard?

Accepted Answer

State is any data that changes over time and affects behaviour. Managing it is hard because state creates dependencies across time — and time is the dimension our reasoning handles worst. Why it is

Question 4

What are mutexes, semaphores and atomic operations?

Accepted Answer

Three mechanisms for coordinating concurrent access to shared state, at different levels of abstraction — and choosing the wrong one is how concurrency bugs are introduced. Atomic operations. A

Question 5

What is refactoring, and how is it different from rewriting?

Accepted Answer

Refactoring is changing the internal structure of code without changing its external behaviour. That definition, from Martin Fowler, is precise and the constraint is what makes it refactoring rather

Question 6

What is a JIT compiler?

Accepted Answer

A compiler that translates code to machine instructions while the program is running, using information only available at runtime — which is how languages that appear to be interpreted achieve

Question 7

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

Related Questions