Differences between revisions 11 and 52 (spanning 41 versions)
⇤ ← Revision 11 as of 2025-12-29 08:42:22 →
Size: 13188
Editor: 정수
Comment:
← Revision 52 as of 2025-12-31 03:35:40 → ⇥
Size: 21041
Editor: 정수
Comment:
Deletions are marked like this. Additions are marked like this.
Line 1: Line 1:
Retrieved content for AiGarden/ToJuniorsPatternLanguage
Line 4: Line 3:
= AiGarden/ToJuniorsPatternLanguage = = 생각하는 개발자의 길 =
Line 6: Line 5:
주니어 개발자들을 위한 프로그래밍 피드백을 Christopher Alexander의 패턴 언어로 변환하는 프로젝트. ''주니어 개발자들을 위한 패턴 언어 - 38개의 실천적 중심이 엮어내는 성장의 서사''

소프트웨어는 미리 정해진 설계도대로 조립되는 결과물이 아니라, 개발자의 인식과 코드의 언어가 조화를 이루며 씨앗으로부터 자라나는 것입니다. 이 패턴 언어는 그 생명력을 유지하며 시스템을 키워가는 과정을 담고 있습니다.
Line 10: Line 11:
== Project Vision == == 성장의 서사 (The Narrative) ==
Line 12: Line 13:
[[기술문서모음/ToJuniors]] 문서의 패턴들을 Alexander의 패턴 언어 형식으로 변환하여 구조적이고 교육적인 자료로 발전시키는 것이 목표입니다. === 제1장: 명료한 인식 (Clear Perception) ===
Line 14: Line 15:
=== Core Principles ===
 * '''Structure-Preserving Baby Steps''' - 기존 구조를 보존하며 점진적 발전
 * '''Story-First Approach''' - 스토리로 시작해서 패턴으로 추상화
 * '''Educational Focus''' - 학습자 중심의 명확한 설명
 * '''Pattern Language Structure''' - Alexander 방식의 체계적 연결		 프로그래밍은 단순한 지식의 적용을 넘어 숙련된 감각이 필요한 '''[[ArtisanMind|기예]]'''입니다. 개발자는 자신의 고정관념에 속지 않고 '''[[PresentMoment|지금 이 순간]]''' 시스템에서 실제로 일어나는 사실을 있는 그대로 보아야 합니다.
Line 20: Line 17:
== Pattern Inventory == 복잡한 현상에 매몰되지 않으려면 '''[[SingleFocus|한 번에 한 가지]]''' 목표에만 집중해야 하며, 자신의 사고 과정을 '''[[CognitiveMicroscope|인지 현미경]]'''으로 들여다보듯 세밀하게 관찰할 때 비로소 전문성이 쌓이기 시작합니다.
Line 22: Line 19:
=== Foundation Patterns ===
'''Core Programming Principles'''
 * '''DataAsFoundation''' - 비즈니스 로직에서 데이터 구성을 분리하여 단순함을 달성하고, 데이터 구조가 복잡해지면 도메인 특화 언어를 만들어라. 모든 깨끗한 코드의 기반은 잘 정리된 데이터에서 시작된다. ''연관: LanguageBuilding, ComplexityTaming''		 === 제2장: 언어와 이론 (Language and Theory) ===
Line 26: Line 21:
 * '''TwoWorlds''' - 문제 공간(무엇을 해결할 것인가)과 해결 공간(어떻게 구현할 것인가)을 명확히 구분하라. 많은 프로그래밍 오류는 사고 과정에서 이 두 관심사를 너무 일찍 섞는 데서 비롯된다. ''연관: StrongCenter, PatternHunting'' 현실의 문제를 코드로 옮기기 위해서는 먼저 '''[[TwoWorlds|문제 공간과 해결 공간]]'''을 명확히 구분해야 합니다. 기술적인 도구를 고르기에 앞서 잘 정리된 '''[[DataAsFoundation|데이터를 기반]]'''으로 삼아 구조의 중심을 잡습니다.
Line 28: Line 23:
 * '''WorkingFirst''' - 우아하거나 효율적으로 만들기 전에 먼저 작동하게 만들어라. 작동하는 해결책은 문제의 진정한 본질을 드러내고 더 나은 설계 결정을 안내한다. ''연관: BabySteps, OrganicGrowth'' 우리는 추상적인 개념을 다루기 위해 '''[[MetaphorThinking|은유를 통해 사고]]'''하고, 적절한 이름을 붙이는 '''[[NamesAsDesign|이름 짓기를 설계 활동]]'''으로 수행하며 우리만의 '''[[LanguageBuilding|도메인 언어를 구축]]'''합니다. 이 언어는 시스템의 변화에 맞춰 '''[[LivingVocabulary|살아있는 어휘]]'''로 진화해야 하며, 이렇게 언어가 바로 설 때 비로소 거대한 '''[[ComplexityTaming|복잡성을 길들일]]''' 수 있습니다.
Line 30: Line 25:
 * '''ArtisanMind''' - 프로그래밍을 순수한 체계적 방법론이 아닌 직관, 경험, 감각이 필요한 기예로 접근하라. 최고의 프로그래머는 기술적 지식과 예술적 감성을 결합한다. ''연관: MasterApprentice, NamesAsDesign'' === 제3장: 실행의 리듬 (The Rhythm of Execution) ===
Line 32: Line 27:
 * '''The95PercentRule''' - 모든 과정의 마지막 5%를 자동화하려는 유혹에 저항하라. 그 남은 복잡성은 종종 절약할 수 있는 수작업 노력보다 더 많은 비용이 든다. ''연관: WorkingFirst, ShortLeash'' 소프트웨어에 생명력을 불어넣는 것은 멈추지 않는 맥박, 즉 리듬입니다. 우리는 완벽한 설계에 매몰되기보다 '''[[WorkingFirst|일단 작동하는 것]]'''을 먼저 만들어 진실을 마주합니다. 불확실한 지점에서는 '''[[TinyExperiment|작은 실험]]'''을 수행하며 1초 이내에 결과를 확인하는 '''[[TightLoop|촘촘한 피드백 루프]]'''를 가동합니다.
Line 34: Line 29:
=== TDD & Evolutionary Design Patterns ===
 * '''[[TinyExperiment]]''' ✓ - 문제에 대해 의미 있는 것을 가르쳐줄 수 있는 가장 작은 실험부터 시작하라. 각 실험은 실패 비용이 거의 없을 정도로 작아야 한다. ''연관: BabySteps, GreenRefuge''		 특히 브라우저 인스펙터나 REPL 같은 '''[[DesigningInTheRun|실행 중인 현장에서의 설계]]'''를 통해 소스 코드를 고치기 전 작동하는 진실을 먼저 결정합니다. 안전한 전진을 위해 '''[[BabySteps|작은 보폭]]'''을 유지하며, 각 단계의 완료를 '''[[AtomicCommit|원자적인 커밋]]'''으로 기록합니다. 가설을 세울 때는 '''[[ShortLeash|추측의 끈을 짧게 쥐고]]''' 수시로 검증하며, 실패했을 때는 즉시 안전한 '''[[GreenRefuge|초록색 피난처]]'''로 돌아옵니다. 이때 마지막 5%의 자동화에 집착하지 않는 '''[[The95PercentRule|95%의 규칙]]'''은 리듬을 지속하기 위한 장인의 실무적 결단이 됩니다.
Line 37: Line 31:
 * '''BabySteps''' - 시스템 무결성을 유지하면서 목표를 향해 나아가는 가장 작은 단계를 취하라. 큰 단계는 복잡성을 숨기고 디버깅을 기하급수적으로 어렵게 만든다. ''연관: TinyExperiment, AtomicCommit'' === 제4장: 유기적 성장 (Organic Growth) ===
Line 39: Line 33:
 * '''GreenRefuge''' - 테스트가 실패하면 앞으로 고치려 하지 말고 즉시 마지막으로 알려진 작동 상태로 돌아가라. 초록 막대는 복잡성의 폭풍 속 안전한 피난처다. ''연관: SafetyNet, PresentMoment'' 리듬을 탄 시스템은 이제 하나의 생명체처럼 자라납니다. 시스템은 무질서하게 커지는 것이 아니라, 가장 본질적인 가치를 담은 '''[[StrongCenter|강한 중심]]'''에서 시작해 바깥으로 펼쳐 나갑니다. 완벽한 조각을 맞추기보다 '''[[RoughWholeFirst|엉성한 전체]]'''에서 시작하여 점진적으로 세분화(Differentiation)해 나가는 것이 성장의 핵심입니다.
Line 41: Line 35:
 * '''DesignThroughTest''' - 테스트 주도 개발을 단순한 검증 도구가 아닌 설계 활동으로 사용하라. 테스트를 먼저 작성하는 행위는 더 나은 API 설계와 깔끔한 인터페이스를 드러낸다. ''연관: CleanIsolation, TightLoop'' 또한 '''[[DesignThroughTest|테스트를 통한 설계]]'''는 이 성장의 방향을 안내하는 나침반이 됩니다. 시스템을 키워가는 과정에서 불필요한 레이어를 걷어내고 문제에 직선으로 다가가는 '''[[DirectPath|직선 경로]]'''를 유지하십시오. 성장의 용기를 주는 것은 언제나 작동함을 보장하는 '''[[SafetyNet|안전망]]'''이며, 의존성을 끊어낸 '''[[CleanIsolation|깨끗한 격리]]'''를 통해 각 부분을 유연하게 유지해야 합니다. 이것이 바로 건강한 '''[[OrganicGrowth|유기적 성장]]'''의 모습입니다.
Line 43: Line 37:
 * '''TightLoop''' - 변경을 만들고 그 효과를 보는 사이의 시간을 최소화하라. 긴 피드백 주기는 오류가 복합되고 근본 원인을 찾기 어렵게 만든다. ''연관: AtomicCommit, PresentMoment'' === 제5장: 공동체의 지혜 (Collective Wisdom) ===
Line 45: Line 39:
 * '''AtomicCommit''' - 각 커밋이 독립적으로 존재할 수 있는 하나의 완전하고 일관된 변경을 나타내도록 하라. 원자적 커밋은 변경 사항을 이해하고, 검토하고, 되돌리기 쉽게 만든다. ''연관: BabySteps, TightLoop'' 개인의 기예는 공동체 안에서 비로소 완성됩니다. 서로의 실력을 존중하는 '''[[TechnicalCommunity|기술 공동체]]''' 안에서, 두 명의 지혜를 하나로 모으는 '''[[SharedMind|공유된 정신]]'''을 실천합니다. 우리는 거주자인 사용자와 '''[[ParticipatoryDesign|함께 짓고]]''' 소통하며 실제 삶이 녹아든 공간을 만듭니다.
Line 47: Line 41:
 * '''CleanIsolation''' - 테스트와 모듈을 숨겨진 의존성 없이 독립적으로 실행할 수 있도록 설계하라. 격리는 시스템을 이해하고, 테스트하고, 수정하기 쉽게 만든다. ''연관: DesignThroughTest, DirectPath'' 우리는 대화의 '''[[BuildingBridge|다리를 놓고]]''', 강물처럼 거침없이 '''[[FlowingFeedback|흐르는 피드백]]'''을 통해 함께 성장합니다. 앞서간 이로부터 '''[[MasterApprentice|암묵지를 전수받으며]]''' 자신만의 '''[[CraftPath|성장 경로]]'''를 걷습니다.
Line 49: Line 43:
 * '''DetectiveWork''' - 관찰된 행동의 원인에 대한 가설을 형성하기 위해 추론적 사고를 사용하라. 좋은 프로그래머는 결론을 내리기 전에 증거를 수집하는 탐정이다. ''연관: RootHunting, PresentMoment'' 이 여정 속에서 우리는 함께 '''[[PatternHunting|패턴을 사냥]]'''하고, '''[[DetectiveWork|탐정의 수사]]'''처럼 버그를 추적하며, '''[[RootHunting|근본 원인을 찾아]]''' 제거합니다. 이때 AI라는 강력한 파트너와 의도와 증거를 나누는 '''[[AugmentedInvestigation|증강된 수사]]'''는 문제 해결의 속도를 획기적으로 높여줍니다. 이러한 반복은 결국 데이터에 기반한 '''[[InstinctiveChoice|직관적인 선택]]'''을 가능하게 합니다. 우리는 매일의 작은 호기심을 '''[[TinyResearch|5분 연구]]'''로 채우고, 수행하는 순간을 '''[[ActiveReflection|실시간으로 성찰]]'''하며, 하루의 끝에서 자신의 사고 과정을 '''[[ThinkingMirror|거울에 비추어]]''' 봅니다.
Line 51: Line 45:
 * '''OrganicGrowth''' - 모든 부분을 동시에 구축하기보다는 작동하는 핵심에서 시스템을 점진적으로 성장시켜라. 생물학적 성장처럼, 소프트웨어는 각 단계에서 전체성을 유지할 때 가장 건강하게 성장한다. ''연관: StrongCenter, WorkingFirst'' ----
Line 53: Line 47:
 * '''StrongCenter''' - 가장 필수적인 핵심 기능부터 구축을 시작하고 바깥쪽으로 성장시켜라. 강한 중심은 시스템이 확장될 때 안정성과 일관성을 제공한다. ''연관: OrganicGrowth, TwoWorlds'' == 패턴 목록 (Pattern Inventory) ==
Line 55: Line 49:
=== Testing & Debugging Patterns ===
 * '''DirectPath''' - 입력에서 출력으로의 흐름을 가리는 불필요한 레이어와 간접성을 제거하라. 문제와 해결책 사이의 가장 짧은 경로가 보통 가장 명확하다. ''연관: CleanIsolation, SingleFocus''		 === 제1장: 명료한 인식 관련 ===
 * '''[[ArtisanMind]] (장인의 마음)''' - 프로그래밍을 순수한 과학보다 감각과 경험이 필요한 기예로 접근합니다. 이론적 완벽함에 매몰되어 실행을 미루기보다, 불완전한 지식으로도 작동하는 실체를 만들어내는 해커 마인드를 함양합니다.
   * ''연관: [[MasterApprentice]], [[InstinctiveChoice]], [[PresentMoment]], [[TinyResearch]]''
 * '''[[PresentMoment]] (지금 이 순간)''' - "이래야 한다"는 머릿속 모델보다 지금 모니터에 찍힌 로그와 에러라는 실제 현실에 집중합니다. 지도가 영토와 다를 때, 항상 영토(실행 결과)를 유일한 진실로 받아들이는 겸손함을 유지합니다.
   * ''연관: [[DetectiveWork]], [[RootHunting]], [[ActiveReflection]], [[CognitiveMicroscope]], [[DesigningInTheRun]]''
 * '''[[SingleFocus]] (오직 하나에 집중)''' - 한 번에 정확히 한 가지 목표에만 렌즈를 맞춥니다. 버그 수정과 리팩토링을 섞지 않음으로써 인지 부하를 낮추고 작업의 완결성을 높입니다.
   * ''연관: [[AtomicCommit]], [[BabySteps]]''
 * '''[[CognitiveMicroscope]] (인지 현미경)''' - 자신의 인지 과정을 네 단계(Intake, Meaning, Significance, Response)로 분해하여 세밀하게 관찰합니다. 관찰 중인 내용을 소리 내어 말하는 '''Think Aloud'''는 인지 과정을 명시화하는 훌륭한 방법입니다.
   * ''연관: [[ThinkingMirror]], [[ActiveReflection]], [[MasterApprentice]]''
Line 58: Line 59:
 * '''SingleFocus''' - 한 번에 정확히 한 가지 일만 하고, 다음으로 넘어가기 전에 완전히 완료하라. 디버깅에서 멀티태스킹은 혼란과 놓친 연결로 이어진다. ''연관: AtomicCommit, PresentMoment'' === 제2장: 언어와 이론 관련 ===
 * '''[[TwoWorlds]] (문제와 해결의 두 세계)''' - 무엇을 해결할 것인가(문제 공간)와 어떻게 구현할 것인가(해결 공간)를 엄격히 분리합니다. 많은 오류는 이 두 세계를 너무 일찍 섞는 데서 비롯됨을 인지하고, 문제 공간에 더 오래 머무르며 본질을 탐색합니다.
   * ''연관: [[DataAsFoundation]], [[LanguageBuilding]], [[StrongCenter]]''
 * '''[[DataAsFoundation]] (토대로서의 데이터)''' - 로직 이전에 단단한 데이터 구조를 먼저 설계합니다. 로직이 복잡해 보인다면 그것은 사실 데이터 구조가 복잡한 것이며, 올바른 데이터 표현은 로직을 저절로 단순하게 만듭니다.
   * ''연관: [[LanguageBuilding]], [[ComplexityTaming]], [[TwoWorlds]], [[NamesAsDesign]]''
 * '''[[LanguageBuilding]] (우리만의 언어 짓기)''' - 프로그래밍을 도메인을 표현하는 전문화된 언어를 구축하는 과정으로 이해합니다. 범용 언어의 원시 요소 위에서 상향식(Bottom-up)으로 어휘를 쌓아올려, 코드가 한 편의 산문처럼 읽히게 만듭니다.
   * ''연관: [[NamesAsDesign]], [[LivingVocabulary]], [[DataAsFoundation]], [[ComplexityTaming]]''
 * '''[[NamesAsDesign]] (이름 짓기라는 설계)''' - 이름을 짓는 행위를 단순한 라벨링이 아닌 핵심적인 설계 활동으로 다룹니다. 좋은 이름은 문맥(Context) 안에서 관계 맺기를 통해 완성되며, 코드의 의도를 주석보다 명확히 드러냅니다.
   * ''연관: [[LanguageBuilding]], [[LivingVocabulary]], [[ArtisanMind]]''
 * '''[[MetaphorThinking]] (은유로 생각하기)''' - 추상적인 시스템을 레스토랑 주방이나 파이프라인 같은 구체적인 은유에 비유하여 사고합니다. 적절한 은유는 복잡한 구조를 즉시 이해하게 하며, 은유를 확장하는 과정에서 창의적인 해결책을 발견하게 돕습니다.
   * ''연관: [[LanguageBuilding]], [[PatternHunting]], [[DataAsFoundation]]''
 * '''[[LivingVocabulary]] (살아있는 어휘)''' - 시스템에 대한 이해가 깊어짐에 따라 코드의 어휘를 살아있는 유기체처럼 지속적으로 진화시킵니다. 낡은 용어는 즉시 정제하여 머릿속 모델과 코드 사이의 간극을 없앱니다.
   * ''연관: [[LanguageBuilding]], [[OrganicGrowth]], [[NamesAsDesign]]''
 * '''[[ComplexityTaming]] (복잡성 길들이기)''' - 추상화, 분해, 관심사 분리라는 도구를 사용하여 복잡성의 야수를 길들입니다. 큰 문제를 다룰 수 있는 작은 조각들로 나누고 경계를 세워 시스템의 유지보수성을 확보합니다.
   * ''연관: [[DataAsFoundation]], [[DirectPath]], [[NamesAsDesign]]''
Line 60: Line 75:
 * '''ShortLeash''' - 버그나 행동에 대한 가설을 형성할 때, 너무 멀리 추론하지 말고 빠르게 테스트하라. 긴 추론 사슬은 불확실성을 곱하고 시간을 낭비한다. ''연관: DetectiveWork, TinyExperiment'' === 제3장: 실행의 리듬 관련 ===
 * '''[[WorkingFirst]] (일단 작동하게)''' - 우아함보다 먼저 작동하는 것을 만들어 진실을 드러냅니다. Tailwind나 HTMX 같은 특정 기술 스택에 얽매이기보다, Custom CSS나 jQuery처럼 '''자신에게 익숙한 도구'''로 먼저 기능을 뚫어내는 실용성을 우선합니다.
   * ''연관: [[TinyExperiment]], [[BabySteps]], [[OrganicGrowth]]''
 * '''[[TinyExperiment]] (아주 작은 실험)''' - 실패 비용이 거의 없는 가장 작은 실험으로 불확실성을 제거합니다. 각 실험은 시스템에 대해 의미 있는 것을 가르쳐주는 학습의 도구가 됩니다.
   * ''연관: [[ShortLeash]], [[TightLoop]], [[BabySteps]]''
 * '''[[TightLoop]] (촘촘한 피드백 루프)''' - 변경을 만들고 그 효과를 확인하는 사이의 시간을 1초 이내로 줄여 몰입(Flow)을 유지합니다. 빠른 피드백은 개발을 지루한 노동이 아닌 즐거운 게임으로 바꿉니다.
   * ''연관: [[BabySteps]], [[DesignThroughTest]], [[GreenRefuge]], [[DesigningInTheRun]]''
 * '''[[DesigningInTheRun]] (실행 중 설계)''' - 소스 코드를 고치기 전에 브라우저 인스펙터나 REPL 등 실행 중인 환경에서 실시간으로 설계를 결정합니다. 실행 중인 현장이 당신의 실험실이자 작업실이 됩니다.
   * ''연관: [[TightLoop]], [[PresentMoment]], [[WorkingFirst]], [[RoughWholeFirst]]''
 * '''[[BabySteps]] (아기 걸음)''' - 시스템의 무결성을 유지하면서 목표를 향해 나아가는 가장 작은 보폭을 유지합니다. 오류가 발생하면 즉시 코드를 주석 처리(Comment out)하고 작동하던 마지막 한 스텝 뒤로 돌아가 증분을 재탐색합니다.
   * ''연관: [[AtomicCommit]], [[GreenRefuge]], [[TightLoop]]''
 * '''[[AtomicCommit]] (원자적 커밋)''' - 변경의 역사를 의미 있고 일관된 최소 단위로 기록합니다. 원자적 커밋은 동료와의 대화 수단이며, 문제 발생 시 안전한 회복을 보장합니다.
   * ''연관: [[BabySteps]], [[FlowingFeedback]], [[GreenRefuge]]''
 * '''[[ShortLeash]] (추측의 끈 짧게 쥐기)''' - 가설의 끈을 짧게 쥐고 수시로 확인하여 추측의 늪에 빠지지 않습니다. 추론 사슬이 길어지기 전에 가장 빠르고 직접적인 방법으로 가설을 검증합니다.
   * ''연관: [[DetectiveWork]], [[TinyExperiment]], [[PresentMoment]]''
 * '''[[GreenRefuge]] (초록색 피난처)''' - 테스트가 실패하고 5분 이내에 해결되지 않으면 즉시 마지막으로 알려진 작동 상태로 돌아갑니다. 초록 막대는 혼란 속의 안전한 베이스캠프입니다.
   * ''연관: [[SafetyNet]], [[BabySteps]], [[AtomicCommit]]''
 * '''[[The95PercentRule]] (95%의 규칙)''' - 마지막 5%의 자동화를 위해 95%의 에너지를 쏟으려는 유혹에 저항합니다. 남겨진 복잡성을 수동으로 처리하는 것이 때로는 더 경제적이고 현명한 선택입니다.
   * ''연관: [[WorkingFirst]], [[ComplexityTaming]], [[ArtisanMind]]''
Line 62: Line 95:
 * '''SafetyNet''' - 이전에 고쳐진 버그가 다시 발생하면 잡아내는 회귀 테스트를 구축하라. 좋은 안전망은 자신감을 가지고 리팩토링하고 개선할 수 있게 해준다. ''연관: GreenRefuge, CleanIsolation'' === 제4장: 유기적 성장 관련 ===
 * '''[[StrongCenter]] (강한 중심)''' - 시스템의 가장 본질적인 가치를 담은 핵심(Center)을 먼저 단단하게 구축합니다. 주변부 인프라에 에너지를 뺏기지 않고 핵심 로직의 중력을 먼저 세웁니다.
   * ''연관: [[OrganicGrowth]], [[CleanIsolation]], [[DataAsFoundation]]''
 * '''[[RoughWholeFirst]] (엉성한 전체부터)''' - 시작 전 '''TODO.md'''를 통해 메타플래닝을 수행하고, 엉성한 전체 구조에서 점진적으로 세분화(Differentiation)해 나갑니다. 배아에서 시작해 장기가 분화되는 과정을 따릅니다.
   * ''연관: [[OrganicGrowth]], [[StrongCenter]], [[WorkingFirst]]''
 * '''[[OrganicGrowth]] (유기적 성장)''' - 작동하는 핵심(Walking Skeleton)에서 시작하여 점진적으로 시스템을 분화시키며 키워나갑니다. 소프트웨어는 조립되는 것이 아니라 살아있는 생명체처럼 성장해야 합니다.
   * ''연관: [[StrongCenter]], [[DirectPath]], [[BabySteps]], [[LivingVocabulary]]''
 * '''[[DirectPath]] (문제로 향하는 직선 경로)''' - 입력에서 출력에 이르는 경로를 가리는 불필요한 레이어와 간접성을 제거합니다. 문제와 해결책 사이의 최단 거리가 가장 명확하고 강력한 설계입니다.
   * ''연관: [[ComplexityTaming]], [[OrganicGrowth]], [[CleanIsolation]]''
 * '''[[SafetyNet]] (안전망)''' - 두려움 없이 리팩토링하고 성장할 수 있도록 기존 기능을 보장하는 자동화된 회귀 테스트를 구축합니다. 안전망은 개발자의 심리적 용기를 지켜주는 그물입니다.
   * ''연관: [[GreenRefuge]], [[DesignThroughTest]], [[Refactoring]]''
 * '''[[CleanIsolation]] (깨끗한 격리)''' - 테스트 대상 코드와 외부 환경 사이의 연결 고리를 끊어 고립된 상태로 검증 가능하게 만듭니다. 의존성이 명시적이고 격리될 때 코드는 유연해집니다.
   * ''연관: [[DesignThroughTest]], [[TightLoop]], [[DataAsFoundation]]''
 * '''[[DesignThroughTest]] (테스트로 설계하기)''' - 테스트를 검증 도구가 아닌 인터페이스를 발견하고 정교화하는 설계 도구로 사용합니다. 코드를 사용하고 싶은 소망을 먼저 테스트로 적을 때 더 나은 설계가 나옵니다.
   * ''연관: [[CleanIsolation]], [[BabySteps]], [[LanguageBuilding]]''
Line 64: Line 111:
 * '''PresentMoment''' - 일어나야 한다고 생각하는 일보다는 지금 실제로 일어나고 있는 일을 이해하는 데 집중하라. 현재 순간은 대부분의 문제를 해결하는 데 필요한 모든 정보를 담고 있다. ''연관: DetectiveWork, RootHunting''

 * '''RootHunting''' - 표면적인 수정을 적용하거나 무작정 찾지 말고 체계적으로 파서 실제 원인을 찾아라. 진정한 근본 원인은 일단 발견되면 종종 간단한 해결책을 드러낸다. ''연관: PresentMoment, DetectiveWork''

=== Programming Fundamentals ===
 * '''PatternHunting''' - 자신의 코드와 다른 사람의 코드에서 반복되는 구조와 해결책을 적극적으로 찾아라. 패턴 인식은 모든 프로그래밍 전문성의 기초다. ''연관: LanguageBuilding, MasterApprentice''

 * '''ComplexityTaming''' - 복잡성을 관리하는 기법들의 도구상자를 개발하라: 추상화, 분해, 네이밍, 관심사 분리. 복잡성은 유지보수성의 적이다. ''연관: DataAsFoundation, DirectPath''

 * '''NamesAsDesign''' - 네이밍을 사고를 명확하게 하고 추상화를 드러내는 설계 활동으로 다뤄라. 좋은 이름은 코드를 자체 문서화하고 의도를 명확하게 표현한다. ''연관: LanguageBuilding, ArtisanMind''

 * '''LanguageBuilding''' - 프로그래밍을 문제 공간을 완벽하게 표현하는 도메인 특화 언어를 구축하는 것으로 접근하라. 최고의 프로그램은 전문화된 어휘로 잘 쓰인 산문처럼 읽힙다. ''연관: DataAsFoundation, LivingVocabulary''

 * '''LivingVocabulary''' - 이해가 깊어짐에 따라 코드베이스에서 사용되는 어휘를 지속적으로 발전시키고 정제하라. 좋은 어휘는 유기적으로 성장하고 새로운 통찰에 적응한다. ''연관: NamesAsDesign, OrganicGrowth''

=== Collaboration Patterns ===
 * '''TechnicalCommunity''' - 프로세스 준수보다는 기술적 우수성과 지속적 학습을 강조하는 개발 관행을 선택하라. 강한 기술적 관행은 경직된 프로세스보다 더 나은 협업을 만든다. ''연관: SharedMind, MasterApprentice''

 * '''SharedMind''' - 지식을 결합하고 서로의 사각지대를 잡아내기 위해 다른 개발자들과 긴밀히 작업하라. 함께 일하는 두 마음은 종종 어느 한쪽도 혼자서는 도달할 수 없는 통찰을 만들어낸다. ''연관: TechnicalCommunity, BuildingBridge''

 * '''FlowingFeedback''' - 병목을 만들기보다는 개발 흐름을 유지하도록 코드 리뷰와 피드백을 구조화하라. 피드백은 진행을 느추는 것이 아니라 학습을 가속화해야 한다. ''연관: BuildingBridge, TightLoop''

 * '''BuildingBridge''' - 다른 사람의 기여에 "네, 하지만..."보다는 "네, 그리고..."로 응답하라. 건설적인 대화는 방어적인 반응보다 더 나은 해결책을 만든다. ''연관: SharedMind, FlowingFeedback''

=== Learning & Expertise Patterns ===
 * '''MasterApprentice''' - 관찰, 모방, 안내된 실습을 통해 전문가로부터 직접 배워라. 스승-제자 관계는 책으로는 전달할 수 없는 암묵적 지식을 전수한다. ''연관: CraftPath, ArtisanMind''

 * '''CraftPath''' - 고급 기법보다는 기초에 집중하면서 초보자에서 전문가로의 의도적인 진행을 따라라. 숙련은 핵심 기술의 인내심 있는 개발을 요구한다. ''연관: MasterApprentice, ThinkingMirror''

 * '''[[/CognitiveMicroscope]]''' ✓ - 자신의 인지 과정을 세밀하게 관찰하여 전문성을 빠르게 구축하라. 평소에는 너무 빨라서 보이지 않는 사고의 단계들을 확대해서 보면, 생각의 해상도와 밀도가 높아진다. ''연관: ThinkingMirror, ActiveReflection, DetectiveWork''

 * '''ThinkingMirror''' - 자신의 사고 과정과 의사결정 패턴을 정기적으로 성찰하라. 자신이 어떻게 생각하는지에 대한 자각은 학습과 문제 해결을 모두 향상시킨다. ''연관: CognitiveMicroscope, ActiveReflection, InstinctiveChoice''

 * '''ActiveReflection''' - 나중이 아니라 수행하면서 자신의 행동과 결정에 대해 의식적으로 생각하라. 실시간 성찰은 성능을 향상시키고 전문성을 더 빠르게 구축한다. ''연관: CognitiveMicroscope, ThinkingMirror, PresentMoment''

 * '''InstinctiveChoice''' - 경험적 직관에 기반한 빠른 의사결정을 가능하게 하는 패턴 인식을 개발하라. 전문 프로그래머는 왜 그런지 설명하기 전에 종종 올바른 답을 안다. ''연관: PatternHunting, ArtisanMind''

== Current Status ==

=== Phase 1: Foundation Patterns (In Progress) ===
'''Completed:'''
 * [[TinyExperiment]] ✓ - 패턴 언어 형식으로 완성, 검증됨
 * [[/CognitiveMicroscope]] ✓ - 인지 과정 관찰 패턴 완성

'''Next Priority:'''
 * DataAsFoundation - 로직 단순화의 핵심
 * TwoWorlds - 사고 체계의 기본

'''Remaining Foundation:'''
 * WorkingFirst, ArtisanMind, The95PercentRule

=== Validation Results ===
첫 번째 패턴 [[TinyExperiment]]의 스토리 구조가 검증되어 패턴 언어로서의 가능성을 확인했습니다. 두 번째 패턴 [[/CognitiveMicroscope]]는 실제 멘토링 사례와 일기의 통찰을 통합하여 실천적 학습 패턴으로 완성되었습니다.

== Implementation Strategy ==

=== Phase 1: Core Foundation (Current) ===
가장 기본이 되는 5-6개 패턴을 완성하여 전체 구조의 기반을 마련

=== Phase 2: TDD & Design Patterns ===
TDD와 설계 관련 패턴들을 체계화 (10-12개 패턴)

=== Phase 3: Collaboration & Learning ===
협업과 학습 관련 패턴들을 완성 (8-10개 패턴)

== Next Actions ==

=== Immediate (This Week) ===
 * DataAsFoundation 패턴 작성 시작
 * TwoWorlds 구조 설계
 * Foundation 패턴들 간의 연결 관계 정의

=== Short Term (This Month) ===
 * Foundation 레벨 5-6개 패턴 완성
 * 패턴 언어로서의 일관성 검증
 * Phase 2 패턴 우선순위 확정

== Pattern Structure Template ==

각 패턴은 Alexander 방식을 따릅니다:
 * '''Context''' - 상황과 배경
 * '''Problem''' - 구체적인 문제와 갈등
 * '''Solution''' - 해결 방법과 원리
 * '''Examples''' - 실제 적용 사례
 * '''Related Patterns''' - 연결된 다른 패턴들

== Progress Log ==

=== Recent Achievements ===
 * 원본 문서에서 27+개 패턴 목록 정리 완료
 * TinyExperiment 패턴 완성 및 검증
 * [[/CognitiveMicroscope]] 패턴 완성 - SatirInteractionModel, CTA, 실제 멘토링 사례 통합
 * 3단계 구현 전략 수립
 * Foundation 레벨 우선순위 확정

=== Lessons Learned ===
 * 전체 패턴 목록을 먼저 정리하는 것이 중요
 * 스토리 우선 접근법의 효과 확인
 * 패턴 간 연결 관계의 복잡성 인식
 * 실제 경험과 일기의 통찰을 패턴에 통합하는 것의 가치		 === 제5장: 공동체의 지혜 관련 ===
 * '''[[TechnicalCommunity]] (기술 공동체)''' - 프로세스 준수보다 기술적 우수성과 지속적 학습을 강조하는 '공부하는 공동체'를 지향합니다. 함께 성장하는 문화가 팀의 역량을 결정합니다.
   * ''연관: [[SharedMind]], [[FlowingFeedback]], [[MasterApprentice]], [[CraftPath]]''
 * '''[[ParticipatoryDesign]] (함께 짓는 설계)''' - 설계 과정에 사용자를 참여시키고, 종료 30~40분 전 **범위 협상(Scope Negotiation)**을 통해 실질적인 가치를 결정합니다. 설계와 시공은 사용자(거주자)와 개발자의 끊임없는 대화여야 합니다.
   * ''연관: [[TwoWorlds]], [[LanguageBuilding]], [[OrganicGrowth]], [[RoughWholeFirst]]''
 * '''[[SharedMind]] (공유된 정신)''' - 지식을 결합하고 서로의 사각지대를 잡아내기 위해 긴밀하게 협업(Pair/Mob)합니다. 두 개의 뇌는 산술적인 합 그 이상의 통찰을 만들어냅니다.
   * ''연관: [[BuildingBridge]], [[MasterApprentice]], [[TechnicalCommunity]]''
 * '''[[BuildingBridge]] (대화의 다리 놓기)''' - 상대방의 기여를 먼저 인정하고 그 위에 생각을 덧붙이는 "네, 그리고" 화법을 실천합니다. 대화는 승패를 가리는 경기가 아니라 다리를 놓는 과정입니다.
   * ''연관: [[FlowingFeedback]], [[SharedMind]], [[TechnicalCommunity]]''
 * '''[[FlowingFeedback]] (흐르는 피드백)''' - 병목을 만들지 않고 학습을 가속화하도록 코드 리뷰와 피드백을 구조화합니다. 피드백이 강물처럼 흐를 때 팀 전체의 실력이 상향 평준화됩니다.
   * ''연관: [[BuildingBridge]], [[TightLoop]], [[TechnicalCommunity]]''
 * '''[[MasterApprentice]] (스승과 제자)''' - 전문가의 어깨 너머로 관찰하고 모방하며 암묵지를 흡수합니다. 전문성은 오직 사람과 사람 사이의 만남을 통해 계승됩니다.
   * ''연관: [[CraftPath]], [[CognitiveMicroscope]], [[SharedMind]]''
 * '''[[CraftPath]] (기예의 길)''' - 유행을 쫓기보다 변하지 않는 기초(Fundamentals)에 집중하며 장인으로 나아가는 의도적 수련을 따릅니다. 성장은 우연이 아니라 설계되는 것입니다.
   * ''연관: [[ThinkingMirror]], [[TinyResearch]], [[MasterApprentice]]''
 * '''[[InstinctiveChoice]] (직관적 선택)''' - 수천 번의 경험을 통해 논리적 분석 이전에 최선의 길을 즉각적으로 찾아내는 직관을 신뢰하고 개발합니다. 최고의 논리는 직관의 모습으로 나타납니다.
   * ''연관: [[PatternHunting]], [[ArtisanMind]], [[ActiveReflection]]''
 * '''[[PatternHunting]] (패턴 사냥)''' - 자신의 코드와 타인의 코드에서 반복되는 구조와 해결책을 적극적으로 찾아 지식의 저장소에 담습니다. 패턴 인식은 모든 전문성의 기초입니다.
   * ''연관: [[MetaphorThinking]], [[LanguageBuilding]], [[CognitiveMicroscope]]''
 * '''[[DetectiveWork]] (탐정의 수사)''' - 무작위 수정 대신 가설을 세우고 증거를 수집하여 버그의 정체를 논리적으로 수사합니다. 디버깅은 이해를 교정하는 인지적 과정입니다.
   * ''연관: [[ShortLeash]], [[PresentMoment]], [[TinyExperiment]]''
 * '''[[AugmentedInvestigation]] (증강된 수사)''' - AI에게 의도와 맥락, 사실을 명료하게 제공하여 수사의 해상도를 높입니다. 명확한 질문을 통해 AI라는 조력자의 능력을 증폭시킨다.
   * ''연관: [[DetectiveWork]], [[PresentMoment]], [[CognitiveMicroscope]]''
 * '''[[RootHunting]] (근본 원인 추적)''' - 증상(Symptom)만 치료하지 말고 "왜?"를 반복하며 근본 원인(Root Cause)을 찾아 제거합니다. 뿌리를 뽑아야 버그의 재발을 막을 수 있습니다.
   * ''연관: [[DetectiveWork]], [[SafetyNet]], [[PresentMoment]]''
 * '''[[TinyResearch]] (5분 연구)''' - 일하면서 발생하는 작은 호기심을 즉시 해결하는 5분 연구를 습관화합니다. 작은 지식의 축적이 훗날 거대한 전문성의 복리로 돌아옵니다.
   * ''연관: [[CraftPath]], [[DetectiveWork]], [[CognitiveMicroscope]]''
 * '''[[ThinkingMirror]] (사고의 거울)''' - 자신의 사고 과정과 의사결정 패턴을 정기적으로 기록하고 성찰하여 메타인지를 깨웁니다. 성찰하는 거울이 있을 때 경험은 비로소 교훈이 됩니다.
   * ''연관: [[CognitiveMicroscope]], [[ActiveReflection]], [[CraftPath]]''
 * '''[[ActiveReflection]] (실천 중의 성찰)''' - 수행하는 뜨거운 현장에서 자신의 행동과 결정에 대해 의식적으로 생각합니다. 실시간 성찰은 실수를 즉시 교정하고 감각을 뇌에 각인시킵니다.
   * ''연관: [[ThinkingMirror]], [[PresentMoment]], [[CognitiveMicroscope]]''

생각하는 개발자의 길

주니어 개발자들을 위한 패턴 언어 - 38개의 실천적 중심이 엮어내는 성장의 서사

소프트웨어는 미리 정해진 설계도대로 조립되는 결과물이 아니라, 개발자의 인식과 코드의 언어가 조화를 이루며 씨앗으로부터 자라나는 것입니다. 이 패턴 언어는 그 생명력을 유지하며 시스템을 키워가는 과정을 담고 있습니다.

Contents

  1. 생각하는 개발자의 길
    1. 성장의 서사 (The Narrative)
    2. 패턴 목록 (Pattern Inventory)

성장의 서사 (The Narrative)

제1장: 명료한 인식 (Clear Perception)

프로그래밍은 단순한 지식의 적용을 넘어 숙련된 감각이 필요한 기예입니다. 개발자는 자신의 고정관념에 속지 않고 지금 이 순간 시스템에서 실제로 일어나는 사실을 있는 그대로 보아야 합니다.

복잡한 현상에 매몰되지 않으려면 한 번에 한 가지 목표에만 집중해야 하며, 자신의 사고 과정을 인지 현미경으로 들여다보듯 세밀하게 관찰할 때 비로소 전문성이 쌓이기 시작합니다.

제2장: 언어와 이론 (Language and Theory)

현실의 문제를 코드로 옮기기 위해서는 먼저 문제 공간과 해결 공간을 명확히 구분해야 합니다. 기술적인 도구를 고르기에 앞서 잘 정리된 데이터를 기반으로 삼아 구조의 중심을 잡습니다.

우리는 추상적인 개념을 다루기 위해 은유를 통해 사고하고, 적절한 이름을 붙이는 이름 짓기를 설계 활동으로 수행하며 우리만의 도메인 언어를 구축합니다. 이 언어는 시스템의 변화에 맞춰 살아있는 어휘로 진화해야 하며, 이렇게 언어가 바로 설 때 비로소 거대한 복잡성을 길들일 수 있습니다.

제3장: 실행의 리듬 (The Rhythm of Execution)

소프트웨어에 생명력을 불어넣는 것은 멈추지 않는 맥박, 즉 리듬입니다. 우리는 완벽한 설계에 매몰되기보다 일단 작동하는 것을 먼저 만들어 진실을 마주합니다. 불확실한 지점에서는 작은 실험을 수행하며 1초 이내에 결과를 확인하는 촘촘한 피드백 루프를 가동합니다.

특히 브라우저 인스펙터나 REPL 같은 실행 중인 현장에서의 설계를 통해 소스 코드를 고치기 전 작동하는 진실을 먼저 결정합니다. 안전한 전진을 위해 작은 보폭을 유지하며, 각 단계의 완료를 원자적인 커밋으로 기록합니다. 가설을 세울 때는 추측의 끈을 짧게 쥐고 수시로 검증하며, 실패했을 때는 즉시 안전한 초록색 피난처로 돌아옵니다. 이때 마지막 5%의 자동화에 집착하지 않는 95%의 규칙은 리듬을 지속하기 위한 장인의 실무적 결단이 됩니다.

제4장: 유기적 성장 (Organic Growth)

리듬을 탄 시스템은 이제 하나의 생명체처럼 자라납니다. 시스템은 무질서하게 커지는 것이 아니라, 가장 본질적인 가치를 담은 강한 중심에서 시작해 바깥으로 펼쳐 나갑니다. 완벽한 조각을 맞추기보다 엉성한 전체에서 시작하여 점진적으로 세분화(Differentiation)해 나가는 것이 성장의 핵심입니다.

또한 테스트를 통한 설계는 이 성장의 방향을 안내하는 나침반이 됩니다. 시스템을 키워가는 과정에서 불필요한 레이어를 걷어내고 문제에 직선으로 다가가는 직선 경로를 유지하십시오. 성장의 용기를 주는 것은 언제나 작동함을 보장하는 안전망이며, 의존성을 끊어낸 깨끗한 격리를 통해 각 부분을 유연하게 유지해야 합니다. 이것이 바로 건강한 유기적 성장의 모습입니다.

제5장: 공동체의 지혜 (Collective Wisdom)

개인의 기예는 공동체 안에서 비로소 완성됩니다. 서로의 실력을 존중하는 기술 공동체 안에서, 두 명의 지혜를 하나로 모으는 공유된 정신을 실천합니다. 우리는 거주자인 사용자와 함께 짓고 소통하며 실제 삶이 녹아든 공간을 만듭니다.

우리는 대화의 다리를 놓고, 강물처럼 거침없이 흐르는 피드백을 통해 함께 성장합니다. 앞서간 이로부터 암묵지를 전수받으며 자신만의 성장 경로를 걷습니다.

이 여정 속에서 우리는 함께 패턴을 사냥하고, 탐정의 수사처럼 버그를 추적하며, 근본 원인을 찾아 제거합니다. 이때 AI라는 강력한 파트너와 의도와 증거를 나누는 증강된 수사는 문제 해결의 속도를 획기적으로 높여줍니다. 이러한 반복은 결국 데이터에 기반한 직관적인 선택을 가능하게 합니다. 우리는 매일의 작은 호기심을 5분 연구로 채우고, 수행하는 순간을 실시간으로 성찰하며, 하루의 끝에서 자신의 사고 과정을 거울에 비추어 봅니다.

패턴 목록 (Pattern Inventory)

제1장: 명료한 인식 관련

  • ArtisanMind (장인의 마음) - 프로그래밍을 순수한 과학보다 감각과 경험이 필요한 기예로 접근합니다. 이론적 완벽함에 매몰되어 실행을 미루기보다, 불완전한 지식으로도 작동하는 실체를 만들어내는 해커 마인드를 함양합니다.

  • PresentMoment (지금 이 순간) - "이래야 한다"는 머릿속 모델보다 지금 모니터에 찍힌 로그와 에러라는 실제 현실에 집중합니다. 지도가 영토와 다를 때, 항상 영토(실행 결과)를 유일한 진실로 받아들이는 겸손함을 유지합니다.

  • SingleFocus (오직 하나에 집중) - 한 번에 정확히 한 가지 목표에만 렌즈를 맞춥니다. 버그 수정과 리팩토링을 섞지 않음으로써 인지 부하를 낮추고 작업의 완결성을 높입니다.

  • CognitiveMicroscope (인지 현미경) - 자신의 인지 과정을 네 단계(Intake, Meaning, Significance, Response)로 분해하여 세밀하게 관찰합니다. 관찰 중인 내용을 소리 내어 말하는 Think Aloud는 인지 과정을 명시화하는 훌륭한 방법입니다.

제2장: 언어와 이론 관련

  • TwoWorlds (문제와 해결의 두 세계) - 무엇을 해결할 것인가(문제 공간)와 어떻게 구현할 것인가(해결 공간)를 엄격히 분리합니다. 많은 오류는 이 두 세계를 너무 일찍 섞는 데서 비롯됨을 인지하고, 문제 공간에 더 오래 머무르며 본질을 탐색합니다.

  • DataAsFoundation (토대로서의 데이터) - 로직 이전에 단단한 데이터 구조를 먼저 설계합니다. 로직이 복잡해 보인다면 그것은 사실 데이터 구조가 복잡한 것이며, 올바른 데이터 표현은 로직을 저절로 단순하게 만듭니다.

  • LanguageBuilding (우리만의 언어 짓기) - 프로그래밍을 도메인을 표현하는 전문화된 언어를 구축하는 과정으로 이해합니다. 범용 언어의 원시 요소 위에서 상향식(Bottom-up)으로 어휘를 쌓아올려, 코드가 한 편의 산문처럼 읽히게 만듭니다.

  • NamesAsDesign (이름 짓기라는 설계) - 이름을 짓는 행위를 단순한 라벨링이 아닌 핵심적인 설계 활동으로 다룹니다. 좋은 이름은 문맥(Context) 안에서 관계 맺기를 통해 완성되며, 코드의 의도를 주석보다 명확히 드러냅니다.

  • MetaphorThinking (은유로 생각하기) - 추상적인 시스템을 레스토랑 주방이나 파이프라인 같은 구체적인 은유에 비유하여 사고합니다. 적절한 은유는 복잡한 구조를 즉시 이해하게 하며, 은유를 확장하는 과정에서 창의적인 해결책을 발견하게 돕습니다.

  • LivingVocabulary (살아있는 어휘) - 시스템에 대한 이해가 깊어짐에 따라 코드의 어휘를 살아있는 유기체처럼 지속적으로 진화시킵니다. 낡은 용어는 즉시 정제하여 머릿속 모델과 코드 사이의 간극을 없앱니다.

  • ComplexityTaming (복잡성 길들이기) - 추상화, 분해, 관심사 분리라는 도구를 사용하여 복잡성의 야수를 길들입니다. 큰 문제를 다룰 수 있는 작은 조각들로 나누고 경계를 세워 시스템의 유지보수성을 확보합니다.

제3장: 실행의 리듬 관련

  • WorkingFirst (일단 작동하게) - 우아함보다 먼저 작동하는 것을 만들어 진실을 드러냅니다. Tailwind나 HTMX 같은 특정 기술 스택에 얽매이기보다, Custom CSS나 jQuery처럼 자신에게 익숙한 도구로 먼저 기능을 뚫어내는 실용성을 우선합니다.

  • TinyExperiment (아주 작은 실험) - 실패 비용이 거의 없는 가장 작은 실험으로 불확실성을 제거합니다. 각 실험은 시스템에 대해 의미 있는 것을 가르쳐주는 학습의 도구가 됩니다.

  • TightLoop (촘촘한 피드백 루프) - 변경을 만들고 그 효과를 확인하는 사이의 시간을 1초 이내로 줄여 몰입(Flow)을 유지합니다. 빠른 피드백은 개발을 지루한 노동이 아닌 즐거운 게임으로 바꿉니다.

  • DesigningInTheRun (실행 중 설계) - 소스 코드를 고치기 전에 브라우저 인스펙터나 REPL 등 실행 중인 환경에서 실시간으로 설계를 결정합니다. 실행 중인 현장이 당신의 실험실이자 작업실이 됩니다.

  • BabySteps (아기 걸음) - 시스템의 무결성을 유지하면서 목표를 향해 나아가는 가장 작은 보폭을 유지합니다. 오류가 발생하면 즉시 코드를 주석 처리(Comment out)하고 작동하던 마지막 한 스텝 뒤로 돌아가 증분을 재탐색합니다.

  • AtomicCommit (원자적 커밋) - 변경의 역사를 의미 있고 일관된 최소 단위로 기록합니다. 원자적 커밋은 동료와의 대화 수단이며, 문제 발생 시 안전한 회복을 보장합니다.

  • ShortLeash (추측의 끈 짧게 쥐기) - 가설의 끈을 짧게 쥐고 수시로 확인하여 추측의 늪에 빠지지 않습니다. 추론 사슬이 길어지기 전에 가장 빠르고 직접적인 방법으로 가설을 검증합니다.

  • GreenRefuge (초록색 피난처) - 테스트가 실패하고 5분 이내에 해결되지 않으면 즉시 마지막으로 알려진 작동 상태로 돌아갑니다. 초록 막대는 혼란 속의 안전한 베이스캠프입니다.

  • The95PercentRule (95%의 규칙) - 마지막 5%의 자동화를 위해 95%의 에너지를 쏟으려는 유혹에 저항합니다. 남겨진 복잡성을 수동으로 처리하는 것이 때로는 더 경제적이고 현명한 선택입니다.

제4장: 유기적 성장 관련

  • StrongCenter (강한 중심) - 시스템의 가장 본질적인 가치를 담은 핵심(Center)을 먼저 단단하게 구축합니다. 주변부 인프라에 에너지를 뺏기지 않고 핵심 로직의 중력을 먼저 세웁니다.

  • RoughWholeFirst (엉성한 전체부터) - 시작 전 TODO.md를 통해 메타플래닝을 수행하고, 엉성한 전체 구조에서 점진적으로 세분화(Differentiation)해 나갑니다. 배아에서 시작해 장기가 분화되는 과정을 따릅니다.

  • OrganicGrowth (유기적 성장) - 작동하는 핵심(Walking Skeleton)에서 시작하여 점진적으로 시스템을 분화시키며 키워나갑니다. 소프트웨어는 조립되는 것이 아니라 살아있는 생명체처럼 성장해야 합니다.

  • DirectPath (문제로 향하는 직선 경로) - 입력에서 출력에 이르는 경로를 가리는 불필요한 레이어와 간접성을 제거합니다. 문제와 해결책 사이의 최단 거리가 가장 명확하고 강력한 설계입니다.

  • SafetyNet (안전망) - 두려움 없이 리팩토링하고 성장할 수 있도록 기존 기능을 보장하는 자동화된 회귀 테스트를 구축합니다. 안전망은 개발자의 심리적 용기를 지켜주는 그물입니다.

  • CleanIsolation (깨끗한 격리) - 테스트 대상 코드와 외부 환경 사이의 연결 고리를 끊어 고립된 상태로 검증 가능하게 만듭니다. 의존성이 명시적이고 격리될 때 코드는 유연해집니다.

  • DesignThroughTest (테스트로 설계하기) - 테스트를 검증 도구가 아닌 인터페이스를 발견하고 정교화하는 설계 도구로 사용합니다. 코드를 사용하고 싶은 소망을 먼저 테스트로 적을 때 더 나은 설계가 나옵니다.

제5장: 공동체의 지혜 관련

CategoryAiGardenProject CategoryPatternLanguage

AiGarden/ToJuniorsPatternLanguage (last edited 2025-12-31 03:35:40 by 정수)