Code ‐ Logic and the Flow of Thought

Early Return

• 조건이 안 맞으면 함수를 즉시 끝내버리고(return), 통과한 경우만 아래로 진행하는 방식이다.

// ❌ Before — if 안에 if 안에 if (화살표 모양 ▷)
function process(user) {
  if (user) {              // 1단계 들여쓰기
    if (user.active) {     // 2단계 — user 있음 + active
      for (order) {        // 3단계 — + 반복 중
        if (order.paid) {  // 4단계 — + 결제됨
          doSomething();   // 😵 여기 오려면 조건 4개를 다 이고 와야 함
        }
      }
    }
  }
}

// ✅ 얼리 리턴으로 펴기 → 들여쓰기 1단계로
function process(user) {
  if (!user) return;
  if (!user.active) return;

  for (const order of user.orders) {
    if (!order.paid) continue;
    doSomething(order);        // 들여쓰기 얕음 → 읽기 편함
  }
}

• 주의 : 얼리 리턴이 항상 정답은 아니다. 리턴 지점이 흩어지면 오히려 흐름 추적이 어려울 수 있다.

Minimizing the Depth of Thought

• 사고의 depth란, 이 코드를 이해하려면 몇 단계를 파고 들어가야 하는가이다.
• 머릿속에서 따락가야 하는 논리의 깊이다.

// 이 값이 뭔지 알려면 몇 단계를 파야 하나?
const result = calc(getConfig(loadUser(session.getId())).rate);
//              4      3          2        1
// session → loadUser → getConfig → calc  ... 4단계를 머릿속에서 추적

// ❌ 한 호흡에 4단계 — 머릿속 스택 4개
const result = calc(getConfig(loadUser(session.getId())).rate);

// ✅ 단계마다 착지 → 각 줄은 depth 1
const userId = session.getId();
const user = loadUser(userId);
const rate = getConfig(user).rate;
const result = calc(rate);

// ❌ 조건 depth 3 — "3겹 안"에서 사고
if (a) { if (b) { if (c) { doIt(); }}}

// ✅ depth 1 — 통과하면 잊어버림
if (!a) return;
if (!b) return;
if (!c) return;
doIt();

// ❌ 이중 부정 — "안 유효하지 않으면" ← 머리에서 뒤집어야 함
if (!isNotValid) { ... }

// ✅ 긍정 — 바로 읽힘
if (isValid) { ... }

// ❌ 조건이 뭘 뜻하는지 해석하는 사고가 필요
if (user.age >= 19 && user.point > 1000 && !user.isBanned) { ... }

// ✅ 조건에 이름을 붙여 해석을 미리 끝냄
const isEligible = user.age >= 19 && user.point > 1000 && !user.isBanned;
if (isEligible) { ... }

Proper Handling of Line Breaks and Whitespace

• 공백 라인은 글의 "문단 나누기"와 똑같다. 관련 있는 코드는 붙이고, 주제가 바뀌면 한 줄 띄우는 것이다.
• "준비 → 실행 → 정리"처럼 하는 일의 성격이 바뀌는 지점에 넣어주면 좋다.

// ❌ 다 붙어 있음 — 어디서 끊어 읽어야 할지 모름
function checkout(cart) {
  const user = getUser();
  const items = cart.items;
  validateStock(items);
  validateUser(user);
  const subtotal = sum(items);
  const discount = getDiscount(user);
  const total = subtotal - discount;
  saveOrder(user, total);
  sendEmail(user);
}

// ✅ 생각의 단위로 문단 나누기
function checkout(cart) {
  const user = getUser();
  const items = cart.items;

  validateStock(items);        // ── 검증 단계
  validateUser(user);

  const subtotal = sum(items); // ── 금액 계산 단계
  const discount = getDiscount(user);
  const total = subtotal - discount;

  saveOrder(user, total);      // ── 마무리 단계
  sendEmail(user);
}

Dealing with Negation

• 부정어(!, not, isNot, !=)는 뇌가 한 번 더 뒤집는 연산을 해야 한다.

if (!isNotValid) { ... }

• 이걸 이해하려면 머릿속에서: "isNotValid가 아니다" → "즉 not(not valid)" → "결국 valid하다". 뒤집기를 두 번이나 해야 뜻이 나온다.

// ❌ 이중 부정 — 머리에서 두 번 뒤집기
if (!isNotEmpty) { ... }
if (!user.isDisabled) { ... }

// ✅ 긍정으로
if (isEmpty) { ... }
if (user.isEnabled) { ... }

// ✅ 부정을 "쳐내는" 데 쓰기 — 자연스러움
function process(user) {
  if (!user) return;           // "없으면 나가"
  if (!user.isActive) return;  // "비활성이면 나가"

  // 여기부터는 전부 긍정 상태 → 부정 없이 깔끔
  doWork(user);
}

// ❌ 덩어리째 부정 — "A와 B가 둘 다인 게 아니라면?" 헷갈림
if (!(isMember && hasPoint)) { ... }

// ✅ 드모르간 법칙으로 풀기
if (!isMember || !hasPoint) { ... }   // "회원 아니거나 포인트 없으면"

// ❌ 부정이 얽혀서 해석이 필요
if (!user.isBanned && !order.isCancelled && !item.isSoldOut) { ... }

// ✅ 긍정 개념으로 요약
const canPurchase = !user.isBanned && !order.isCancelled && !item.isSoldOut;
if (canPurchase) { ... }

// ✅ "빈 경우 처리"가 본래 의도면 부정이 자연스러움
if (list.isEmpty()) return;

// ❌ 억지 긍정 — 오히려 어색
if (list.hasAtLeastOneElement() == false) ...

• 주의 : "부정을 없애라"가 아니라 "부정을 겹치지 마라", "뒤집게 만들지 마라"는 것이다. 단일 부정은 명확하면 괜찮다.

Handling Happy Path and Exceptions

• 해피 케이스 = 모든 게 정상일 때의 흐름
• 예외 처리 = 뭔가 잘못됐을 때의 처리

// ❌ 예외 처리가 본 로직을 감싸서 진짜 로직이 안 보임
function getUserName(id) {
  if (id != null) {
    const user = findUser(id);
    if (user != null) {
      if (user.name != null) {
        return user.name;        // 😵 진짜 하려는 일이 3겹 안에 파묻힘
      } else {
        return "이름 없음";
      }
    } else {
      return "유저 없음";
    }
  } else {
    return "잘못된 ID";
  }
}

// ✅ 예외 먼저(가드 절) → 해피 케이스는 마지막에 깔끔하게
function getUserName(id) {
  if (id == null) return "잘못된 ID";      // 예외 1

  const user = findUser(id);
  if (user == null) return "유저 없음";     // 예외 2
  if (user.name == null) return "이름 없음"; // 예외 3

  return user.name;                         // ✨ 해피 케이스 — 한눈에 보임
}

• 예외들은 위에서 다 걸러내고, 함수의 진짜 목적을 맨 아래에 평평하게 둔다. 즉, "예외는 위로, 해피는 아래로" 가도록 작성해야 해피 케이스 구역을 읽을 때 "이미 정상"임을 보장할 수 있어서 예외 걱정 없이 본 로직에만 집중할 수 있다.

function doSomething(input) {
  // ┌─────────────────────────┐
  // │ 1. 예외 처리 구역 (가드)      ← 비정상 케이스를 전부 쳐냄
  if (!valid) return ...;
  if (!found) return ...;
  // └─────────────────────────┘

  // ┌─────────────────────────┐
  // │ 2. 해피 케이스 구역          ← 정상 로직만, 방해 없이
  return realWork();
  // └─────────────────────────┘
}