Long Method

Signs

• You have to scroll to see the whole function, or you need to keep more than a handful of local variables in your head at once.
• Blank lines and comments split the body into "paragraphs" such as // validate, // compute totals, // send email.
• The name is vague (process, handle, run) because no specific name covers everything it does.
• Tests for it need large fixtures, and each test asserts on many unrelated outputs.
• Diffs touch the same function for unrelated reasons: a tax change and a logging change land in the same 150 lines.

Why it happens

Adding a line to an existing function always feels cheaper than creating a new one. Each change is small and reasonable, so nobody notices the function crossing the line from "a step" to "a workflow". Local variables make it worse: once five temporaries are shared across the body, pulling out a piece means deciding what to pass in and out, so people keep appending instead.

Example

An order-placement handler that validates, prices, persists and notifies in one block.

async function placeOrder(req: OrderRequest, db: Db, mailer: Mailer): Promise<string> {
  // validate
  if (!req.items.length) throw new Error("empty order");
  for (const item of req.items) {
    if (item.qty <= 0) throw new Error(`bad qty for ${item.sku}`);
  }

  // price
  let subtotal = 0;
  for (const item of req.items) {
    const product = await db.products.get(item.sku);
    subtotal += product.priceCents * item.qty;
  }
  let discount = 0;
  if (req.coupon === "SPRING10") discount = Math.round(subtotal * 0.1);
  const tax = Math.round((subtotal - discount) * 0.08);
  const total = subtotal - discount + tax;

  // persist
  const id = await db.orders.insert({ ...req, subtotal, discount, tax, total });

  // notify
  await mailer.send(req.email, "Order received", `Order ${id}: $${(total / 100).toFixed(2)}`);
  return id;
}

After extracting each paragraph into a named function, the top-level function reads as a table of contents.

async function placeOrder(req: OrderRequest, db: Db, mailer: Mailer): Promise<string> {
  assertValid(req);
  const price = await priceOrder(req, db.products);
  const id = await db.orders.insert({ ...req, ...price });
  await sendConfirmation(mailer, req.email, id, price.total);
  return id;
}

function assertValid(req: OrderRequest): void {
  if (!req.items.length) throw new Error("empty order");
  const bad = req.items.find((i) => i.qty <= 0);
  if (bad) throw new Error(`bad qty for ${bad.sku}`);
}

async function priceOrder(req: OrderRequest, products: ProductRepo): Promise<Price> {
  const subtotal = await subtotalOf(req.items, products);
  const discount = couponDiscount(req.coupon, subtotal);
  const tax = Math.round((subtotal - discount) * TAX_RATE);
  return { subtotal, discount, tax, total: subtotal - discount + tax };
}

Treatment

• If the body has comment-headed paragraphs, use Extract Method on each one and name it after the comment.
• If temporaries block extraction, first apply Replace Temp with Query so the extracted code can recompute the value.
• If many parameters must flow into the extracted pieces, group them with Introduce Parameter Object or Preserve Whole Object.
• If locals are so entangled that no clean cut exists, use Replace Method with Method Object: the locals become fields and every step becomes a method.
• If conditionals dominate, apply Decompose Conditional to give each condition and branch a name.
• If a loop does one self-contained job, extract the loop into its own function.

Payoff

• Each function has one name that tells the truth, so callers and reviewers read intent, not mechanics.
• Small functions are testable in isolation and reusable elsewhere.
• Duplicate fragments become visible once pieces have names.
• Changes land in one small function, so diffs and merge conflicts shrink.

When to ignore

• The function is long but flat and linear, such as a configuration table, a route list or a generated mapping. Splitting it adds jumps without adding meaning.
• A hot loop where a profiler shows that call overhead matters and the compiler does not inline. This is rare; measure first.
• Test functions that set up one scenario end to end. Arrange-act-assert in one place can be clearer than helper soup.

Agent checklist

• Tests cover the function before you split it; add characterization tests if they don't.
• Each extracted function has a name specific enough that the comment above the old paragraph can be deleted.
• Extracted functions take the data they need as arguments and do not reach back into the caller's locals through closures or shared mutable state.
• The original function now reads as a short sequence of steps at one level of abstraction.
• Behavior is unchanged: the same tests pass with no edits to their assertions.