What is immutable?

Immutable means “cannot be changed after it’s created.” In programming, an immutable value or object is fixed - any attempt to modify it actually produces a new copy, leaving the original exactly the same.

Let's break it down

Think of an immutable object like a printed photograph. You can look at it, show it to others, but you can’t alter the picture itself. If you want a different photo, you must take a new one. In code, numbers, strings, and tuples in many languages are immutable: assigning a new value creates a fresh object instead of editing the old one.

Why does it matter?

Because the data never changes, you can trust that it will stay the same throughout your program. This makes reasoning about code easier, prevents accidental bugs from hidden side‑effects, and allows safe use of the same data in multiple places or threads without extra locking.

Where is it used?

  • Functional programming languages (Haskell, Clojure) rely heavily on immutability.
  • In JavaScript/React, immutable state helps detect changes efficiently.
  • Databases and caches often store immutable snapshots for versioning.
  • Blockchain transactions are immutable records.
  • Many standard libraries provide immutable collections (e.g., Java’s List.of, Python’s frozenset).

Good things about it

  • Thread‑safe by default - no race conditions.
  • Predictable behavior; functions become pure and easier to test.
  • Enables powerful optimizations like sharing memory between copies.
  • Simplifies debugging because values don’t change unexpectedly.
  • Facilitates undo/redo features by keeping historic versions.

Not-so-good things

  • Can increase memory usage because each “change” creates a new object.
  • May lead to performance overhead if large structures are copied frequently.
  • Requires a different programming mindset; developers must think in terms of “new” rather than “modify.”
  • Some algorithms are more natural with mutable state, so extra work is needed to adapt them.