oosioo
큰 목표를 아흔한 개의 작은 칸으로 쪼갠 모습
SeriesNotes from the Office · Ep. 3

How to Repeat Small Wins (1) — Breaking Things Down Is the Oldest Trick in the Book

When a big goal feels overwhelming, breaking an unmanageable problem into small pieces turns out to be the oldest trick in the book — the same one computer science calls divide and conquer.

· SYSOP · 41 views
▶ This post as a video (Korean) · 4:40Watch on YouTube
Shorts (Korean) · 5
1조 번을 2천만 번으로
30억 글자를 읽어 낸 방법
라이트 형제가 날 수 있었던 이유
몇 주짜리 결승선을 긋는 법
91개로 쪼갠 첫 칸의 정체

This time I want to talk about a way to solve problems that makes it easier to succeed, or to produce good results, again and again.

Back when I was building a product from scratch at a startup, I broke that enormous goal into ninety-one small milestones. The first item wasn't anything impressive — something like "write code that reads a single file correctly." Modern programs are, for the most part, built by assembling components that each handle a small function, so I built mine the same way: adding one function at a time. In between, I'd check the results, and whenever something worked the way I'd designed it, that counted as a small win.

A big goal broken into ninety-one small squares

The oldest way to handle a big problem

This isn't some trick or know-how of my own. Computer science has a problem-solving strategy called "divide and conquer." You take an unmanageable big problem, split it into smaller subproblems of the same shape, solve each one, and merge the results back together. Merge sort works this way. So does binary search.

It looks simple, but it's more powerful than it seems. Say you're sorting a million pieces of data. A naive approach that compares everything against everything needs roughly a trillion operations (O(n²)), while merge sort — which splits the problem in half again and again (O(n log n)) — finishes in about twenty million. Same problem, but solving it by splitting cuts the number of operations to roughly one fifty-thousandth. The oldest real way to handle a big problem is simply to break it into small pieces.

The gap in operation count between the two approaches widens as the data grows

And this isn't just a computer science story. Life science has the same idea. The human genome consists of three billion base pairs, far too many to read all at once. So scientists cut the genome into small fragments at random, read each fragment separately, and then reassembled them by computer. By breaking an unmanageable scale down into small pieces and conquering it piece by piece, the human genome map was completed in 2003 — more than two years ahead of schedule.

The power of breaking things down even earned a name in psychology. In a 1984 paper, the psychologist Karl Weick laid out the concept of "small wins." A big problem is so overwhelming in scale that people can't even get a grip on it, he argued — but once it's turned into a chain of small, controllable, completed results, real change finally starts to happen. What we do in code, it turns out, he found in large-scale social problems.

Breaking things down isn't just for code

Even a problem as enormous as "flying through the air" was solved by breaking it into pieces. In 1901, when the Wright brothers' glider produced only a third of the lift they had predicted, they cut the monolithic problem of flight down into the problem of each individual wing. That fall, they tested somewhere between one and two hundred wing models in a small wind tunnel they built themselves, measuring exactly how much lift a given curvature and angle produced. Those small experiments piled up into the most precise wing data of their era, and the following year, after hundreds of glides with an improved glider, they finally achieved powered flight in 1903. Everyone who tried to conquer the sky all at once crashed — the brothers who broke the wing into pieces and measured it, flew.

This same idea has become institutionalized in how software gets built. Scrum, a methodology, cuts a massive project that would take months or years into short repeating units called "sprints." A single sprint usually runs no longer than a month, and at the end of it, there's always a piece of actually working output. Instead of running toward a finish line set far in the distance, you keep drawing a new finish line just a few weeks out. This approach, laid out by Jeff Sutherland and Ken Schwaber, has since become standard practice for development teams around the world.

Breaking things down applies not just to work but to teams, too. Amazon has a principle called the "two-pizza team." A team should be small enough that two pizzas can feed everyone — roughly no more than ten people. Splitting a large organization into small, autonomous units cuts down on time spent coordinating and speeds up decisions. People, work, problems — it seems like all of them only become manageable once you break them down small enough.

Cut things down to a size where the end is visible

The key is to cut things down to "a size where you can see the end with your own eyes." "Finish the product, launch it, and make money" doesn't intuitively have a visible end point, but "read this file format correctly" does. So I think the goal of that first milestone shouldn't be completion — it should be simply getting started. As the saying goes, starting is half the battle.

In an unfamiliar project or domain you're tackling for the first time, even the smallest task can feel like a lot. There was a time it took me a full week just to get the code that reads a single file properly sorted out. But even starting that way, as the finished components piled up, the earlier pieces became the raw material for the later ones, and things picked up speed. Small wins earned interest, and that interest kept compounding for the entire length of the project.

This approach had a side effect I didn't expect at first. I'll pick up that story in the next piece.

Reference: Merge sort — Wikipedia

Read this series from the start: Notes from the Office.