Organizing Data — Optimize¶

12 cases where the refactor is correct but the perf cost is real.

Optimize 1 — Encapsulate Collection allocates per call (Java)¶

public List<Order> orders() { return List.copyOf(orders); }

For 10K req/s, each calling orders() once: 10K list copies/s.

public List<Order> orders() { return Collections.unmodifiableList(orders); }

public Stream<Order> orders() { return orders.stream(); }

Optimize 2 — Replace Data Value with Object on a hot path (Java)¶

class Transaction {
    private Money amount;   // was double
}
class Money {
    private final double value;
    private final Currency currency;
}

In a batch processing job, 10M transactions per minute.

Optimize 3 — Replace Type Code with Class breaks switch optimization (Java)¶

enum Status { ACTIVE, INACTIVE, PENDING }
switch (status) {
    case ACTIVE -> ...;
    case INACTIVE -> ...;
    case PENDING -> ...;
}

vs. the old int status with switch(status).

Optimize 4 — Replace Magic Number adds runtime lookup (Python)¶

TAX_RATE = 0.07
def total(amount): return amount * (1 + TAX_RATE)

vs. old def total(amount): return amount * 1.07.

_TAX_RATE = 0.07
def total_many(amounts):
    rate = _TAX_RATE     # local lookup is faster than module lookup
    return [a * (1 + rate) for a in amounts]

def total(amount, _r=0.07): return amount * (1 + _r)

Optimize 5 — Encapsulate Field's accessor not inlined by JIT (Java)¶

class Account {
    private double balance;
    public double balance() { return balance; }   // ✓ free in steady state
}

Question: when isn't this free?

Optimize 6 — Replace Array with Object adds per-instance memory (Java)¶

String[] row = {"Alice", "Eng", "30"};   // ~40 bytes (3 refs + array header)

vs.

record Employee(String name, String title, int age) {}   // header + 2 refs + int = ~24 bytes

For 10M instances: - Array form: 400 MB. - Record form: 240 MB.

Records win.

Optimize 7 — Bidirectional with serialization loop (Java + Jackson)¶

class Customer { @JsonManagedReference List<Order> orders; }
class Order { @JsonBackReference Customer customer; }

class CustomerDto {
    String id;
    String name;
    List<OrderDto> orders;
}
class OrderDto {
    String id;
    String customerId;   // just the id, not the full customer
    Money total;
}

Optimize 8 — Encapsulate Collection with concurrent mutation (Java)¶

class Customer {
    private final List<Order> orders = new ArrayList<>();
    public List<Order> orders() { return Collections.unmodifiableList(orders); }
    public synchronized void add(Order o) { orders.add(o); }
}

// Caller:
for (Order o : customer.orders()) { ... }   // iteration
// Concurrently: anotherThread.add(...)

public List<Order> orders() { synchronized(this) { return new ArrayList<>(orders); } }

Optimize 9 — Replace Type Code with State allocates per transition (Java)¶

class Order {
    private OrderStatus status;
    public void submit() { status = new SubmittedStatus(); }
    public void ship() { status = new ShippedStatus(); }
}

class Order {
    private OrderStatus status;
    public void submit() { status = SubmittedStatus.INSTANCE; }
}
class SubmittedStatus implements OrderStatus {
    static final SubmittedStatus INSTANCE = new SubmittedStatus();
    private SubmittedStatus() {}
    ...
}

enum OrderStatus implements Status {
    DRAFT { public void cancel() { ... } },
    SHIPPED { public void cancel() { throw ... } };
    public abstract void cancel();
}

Optimize 10 — Encapsulate Field on a Python class without slots (Python)¶

class Account:
    def __init__(self, balance):
        self._balance = balance

    @property
    def balance(self):
        return self._balance

Each instance has a __dict__ (~280 bytes overhead).

class Account:
    __slots__ = ("_balance",)
    def __init__(self, balance):
        self._balance = balance

    @property
    def balance(self):
        return self._balance

Optimize 11 — Replace Reference to Value triggers expensive equals (Java)¶

public record Customer(String id, String name, String email, Address address) {}

Records auto-generate equals based on all fields. Address has its own auto-generated equals based on its fields.

HashMap<Customer, X> map = ...;
map.get(someCustomer);   // calls equals → walks all fields recursively

For complex nested values, equality is O(total field count).

HashMap<String, Customer> byId = ...;
byId.get(customer.id());

public record Customer(String id, String name, ...) {
    public static EqualBy idEquals = ...;
}

Optimize 12 — Magic Number Constant in JS / TypeScript (TypeScript)¶

const TAX_RATE = 0.07;
function total(x: number): number { return x * (1 + TAX_RATE); }

V8 inlines TAX_RATE as long as it's const and not exported (or if the bundler does dead-code elimination).

function makeCalculator(rate = TAX_RATE) {
  return (x: number) => x * (1 + rate);
}

Patterns¶

Next¶

• tasks.md — practice clean refactors
• find-bug.md — wrong refactors
• interview.md — review