Differences between revisions 4 and 14 (spanning 10 versions)
Revision 4 as of 2025-07-24 13:27:57
Size: 11260
Editor: 정수
Comment:
Revision 14 as of 2025-12-30 10:00:26
Size: 11561
Editor: 정수
Comment:
Deletions are marked like this. Additions are marked like this.
Line 5: Line 5:
[[attachment:TinyExperiment.pdf]]

== The Story 1: Complex Regex (Programming) ==

한 주니어 개발자가 기존 코드에 있는 복잡한 정규표현식을 수정해야 하는 상황에 처했다.
{{{ /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/ }}}
그는 정규표현식 전체를 한꺼번에 이해하려고 끙끙대며 1시간을 보냈다. 하지만 시니어는 다르게 접근했다. 그는 정규표현식을 부분별로 나누어(Detachment), 아주 작은 테스트 함수에 하나씩 넣어보았다(Experiment-able). "먼저 소문자만 체크해보자. 그다음엔 숫자만." 15분 만에 그는 복잡한 패턴의 정규표현식을 완벽하게 파악하고 안전하게 수정했다.


== The Story 2: The Baker's Test (Ordinary Life) ==

민수와 하나는 친구의 결혼식 답례품으로 줄 '초콜릿 쿠키' 200개를 굽기로 했다.

'''민수의 방식 (The Big Batch):'''
민수는 레시피를 믿고 200개 분량의 반죽을 한꺼번에 만들었다. "레시피대로 했으니 당연히 맛있겠지?" 그는 거대한 오븐에 쿠키들을 가득 넣고 구웠다. 하지만 오븐에서 나온 쿠키들은 너무 딱딱했고 지나치게 달았다. 200개의 쿠키는 모두 쓰레기통으로 향했고, 민수는 재료비와 시간을 모두 날렸다.

'''하나의 방식 (The Tiny Experiment):'''
하나는 반죽을 한 숟가락만 떼어내어 작은 오븐에 딱 2개만 먼저 구워보았다.
 1. '''분리:''' 전체 양이 아닌 한 조각만 먼저 굽는다.
 2. '''관찰:''' 구워진 쿠키를 먹어보니 속이 덜 익고 설탕이 너무 많았다.
 3. '''조정:''' 설탕을 줄이고 오븐 온도를 10도 높였다.
하나는 세 번의 '작은 실험' 끝에 완벽한 맛과 식감을 찾아냈고, 그제야 200개의 쿠키를 자신 있게 구워냈다. 큰 실패의 위험을 작은 실험으로 미리 차단한 것이다.

Line 6: Line 30:
복잡한 소프트웨어 문제를 해결하거나 새로운 기능을 구현할 때, 또는 버그를 추적할 때. 불확실성이 높고 여러 가능성이 존재하는 상황에서 어떻게 접근해야 할지 막막할 때. 거대한 시스템 앞에서 큰 시스템을 바로 건드려야 하는 상황. 복잡한 곳에서부터 접근해야 할지 막막하거나, 무언가 건드릴 때마다 고장나기 쉽거나, 새로운 기능을 짜거나 기존 코드를 고쳐야 할 때.
Line 9: Line 34:
'''두 요리사의 이야기'''
Line 11: Line 35:
어느 레스토랑에 두 명의 요리사가 있었다. 둘 다 새로운 파스타 요리를 개발하라는 임무를 받았다. '''성급함이라는 거대한 장애물'''
Line 13: Line 37:
첫 번째 요리사 알렉스는 야심이 컸다. "완전히 새로운 파스타를 만들어보자!" 그는 면도 직접 만들고, 소스도 새로 개발하고, 치즈도 특별한 것을 사용하고, 허브도 독특한 조합으로 넣기로 했다. 3시간 동안 열심히 요리한 결과, 이상한 맛의 음식이 나왔다. 손님들은 고개를 저었다. 하지만 알렉스는 무엇이 잘못되었는지 알 수 없었다. 면 때문일까? 소스 때문일까? 치즈 때문일까? 처음부터 다시 시작해야 했다. 대부분의 프로그래머들은 큰 것을 '''전체를 한번에''' 다루려는 습관에 빠져 있다. 전통적인 접근은 세 단계를 따른다. 첫째로 '''기획 후 작업 후 완성'''이라는 순서를 가진다. 머릿속으로 전체를 상상하고, 한번에 구현하려 한다. 둘째로 '''실행 후 기도 후 결과'''를 기다린다. "아마 이렇게 하면 될 것이다"라고 추정하고 프로그램이 잘 되기를 기대한다. 셋째로 '''검증 후 디버그 후 재시도'''를 반복한다. 실제상황에서만 문제를 찾고 해결하기를 반복한다.
Line 15: Line 39:
두 번째 요리사 베타는 다르게 접근했다. 먼저 검증된 기본 파스타를 만들어 맛을 확인했다. 그 다음 소스만 조금 바꿔서 다시 맛을 보았다. "좋아, 이건 괜찮네." 그리고 치즈를 한 종류만 바꿔서 또 맛을 보았다. 각 단계마다 작은 접시에 조금씩 만들어서 확인했다. 만약 어떤 변경이 맛을 망쳤다면, 바로 이전 단계로 돌아갔다. 2시간 후, 손님들이 "이 파스타 정말 맛있네요!"라고 말하는 요리가 완성되었다. 하지만 이런 습관방식은 심각한 문제들을 만든다. '''피드백이 늦다'''. 전체에 대해 무엇이 잘못된 것인지 어떻게 작동하는지 잘 모르는데도 추진한다. '''실수 비용이 크다'''. 잘못되면 처음부터 다시 해야 한다. '''학습이 일어나지 않는다'''. 왜 작동하는지 작동하지 않는지 메커니즘을 놓친다. '''창의성이 막힌다'''. 큰 것이 앞에 서있으면 압도되어 어떤 길로 가야 할지 모른다.
Line 17: Line 41:
개발자들도 마찬가지다. 복잡한 기능을 한 번에 모두 구현하려다가 알렉스처럼 실패하거나, 베타처럼 작은 단계로 나누어 성공하거나. 차이는 접근 방법에 있다. 실제 문제는 큰 것들에 대해 우리 대부분이 가지고 있는 '''잘못된 접근 방식'''이다. 다시 정리하면 '''큰 전체 시스템에서 작은 작동 가능한 부분들을 분리해내는 능력'''이 부족하다는 점이다. 300줄짜리 함수를 보면서 "복잡한 것에서부터 어떤 길로 갈까?" 고민한다. 새로운 것이 많은데 "전체 시스템을 이해해서..." 라고 접근한다. 새로운 라이브러리를 배울 때 전체 문서를 다 읽으려 한다.
Line 20: Line 45:
'''작은 실험실을 만들어라'''
Line 22: Line 46:
베타 요리사의 지혜는 단순했다. 큰 변화를 작은 실험들로 나누고, 각 실험의 결과를 즉시 확인하고, 실패해도 쉽게 되돌아갈 수 있게 준비하는 것이었다. '''TinyExperiment의 3단계 사이클'''
Line 24: Line 48:
프로그래밍에서도 이와 같은 "작은 실험실"을 만들 수 있다. 새로운 기능을 구현할 때, 버그를 찾을 때, 성능을 개선할 때마다 이 방법을 사용하라. === 1단계: 작은 부분 분리하기 (Detachment) ===
Line 26: Line 50:
'''명확한 가설부터 시작하라''' 큰 전체 시스템에서 독립적이고 작은 부분만 떼어낸다. 이것이 TinyExperiment의 핵심 시작점이다. 전체 시스템이 아니라 '''극히 작고 특별한 특정 기능만''' 분리한다.
Line 28: Line 52:
베타가 "이 소스가 더 맛있을 것이다"라는 구체적인 가설을 세웠듯이, 개발에서도 명확한 가설을 세워야 한다. "이 함수가 느릴 것이다"가 아니라 "이 반복문에서 데이터베이스를 N번 호출해서 느릴 것이다"처럼 구체적으로 말이다. 분리를 위한 구체적인 전략들이 있다. '''함수 단위 분리'''에서는 300줄 함수에서 10줄짜리 핵심 기능만 먼저 빼서 만든다. '''데이터 단위 분리'''에서는 데이터베이스 시스템에서 작은 3-4개의 레코드를 만들어 준비한다. '''처리과정 단위 분리'''에서는 100단계 중에서 한 가지 결과를 내는 1단계만 먼저 한다. '''의존성 단위 분리'''에서는 전체 시스템에서 이 작은 기능이 외부로부터 독립적으로 작동하게 한다.
Line 30: Line 54:
'''안전한 실험 환경을 구축하라''' === 2단계: 실험 가능하게 만들기 (Make it Experiment-able) ===
Line 32: Line 56:
베타는 작은 접시에 조금씩 만들어서 실험했다. 만약 망쳐도 전체 요리가 아니라 작은 부분만 버리면 되었다. 개발에서는 git 브랜치가 이 역할을 한다. 새로운 시도를 할 때마다 브랜치를 만들고, 실패하면 쉽게 되돌아간다. 테스트 코드는 기존 기능이 망가지지 않았는지 확인하는 안전망 역할을 한다. 분리한 부분을 빠르게 실험하고 결과를 볼 수 있는 환경을 만들어라. 이 단계에서 '''밑바닥 창의성'''이 필요하다. 작은 기능이 혼자서도 돌아가도록 하는, 실제 상황에서 떨어진 최소한의 작은 환경을 만든다.
Line 34: Line 58:
'''즉시 피드백을 받아라''' 실험 환경을 만드는 몇 가지 예들이 있다. '''작은 테스트 스크립트 만들기'''는 단위테스트와는 다른 환경이다:
Line 36: Line 60:
베타는 각 단계마다 맛을 보았다. 3시간 후에 맛을 보는 게 아니라 5분마다 맛을 확인했다. 개발에서도 마찬가지다. 코드를 100줄 짠 후에 테스트하는 게 아니라, 5줄 짤 때마다 실행해보고 확인한다. 자동화된 테스트, 핫 리로드, 간단한 print문까지 모든 것이 즉시 피드백을 주는 도구가 된다. {{{
function testDataParsing() {
  console.log("날짜 파싱:", parseDate("2024-01-15") === "2024/01/15" ? "PASS" : "FAIL");
  console.log("빈 데이터:", handleEmpty("") === null ? "PASS" : "FAIL");
  console.log("숫자 변환:", toNumber("123") === 123 ? "PASS" : "FAIL");
}
}}}
Line 38: Line 68:
'''한 번에 하나씩만 바꿔라''' '''외부 API 호출 테스트'''는 다음과 같이 한다:
Line 40: Line 70:
베타의 가장 중요한 원칙이다. 소스를 바꿀 때는 다른 것은 그대로 두고 소스만 바꿨다. 그래서 결과가 나빠지면 소스 때문이라는 걸 확실히 알 수 있었다. 개발에서도 한 번에 하나의 변수만 바꿔야 한다. 함수를 수정할 때 동시에 데이터베이스 스키마까지 바꾸면, 문제가 생겼을 때 원인을 찾기 어렵다. {{{
// 실제 API 대신 가짜 데이터로 테스트
const mockData = { users: [{ id: 1, name: "test" }] };
console.log("활성화 필터링:", filterActiveUsers(mockData));
}}}
Line 42: Line 76:
== Examples == '''데이터베이스 작업 시뮬레이션'''은 이렇게 한다:
Line 44: Line 78:
'''신입 개발자 준호의 첫 번째 버그 수정''' {{{
// 전체 DB 대신 작은 테스트 데이터로
const testRows = [
  { id: 1, status: 'active', score: 85 },
  { id: 2, status: 'inactive', score: 92 }
];
console.log("상태 필터:", filterByStatus(testRows, 'active'));
}}}
Line 46: Line 87:
준호는 "로그인 후 대시보드가 가끔 안 보인다"는 버그 리포트를 받았다. 처음에는 겁이 났다. 로그인 시스템은 복잡하고, 대시보드도 여러 컴포넌트로 이루어져 있었다. === 3단계: 실험 휠 돌리기 (Flying the Experiment Wheel) ===
Line 48: Line 89:
시니어 개발자 민지가 조언했다. "베타 요리사처럼 해봐. 한 번에 모든 걸 고치려 하지 말고, 작은 실험부터 시작해." 작고 빠른 반복으로 계속 학습하라. 이제 '''찔러보고 → 관찰 → 배우기 → 조정 → 다시 찔러보기''' 사이클을 빠르게 돌린다.
Line 50: Line 91:
준호는 먼저 "이 버그를 재현할 수 있을까?"라는 가설을 세웠다. 자신의 로컬 환경에서 여러 번 로그인해봤지만 문제가 없었다. 그러다가 다른 브라우저로 시도해봤더니 Internet Explorer에서만 문제가 발생했다. 실험 휠의 각 단계는 명확한 목적을 가진다. '''Poke (찔러보기)'''에서는 작은 변경을 가한다. '''Observe (관찰)'''에서는 시스템의 반응을 본다. '''Learn (학습)'''에서는 왜 그런 결과가 나오는지 추론한다. '''Adjust (조정)'''에서는 다음 변경을 위해 접근을 수정한다.
Line 52: Line 93:
"IE에서만 발생한다"는 새로운 정보를 얻은 준호는 다음 가설을 세웠다. "JavaScript 에러가 있을 것이다." 브라우저 콘솔을 열어보니 과연 에러 메시지가 있었다. 특정 함수에서 undefined 에러가 발생하고 있었다.
Line 54: Line 94:
이제 "이 함수의 이 변수가 undefined이다"라는 구체적인 가설이 생겼다. console.log를 몇 줄 추가해서 변수의 값을 확인해봤더니, IE에서는 특정 API가 지원되지 않아서 undefined가 되고 있었다. == The Learning Laboratory ==
Line 56: Line 96:
문제를 정확히 파악한 준호는 간단한 브라우저 호환성 체크 코드를 추가했다. 테스트해보니 문제가 해결되었다. 전체 과정이 1시간밖에 걸리지 않았다. 만약 처음부터 "아마 세션 문제일 것이다"라고 추측하고 세션 관련 코드를 모두 뒤졌다면, 하루 종일 걸렸을 것이다. 왜 이런 작은 반복이 최고의 학습 환경인가? TinyExperiment의 진짜 목적은 '''학습'''이다. 작고 빠른 반복을 통해서 깊이를 이해하게 한다.
Line 58: Line 98:
'''경력 5년 차 수진의 성능 개선 프로젝트''' '''삼각측량 피드백'''이 일어난다. 변경과 그 결과 사이에 직접적인 연결을 볼 수 있다. 잘못된 변경이 어떤 결과를 가져오는지 바로 수정할 수 있다. "왜?"라는 질문에 대한 답이 바로 보인다.
Line 60: Line 100:
수진은 "페이지 로딩이 너무 느리다"는 요청을 받았다. 경험이 있는 그녀도 처음에는 막막했다. 성능 문제는 여러 원인이 복합적으로 작용할 수 있기 때문이다. '''안전한 실패'''가 가능하다. 작은 범위의 실패 비용만 있다 (몇 초만 피드백을 기다리면 됨). 망해도 큰 영향을 끼치지 않고 안전하게 시도한다. 실패에서 학습할 수 있다.
Line 62: Line 102:
하지만 수진은 베타 요리사의 방법을 알고 있었다. 먼저 현재 상황을 정확히 측정했다. 브라우저 개발자 도구를 열고 실제 로딩 시간을 확인했다. 8초가 걸리고 있었다. '''창조의 경험'''을 얻는다. 표준으로 정해진 것이 아니라 직접 발견하는 기쁨을 느낀다. "정답"이 아니라 "왜"를 안다. 창의적 해결방법을 발견할 수 있는 기회가 온다.
Line 64: Line 104:
첫 번째 가설: "이미지 파일이 너무 클 것이다." 네트워크 탭을 보니 5MB짜리 이미지들이 여러 개 있었다. 이미지를 압축하고 다시 측정했다. 5초로 줄어들었다. 좋은 시작이었다.
Line 66: Line 105:
두 번째 가설: "JavaScript 파일이 클 것이다." 번들 분석기로 확인해보니 사용하지 않는 라이브러리들이 포함되어 있었다. 불필요한 것들을 제거하고 측정했다. 3초로 더 줄어들었다. == Real Examples ==
Line 68: Line 107:
세 번째 가설: "데이터베이스 쿼리가 느릴 것이다." 서버 로그를 보니 N+1 쿼리 문제가 있었다. 쿼리를 최적화하고 측정했다. 1.5초까지 줄어들었다. === 예제 1: 복잡한 정규표현식 이해하기 ===
상단 'Story 1'의 사례와 같이 복잡한 패턴을 분리하여 개별적으로 검증함으로써 신속하고 정확하게 원리를 파악한 사례.
Line 70: Line 110:
각 단계마다 실제 측정치로 개선 효과를 확인했기 때문에, 어떤 최적화가 얼마나 효과적인지 정확히 알 수 있었다. 만약 한 번에 모든 것을 바꿨다면, 어떤 변경이 진짜 효과가 있었는지 알 수 없었을 것이다. === 예제 2: 성능 문제 찾기 ===
로딩 과정을 단계별로 `console.time()`으로 측정하여 8초 중 5초가 걸리는 특정 데이터 처리 지점을 발견하고 최적화한 사례.
Line 72: Line 113:
== The Wisdom of Small Steps == === 예제 3: 새로운 API 배우기 ===
100페이지 문서를 다 읽는 대신, `curl`이나 Postman으로 API 하나만 직접 호출해보며 요청과 응답 구조를 2시간 만에 파악한 사례.
Line 74: Line 116:
'''왜 작은 단계가 더 빠를까?'''
Line 76: Line 117:
역설적이게도, 작은 단계로 나누는 것이 결국 더 빠르다. 큰 변경을 한 번에 시도하다가 실패하면, 처음부터 다시 시작해야 한다. 하지만 작은 단계로 나누면 실패해도 바로 이전 단계로만 돌아가면 된다. == Common Anti-Patterns ==
Line 78: Line 119:
마치 산을 오를 때와 같다. 정상을 향해 일직선으로 가려다가 절벽을 만나면 다시 처음부터 시작해야 한다. 하지만 지그재그로 안전한 길을 찾아가면, 조금 더 돌아가더라도 결국 정상에 더 빨리 도착한다. 첫 번째 안티패턴은 '''전체를 이해하려는 욕구'''다. "전체를 다 이해하고 나서 시작해야 한다"는 생각 때문에 시작도 영원히 하지 못한다. 해결책은 시작해야 할 최소한만 분리해서 시작하는 것이다.
Line 80: Line 121:
'''실패는 정보다''' 두 번째 안티패턴은 '''완벽한 환경을 기다리기'''다. "실제로 제대로 된 테스트 인프라에서 해봐야지"라고 생각해서 환경 구축에서만 시간을 소모한다. console.log를 활용해서라도 바로 시작하는 것이 낫다.
Line 82: Line 123:
베타 요리사에게 실패한 실험은 낭비가 아니었다. "이 조합은 맛이 없다"는 중요한 정보였다. 개발에서도 마찬가지다. "이 방법은 작동하지 않는다"는 것을 빨리 알면, 다른 방법을 시도할 수 있다. 세 번째 안티패턴은 '''한번에 너무 많이 바꾸기'''다. "이것도 고치고 저것도 고치고..."라고 접근하면 어떤 변경이 효과를 가져왔는지 모르게 된다. 한 번에 하나씩만 바꾸는 것이 원칙이다.
Line 84: Line 125:
중요한 것은 실패의 비용을 낮추는 것이다. 작은 실험에서 실패하면 5분을 잃는다. 큰 변경에서 실패하면 5일을 잃는다.
Line 86: Line 126:
'''시스템과 친해지기''' == The Experiment Mindset ==
Line 88: Line 128:
작은 실험을 반복하다 보면, 시스템과 친해진다. 어떤 부분이 민감한지, 어떤 변경이 위험한지, 어떤 패턴이 잘 작동하는지 자연스럽게 알게 된다. 이런 직관은 큰 변경을 한 번에 시도해서는 얻을 수 없다. TinyExperiment를 체화하면 평소에 이런 질문들이 자연스럽게 떠오른다:
 * "이것 중에 가장 작고 성공할만한 것은 무엇인가?"
 * "어떤 부분만 먼저 시험해볼 수 있을까?"
 * "5분 안에 답을 확인할 수 있을까?"
 * "망쳐도 괜찮게 되돌릴 수 있을까?"
이런 질문들이 습관이 되면, 거대한 것이 앞에 와도 상황에서 멈추지 않는다. 항상 "작은 시작점이 어디일까"를 찾는 사고방식을 자연스럽게 갖게 된다.
Line 90: Line 135:
베타 요리사가 재료들의 특성을 하나씩 이해해가듯이, 개발자도 코드베이스의 특성을 작은 실험을 통해 이해해간다.
Line 92: Line 136:
== Common Pitfalls == == Tools and Techniques ==
Line 94: Line 138:
'''완벽한 실험 환경의 함정''' 실험 환경을 위해 활용하는 도구들이 여러 있다. '''REPL'''은 즉석 인터랙티브 환경이다. '''console.log/print'''는 가장 기본적이면서도 강력한 실험과 디버깅 도구이다. '''단위 테스트'''는 작은 부분을 격리해서 실험하는 방법이다. '''git stash/branch'''는 실험을 안전한 별도 공간에서 하기 위한 것이다. '''샌드박스'''는 코드 온라인 실험환경을 활용하는 것이다. '''프로파일러'''는 성능 실험을 위한 도구이다.
Line 96: Line 140:
어떤 개발자들은 실험을 시작하기 전에 완벽한 환경을 만들려고 한다. 모든 테스트를 작성하고, 모든 도구를 설정하고, 모든 문서를 읽고 나서야 실험을 시작한다. 하지만 이는 본말이 전도된 것이다.

베타 요리사는 작은 접시와 기본 재료만 있으면 바로 실험을 시작했다. 완벽한 주방 설비를 기다리지 않았다. 개발에서도 마찬가지다. 간단한 print문이나 로그만 있어도 충분히 실험할 수 있다.

'''추측의 늪'''

"아마 이것 때문일 것이다"라는 추측에 빠지는 것도 위험하다. 추측은 가설의 출발점이 될 수 있지만, 검증 없이는 의미가 없다. 베타 요리사도 "이 소스가 더 맛있을 것 같다"고 생각했지만, 반드시 맛을 보고 확인했다.

== Tools for Your Laboratory ==

실험실에는 도구가 필요하다. 베타 요리사에게 작은 접시와 맛보기용 스푼이 있었듯이, 개발자에게도 실험을 돕는 도구들이 있다.

코드를 즉시 실행해볼 수 있는 REPL, 변경사항을 바로 확인할 수 있는 핫 리로드, 중간 결과를 확인할 수 있는 디버거, 기존 기능을 보호하는 테스트 코드. 이 모든 것들이 당신의 실험실을 구성하는 도구들이다.

중요한 것은 도구 자체가 아니라 도구를 사용하는 마음가짐이다. "빨리 확인하고, 빨리 배우고, 빨리 조정한다"는 베타 요리사의 철학 말이다.
Line 113: Line 142:
TinyExperiment를 습관화하면 복잡한 문제 앞에서도 당황하지 않게 된다. 큰 산도 작은 돌들로 이루어져 있고, 복잡한 시스템도 작은 부분들로 나누어 이해할 수 있다는 것을 안다. 실패를 두려워하지 않게 되고, 오히려 실패에서 배우는 것에 익숙해진다.
Line 115: Line 143:
가장 중요한 것은, 시스템과 대화하는 법을 배우게 된다는 것이다. 코드에게 질문하고, 답을 듣고, 다시 질문하는 순환이 자연스러워진다. 이것이 진정한 프로그래밍의 시작이다. TinyExperiment를 체화하면 창의성이 막히지 않고 학습 속도가 빨라지며 실패에 대한 두려움이 사라집니다. 가장 중요한 변화는 '''"탐구하는 프로그래머"'''가 되는 것입니다.
Line 117: Line 145:
== Related Patterns ==
* '''Enables:''' [[BabyStep]], [[UseAbduction]], [[HereAndNowDebugging]]
* '''Used by:''' [[TddIsDesignActivity]], [[PiecemealGrowthCenterFirst]]
* '''Complements:''' [[ShortFeedbackCycle]], [[MicroCommit]]
Line 122: Line 146:
== See Also ==
* [[가추법]] - 관찰에서 가설을 도출하는 사고 방식
* Kent Beck의 "Test Driven Development" - 작은 테스트로 설계하기
* Gary Klein의 "Sources of Power" - 전문가의 직관과 가설 검증
== Connection to Other Patterns ==

 * '''[[BabySteps]]''', '''[[GreenRefuge]]''' - 작은 단계와 안전한 피드백을 보장하는 기반 패턴입니다. ''기반''
 * '''[[DesignThroughTest]]''', '''[[DetectiveWork]]''' - 실험적 방법론을 설계와 디버깅에 응용합니다. ''활용''
 * '''[[TightLoop]]''', '''[[AtomicCommit]]''' - 실험의 주기를 짧게 유지하고 결과를 안전하게 기록합니다. ''연계''
 * '''[[CognitiveMicroscope]]''' - 실험의 결과를 관찰할 때 인지 과정을 확대해서 보면 더 많이 배웁니다. ''관찰''
 * '''[[WorkingFirst]]''' - 작동하는 코드를 만들기 위한 가장 강력한 도구가 TinyExperiment입니다. ''실행''
 * '''[[ArtisanMind]]''' - 해커 마인드의 핵심은 끊임없는 작은 실험입니다. ''정신''
Line 128: Line 156:
CategoryPattern CategoryPatternLanguage CategoryProgramming CategoryLearning CategoryAgile

TinyExperiment

TinyExperiment.pdf

The Story 1: Complex Regex (Programming)

한 주니어 개발자가 기존 코드에 있는 복잡한 정규표현식을 수정해야 하는 상황에 처했다.  /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/  그는 정규표현식 전체를 한꺼번에 이해하려고 끙끙대며 1시간을 보냈다. 하지만 시니어는 다르게 접근했다. 그는 정규표현식을 부분별로 나누어(Detachment), 아주 작은 테스트 함수에 하나씩 넣어보았다(Experiment-able). "먼저 소문자만 체크해보자. 그다음엔 숫자만." 15분 만에 그는 복잡한 패턴의 정규표현식을 완벽하게 파악하고 안전하게 수정했다.

The Story 2: The Baker's Test (Ordinary Life)

민수와 하나는 친구의 결혼식 답례품으로 줄 '초콜릿 쿠키' 200개를 굽기로 했다.

민수의 방식 (The Big Batch): 민수는 레시피를 믿고 200개 분량의 반죽을 한꺼번에 만들었다. "레시피대로 했으니 당연히 맛있겠지?" 그는 거대한 오븐에 쿠키들을 가득 넣고 구웠다. 하지만 오븐에서 나온 쿠키들은 너무 딱딱했고 지나치게 달았다. 200개의 쿠키는 모두 쓰레기통으로 향했고, 민수는 재료비와 시간을 모두 날렸다.

하나의 방식 (The Tiny Experiment): 하나는 반죽을 한 숟가락만 떼어내어 작은 오븐에 딱 2개만 먼저 구워보았다.

  1. 분리: 전체 양이 아닌 한 조각만 먼저 굽는다.

  2. 관찰: 구워진 쿠키를 먹어보니 속이 덜 익고 설탕이 너무 많았다.

  3. 조정: 설탕을 줄이고 오븐 온도를 10도 높였다.

하나는 세 번의 '작은 실험' 끝에 완벽한 맛과 식감을 찾아냈고, 그제야 200개의 쿠키를 자신 있게 구워냈다. 큰 실패의 위험을 작은 실험으로 미리 차단한 것이다.

Context

거대한 시스템 앞에서 큰 시스템을 바로 건드려야 하는 상황. 복잡한 곳에서부터 접근해야 할지 막막하거나, 무언가 건드릴 때마다 고장나기 쉽거나, 새로운 기능을 짜거나 기존 코드를 고쳐야 할 때.

Problem

성급함이라는 거대한 장애물

대부분의 프로그래머들은 큰 것을 전체를 한번에 다루려는 습관에 빠져 있다. 전통적인 접근은 세 단계를 따른다. 첫째로 기획 후 작업 후 완성이라는 순서를 가진다. 머릿속으로 전체를 상상하고, 한번에 구현하려 한다. 둘째로 실행 후 기도 후 결과를 기다린다. "아마 이렇게 하면 될 것이다"라고 추정하고 프로그램이 잘 되기를 기대한다. 셋째로 검증 후 디버그 후 재시도를 반복한다. 실제상황에서만 문제를 찾고 해결하기를 반복한다.

하지만 이런 습관방식은 심각한 문제들을 만든다. 피드백이 늦다. 전체에 대해 무엇이 잘못된 것인지 어떻게 작동하는지 잘 모르는데도 추진한다. 실수 비용이 크다. 잘못되면 처음부터 다시 해야 한다. 학습이 일어나지 않는다. 왜 작동하는지 작동하지 않는지 메커니즘을 놓친다. 창의성이 막힌다. 큰 것이 앞에 서있으면 압도되어 어떤 길로 가야 할지 모른다.

실제 문제는 큰 것들에 대해 우리 대부분이 가지고 있는 잘못된 접근 방식이다. 다시 정리하면 큰 전체 시스템에서 작은 작동 가능한 부분들을 분리해내는 능력이 부족하다는 점이다. 300줄짜리 함수를 보면서 "복잡한 것에서부터 어떤 길로 갈까?" 고민한다. 새로운 것이 많은데 "전체 시스템을 이해해서..." 라고 접근한다. 새로운 라이브러리를 배울 때 전체 문서를 다 읽으려 한다.

Solution

TinyExperiment의 3단계 사이클

1단계: 작은 부분 분리하기 (Detachment)

큰 전체 시스템에서 독립적이고 작은 부분만 떼어낸다. 이것이 TinyExperiment의 핵심 시작점이다. 전체 시스템이 아니라 극히 작고 특별한 특정 기능만 분리한다.

분리를 위한 구체적인 전략들이 있다. 함수 단위 분리에서는 300줄 함수에서 10줄짜리 핵심 기능만 먼저 빼서 만든다. 데이터 단위 분리에서는 데이터베이스 시스템에서 작은 3-4개의 레코드를 만들어 준비한다. 처리과정 단위 분리에서는 100단계 중에서 한 가지 결과를 내는 1단계만 먼저 한다. 의존성 단위 분리에서는 전체 시스템에서 이 작은 기능이 외부로부터 독립적으로 작동하게 한다.

2단계: 실험 가능하게 만들기 (Make it Experiment-able)

분리한 부분을 빠르게 실험하고 결과를 볼 수 있는 환경을 만들어라. 이 단계에서 밑바닥 창의성이 필요하다. 작은 기능이 혼자서도 돌아가도록 하는, 실제 상황에서 떨어진 최소한의 작은 환경을 만든다.

실험 환경을 만드는 몇 가지 예들이 있다. 작은 테스트 스크립트 만들기는 단위테스트와는 다른 환경이다:

function testDataParsing() {
  console.log("날짜 파싱:", parseDate("2024-01-15") === "2024/01/15" ? "PASS" : "FAIL");
  console.log("빈 데이터:", handleEmpty("") === null ? "PASS" : "FAIL");  
  console.log("숫자 변환:", toNumber("123") === 123 ? "PASS" : "FAIL");
}

외부 API 호출 테스트는 다음과 같이 한다:

// 실제 API 대신 가짜 데이터로 테스트
const mockData = { users: [{ id: 1, name: "test" }] };
console.log("활성화 필터링:", filterActiveUsers(mockData));

데이터베이스 작업 시뮬레이션은 이렇게 한다:

// 전체 DB 대신 작은 테스트 데이터로
const testRows = [
  { id: 1, status: 'active', score: 85 },
  { id: 2, status: 'inactive', score: 92 }
];
console.log("상태 필터:", filterByStatus(testRows, 'active'));

3단계: 실험 휠 돌리기 (Flying the Experiment Wheel)

작고 빠른 반복으로 계속 학습하라. 이제 찔러보고 → 관찰 → 배우기 → 조정 → 다시 찔러보기 사이클을 빠르게 돌린다.

실험 휠의 각 단계는 명확한 목적을 가진다. Poke (찔러보기)에서는 작은 변경을 가한다. Observe (관찰)에서는 시스템의 반응을 본다. Learn (학습)에서는 왜 그런 결과가 나오는지 추론한다. Adjust (조정)에서는 다음 변경을 위해 접근을 수정한다.

The Learning Laboratory

왜 이런 작은 반복이 최고의 학습 환경인가? TinyExperiment의 진짜 목적은 학습이다. 작고 빠른 반복을 통해서 깊이를 이해하게 한다.

삼각측량 피드백이 일어난다. 변경과 그 결과 사이에 직접적인 연결을 볼 수 있다. 잘못된 변경이 어떤 결과를 가져오는지 바로 수정할 수 있다. "왜?"라는 질문에 대한 답이 바로 보인다.

안전한 실패가 가능하다. 작은 범위의 실패 비용만 있다 (몇 초만 피드백을 기다리면 됨). 망해도 큰 영향을 끼치지 않고 안전하게 시도한다. 실패에서 학습할 수 있다.

창조의 경험을 얻는다. 표준으로 정해진 것이 아니라 직접 발견하는 기쁨을 느낀다. "정답"이 아니라 "왜"를 안다. 창의적 해결방법을 발견할 수 있는 기회가 온다.

Real Examples

예제 1: 복잡한 정규표현식 이해하기

상단 'Story 1'의 사례와 같이 복잡한 패턴을 분리하여 개별적으로 검증함으로써 신속하고 정확하게 원리를 파악한 사례.

예제 2: 성능 문제 찾기

로딩 과정을 단계별로 console.time()으로 측정하여 8초 중 5초가 걸리는 특정 데이터 처리 지점을 발견하고 최적화한 사례.

예제 3: 새로운 API 배우기

100페이지 문서를 다 읽는 대신, curl이나 Postman으로 API 하나만 직접 호출해보며 요청과 응답 구조를 2시간 만에 파악한 사례.

Common Anti-Patterns

첫 번째 안티패턴은 전체를 이해하려는 욕구다. "전체를 다 이해하고 나서 시작해야 한다"는 생각 때문에 시작도 영원히 하지 못한다. 해결책은 시작해야 할 최소한만 분리해서 시작하는 것이다.

두 번째 안티패턴은 완벽한 환경을 기다리기다. "실제로 제대로 된 테스트 인프라에서 해봐야지"라고 생각해서 환경 구축에서만 시간을 소모한다. console.log를 활용해서라도 바로 시작하는 것이 낫다.

세 번째 안티패턴은 한번에 너무 많이 바꾸기다. "이것도 고치고 저것도 고치고..."라고 접근하면 어떤 변경이 효과를 가져왔는지 모르게 된다. 한 번에 하나씩만 바꾸는 것이 원칙이다.

The Experiment Mindset

TinyExperiment를 체화하면 평소에 이런 질문들이 자연스럽게 떠오른다:

  • "이것 중에 가장 작고 성공할만한 것은 무엇인가?"
  • "어떤 부분만 먼저 시험해볼 수 있을까?"
  • "5분 안에 답을 확인할 수 있을까?"
  • "망쳐도 괜찮게 되돌릴 수 있을까?"

이런 질문들이 습관이 되면, 거대한 것이 앞에 와도 상황에서 멈추지 않는다. 항상 "작은 시작점이 어디일까"를 찾는 사고방식을 자연스럽게 갖게 된다.

Tools and Techniques

실험 환경을 위해 활용하는 도구들이 여러 있다. REPL은 즉석 인터랙티브 환경이다. console.log/print는 가장 기본적이면서도 강력한 실험과 디버깅 도구이다. 단위 테스트는 작은 부분을 격리해서 실험하는 방법이다. git stash/branch는 실험을 안전한 별도 공간에서 하기 위한 것이다. 샌드박스는 코드 온라인 실험환경을 활용하는 것이다. 프로파일러는 성능 실험을 위한 도구이다.

Resulting Context

TinyExperiment를 체화하면 창의성이 막히지 않고 학습 속도가 빨라지며 실패에 대한 두려움이 사라집니다. 가장 중요한 변화는 "탐구하는 프로그래머"가 되는 것입니다.

Connection to Other Patterns

  • BabySteps, GreenRefuge - 작은 단계와 안전한 피드백을 보장하는 기반 패턴입니다. 기반

  • DesignThroughTest, DetectiveWork - 실험적 방법론을 설계와 디버깅에 응용합니다. 활용

  • TightLoop, AtomicCommit - 실험의 주기를 짧게 유지하고 결과를 안전하게 기록합니다. 연계

  • CognitiveMicroscope - 실험의 결과를 관찰할 때 인지 과정을 확대해서 보면 더 많이 배웁니다. 관찰

  • WorkingFirst - 작동하는 코드를 만들기 위한 가장 강력한 도구가 TinyExperiment입니다. 실행

  • ArtisanMind - 해커 마인드의 핵심은 끊임없는 작은 실험입니다. 정신


CategoryPatternLanguage CategoryProgramming CategoryLearning CategoryAgile

TinyExperiment (last edited 2025-12-30 10:00:26 by 정수)