Immutability for safety in LLD - System Design Guide

Problem Statement

When multiple parts of a system share data that can change, unexpected bugs happen because one part changes data while another part is still using it. This causes crashes, inconsistent results, and hard-to-find errors, especially in concurrent or multi-threaded environments.

Solution

Immutability means data cannot be changed after creation. Instead of modifying existing data, new copies are made with changes. This prevents accidental changes and race conditions because shared data stays constant and safe to read by anyone at any time.

Architecture

Immutable Obj

(unchanged)

→Reader 1

↓

New Immutable

Obj (copy +

This diagram shows an immutable object shared safely by multiple readers. When changes are needed, a new immutable object is created instead of modifying the original.

Trade-offs

✓ Pros

→

Prevents bugs from unexpected data changes in concurrent environments.

→

Simplifies reasoning about program state since data never changes.

→

Enables safe sharing of data without locks or synchronization.

→

Facilitates undo/redo and time-travel debugging by keeping old versions.

✗ Cons

→

Can increase memory usage due to creating copies instead of modifying in place.

→

May cause performance overhead if large data structures are copied frequently.

→

Requires careful design to avoid excessive copying in performance-critical paths.

Use when your system has concurrent reads and writes to shared data or when safety and predictability are critical, especially in multi-threaded or distributed systems.

Avoid when working with very large mutable data that changes frequently and performance or memory is a strict constraint, and concurrency is not a concern.

Real World Examples

Google

Uses immutable data structures in their MapReduce framework to safely share data between distributed tasks without synchronization overhead.

Facebook

React library uses immutable state updates to efficiently detect changes and avoid bugs in UI rendering.

Twitter

Employs immutable messages in their distributed messaging system to ensure message integrity and safe concurrent processing.

Code Example

The before code shows a mutable UserProfile object that can be changed by any part, risking inconsistent state. The after code uses a frozen dataclass to make UserProfile immutable. Updates create new copies with changes, ensuring safety and predictability.

LLD

### Before (mutable shared state, unsafe)
class UserProfile:
    def __init__(self, name, age):
        self.name = name
        self.age = age

profile = UserProfile("Alice", 30)

# Multiple parts modify the same object
profile.age += 1  # Part A
profile.name = "Alicia"  # Part B

### After (immutable data, safe)
from dataclasses import dataclass, replace

@dataclass(frozen=True)
class UserProfile:
    name: str
    age: int

profile = UserProfile("Alice", 30)

# To update, create a new object
new_profile = replace(profile, age=profile.age + 1)
newer_profile = replace(new_profile, name="Alicia")

Alternatives

Lock-based synchronization

Allows mutable shared data but uses locks to control access and prevent concurrent modifications.

Use when: Choose when data changes are frequent and copying is too costly, but you can tolerate complexity and potential deadlocks.

Copy-on-write

Shares data until a write occurs, then copies only the part that changes, reducing full copies.

Use when: Choose when writes are rare compared to reads, to optimize memory and performance.

Summary

Immutability prevents bugs by ensuring data cannot change unexpectedly after creation.

It enables safe sharing of data in concurrent systems without locks or synchronization.

The trade-off is increased memory use and potential performance costs from copying data.

Practice

1. What is the main benefit of using immutability in system design?

easy

A. It allows faster data processing by skipping checks.

B. It makes data changeable by multiple users at the same time.

C. It prevents data from being changed after creation, improving safety.

D. It reduces the size of data stored in memory.

Solution

1. Step 1: Understand immutability meaning

   Immutability means data cannot be changed once created.

2. Step 2: Identify safety benefit

   This prevents accidental or concurrent changes, improving safety.

3. Final Answer:

   It prevents data from being changed after creation, improving safety. -> Option C

4. Quick Check:

   Immutability = Prevents changes [OK]

Hint: Immutability means no changes allowed after creation [OK]

Common Mistakes:

• Thinking immutability allows data changes
• Confusing immutability with performance optimization
• Assuming immutability reduces memory size

2. Which of the following code snippets correctly creates an immutable data structure in a low-level design context?

easy

A. Using a constant object or final class with no setters.

B. Using a regular class with public fields that can be changed.

C. Using a mutable list that allows adding or removing items.

D. Using a global variable that can be updated anytime.

Solution

1. Step 1: Identify immutable structure traits

   Immutable means no changes allowed after creation, so no setters or public mutable fields.

2. Step 2: Match code snippet to traits

   Constant object or final class with no setters fits immutability.

3. Final Answer:

   Using a constant object or final class with no setters. -> Option A

4. Quick Check:

   Immutable = constant, no setters [OK]

Hint: Immutable means no setters or public mutable fields [OK]

Common Mistakes:

• Choosing mutable lists or global variables
• Confusing final keyword with mutable fields
• Ignoring setters in class design

3. Consider this pseudo-code snippet for an immutable user profile object:

user = ImmutableUser(name='Alice', age=30)
user.age = 31
print(user.age)

What will be the output?

medium

A. 31

B. None

C. 30

D. Error: Cannot modify immutable object

Solution

1. Step 1: Understand immutability effect on assignment

   Immutable objects do not allow changing fields after creation.

2. Step 2: Analyze the assignment line

   Trying to assign user.age = 31 will cause an error because the object is immutable.

3. Final Answer:

   Error: Cannot modify immutable object -> Option D

4. Quick Check:

   Immutable object modification = Error [OK]

Hint: Immutable objects throw error on field change [OK]

Common Mistakes:

• Assuming value silently changes
• Assuming old value prints without error
• Ignoring immutability enforcement

4. You have a mutable shared configuration object causing race conditions in a concurrent system. Which fix uses immutability to solve this?

medium

A. Add locks around every access to the mutable object.

B. Replace the shared object with an immutable configuration instance passed by value.

C. Allow threads to modify the shared object but reset it periodically.

D. Use global variables to store configuration for faster access.

Solution

1. Step 1: Identify immutability benefit in concurrency

   Immutable objects prevent race conditions by disallowing changes.

2. Step 2: Choose solution using immutability

   Replacing shared mutable object with immutable instance passed by value avoids conflicts.

3. Final Answer:

   Replace the shared object with an immutable configuration instance passed by value. -> Option B

4. Quick Check:

   Immutability fixes race conditions [OK]

Hint: Immutable shared data avoids race conditions [OK]

Common Mistakes:

• Relying only on locks without immutability
• Allowing mutable shared state
• Using global variables increases risk

5. In a complex system, you want to safely share user session data across multiple services without accidental modification. Which design approach best uses immutability for safety?

hard

A. Create immutable session objects and pass copies to each service.

B. Use a single mutable session object shared globally with synchronization.

C. Store session data in a database and allow services to update it directly.

D. Send session data as plain text strings and let services parse and modify.

Solution

1. Step 1: Understand immutability in distributed systems

   Immutable objects prevent accidental changes when shared across services.

2. Step 2: Evaluate design options

   Passing immutable session copies ensures safety without synchronization overhead.

3. Final Answer:

   Create immutable session objects and pass copies to each service. -> Option A

4. Quick Check:

   Immutable copies for safe sharing [OK]

Hint: Pass immutable copies to avoid accidental changes [OK]

Common Mistakes:

• Using mutable shared objects with locks
• Allowing direct database updates without control
• Parsing and modifying plain text increases errors