Differences between revisions 4 and 8 (spanning 4 versions)
Revision 4 as of 2025-07-24 13:49:28
Size: 6327
Editor: 정수
Comment:
Revision 8 as of 2025-07-24 16:09:14
Size: 11331
Editor: 정수
Comment:
Deletions are marked like this. Additions are marked like this.
Line 5: Line 5:
주니어 개발자들을 위한 프로그래밍 지혜를 Christopher Alexander의 패턴 언어로 변환하는 프로젝트. 주니어 개발자들을 위한 프로그래밍 피드백을 Christopher Alexander의 패턴 언어로 변환하는 프로젝트.
Line 11: Line 11:
[[기술문서모음/ToJuniors]] 페이지의 27개 핵심 격언들을 개별 패턴으로 확장하여, 반격자(semi-lattice) 구조의 상호 연결된 지식 네트워크를 구축한다. 각 패턴은 이솝우화 스타일의 스토리텔링으로 작성되어 초보자들이 쉽게 이해하고 기억할 수 있도록 한다. [[기술문서모음/ToJuniors]] 문서의 패턴들을 Alexander의 패턴 언어 형식으로 변환하여 구조적이고 교육적인 자료로 발전시키는 것이 목표입니다.
Line 13: Line 13:
== Pattern Language Structure == === Core Principles ===
 * '''Structure-Preserving Baby Steps''' - 기존 구조를 보존하며 점진적 발전
 * '''Story-First Approach''' - 스토리로 시작해서 패턴으로 추상화
 * '''Educational Focus''' - 학습자 중심의 명확한 설명
 * '''Pattern Language Structure''' - Alexander 방식의 체계적 연결
Line 15: Line 19:
=== Foundation Patterns (가장 기본적) ===
'''[[TinyExperiment]]''' (완성) - 작은 실험 환경을 통한 점진적 학습과 개발
↳ enables → BabyStep, UseAbduction, HereAndNowDebugging
↳ used by → TddIsDesignActivity, PiecemealGrowthCenterFirst
== Pattern Inventory ==
Line 20: Line 21:
'''UseDataToMakeLogicSimple''' - 관심사 분리의 기본 원칙
↳ supports → MakeDSL, DoNotMixLogicAndDataConstruction
↳ enables → FindCommonalityAndVariability
=== Foundation Patterns ===
'''Core Programming Principles'''
 * '''DataAsFoundation''' - Separate data construction from business logic to achieve simplicity; create domain-specific languages when data structures become complex. The foundation of all clean code starts with well-organized data. ''Related: LanguageBuilding, ComplexityTaming''
Line 24: Line 25:
'''ProblemSpaceSolutionSpace''' - 근본적 사고 체계
↳ guides → NamingIsDesignPractice, MakeItWorkThenMakeBetter
↳ supports → TddIsDesignActivity
 * '''TwoWorlds''' - Distinguish clearly between the problem space (what needs to be solved) and solution space (how to implement it). Many programming errors stem from mixing these concerns too early in the thinking process. ''Related: StrongCenter, PatternHunting''
Line 28: Line 27:
=== Intermediate Patterns (기초 위에 구축) ===
'''BabyStep''' - 핵심적 진화적 접근법
↳ connected to → MicroCommit, ShortFeedbackCycle
↳ enables → PiecemealGrowthCenterFirst
↳ requires → DoNotGuessValidateIt
 * '''WorkingFirst''' - Get something working before making it elegant or efficient. A working solution reveals the true nature of the problem and guides better design decisions. ''Related: BabySteps, OrganicGrowth''
Line 34: Line 29:
'''NamingIsDesignPractice''' - 추상화 생성
↳ uses → ProblemSpaceSolutionSpace
↳ supports → MakeDSL
↳ enables → FindCommonalityAndVariability
 * '''ArtisanMind''' - Approach programming as a craft requiring intuition, experience, and feel rather than pure systematic methodology. The best programmers combine technical knowledge with artistic sensibility. ''Related: MasterApprentice, NamesAsDesign''
Line 39: Line 31:
'''TddIsDesignActivity''' - 피드백을 통한 설계
↳ uses → ProblemSpaceSolutionSpace, BabyStep
↳ requires → ShortFeedbackCycle, UseAbduction
↳ produces → RegressionTest
 * '''The95PercentRule''' - Resist the temptation to automate the final 5% of any process. That remaining complexity often costs more than the manual effort it would save. ''Related: WorkingFirst, ShortLeash''
Line 44: Line 33:
=== Application Patterns (구체적 실천) ===
'''MicroCommit''' - 버전 제어 원칙
↳ implements → BabyStep
↳ enables → PiecemealGrowthCenterFirst
=== TDD & Evolutionary Design Patterns ===
 * '''[[TinyExperiment]]''' ✓ - Start with the smallest possible experiment that can teach you something meaningful about the problem. Each experiment should be so small that failure costs almost nothing. ''Related: BabySteps, GreenRefuge''
Line 49: Line 36:
'''UseAbduction''' - 탐구 방법
↳ supports → TddIsDesignActivity, HereAndNowDebugging
↳ opposite of → DoNotGuessValidateIt
 * '''BabySteps''' - Take the smallest possible step that moves toward your goal while maintaining system integrity. Large steps hide complexity and make debugging exponentially harder. ''Related: TinyExperiment, AtomicCommit''
Line 53: Line 38:
'''HereAndNowDebugging''' - 디버깅 접근법
↳ uses → UseAbduction, EliminateIntermediateLayers
↳ implements → DoNotGuessValidateIt
 * '''GreenRefuge''' - When tests fail, immediately return to the last known working state rather than trying to fix forward. Your green bar is a safe harbor in the storm of complexity. ''Related: SafetyNet, PresentMoment''
Line 57: Line 40:
=== Meta-Patterns (과정 자체에 대한) ===
'''CraftNotScience''' - 개발 철학
↳ manifests through → BabyStep, LastFivePercentAutomation
↳ guides → LearnFromExperts
 * '''DesignThroughTest''' - Use test-driven development as a design activity, not just a verification tool. The act of writing tests first reveals better API designs and cleaner interfaces. ''Related: CleanIsolation, TightLoop''
Line 62: Line 42:
'''LastFivePercentAutomation''' - 자동화의 한계
↳ reflects → CraftNotScience
↳ requires → PairProgrammingWithJuniors
 * '''TightLoop''' - Minimize the time between making a change and seeing its effect. Long feedback cycles allow errors to compound and make root causes harder to identify. ''Related: AtomicCommit, PresentMoment''
Line 66: Line 44:
=== Social Patterns (팀 역학) ===
'''PairProgrammingWithJuniors''' - 지식 전수
↳ enables → LearnFromExperts
↳ uses → YesButYesAnd
↳ supports → LastFivePercentAutomation
 * '''AtomicCommit''' - Make each commit represent one complete, coherent change that can stand alone. Atomic commits make it easier to understand, review, and revert changes. ''Related: BabySteps, TightLoop''
Line 72: Line 46:
== Pattern Template ==  * '''CleanIsolation''' - Design tests and modules so they can run independently without hidden dependencies. Isolation makes systems easier to understand, test, and modify. ''Related: DesignThroughTest, DirectPath''
Line 74: Line 48:
각 패턴은 Alexander의 형식을 따르되, 이솝우화 스타일로 작성된다:  * '''DetectiveWork''' - Use abductive reasoning to form hypotheses about what might be causing observed behavior. Good programmers are detectives who gather evidence before drawing conclusions. ''Related: RootHunting, PresentMoment''
Line 76: Line 50:
{{{
#acl +All:read
 * '''OrganicGrowth''' - Grow your system incrementally from a working core rather than building all parts simultaneously. Like biological growth, software grows healthiest when it maintains wholeness at each stage. ''Related: StrongCenter, WorkingFirst''
Line 79: Line 52:
= PatternName =  * '''StrongCenter''' - Start building from the most essential core functionality and grow outward. A strong center provides stability and coherence as the system expands. ''Related: OrganicGrowth, TwoWorlds''
Line 81: Line 54:
== Context ==
언제 이 패턴이 적용되는가
=== Testing & Debugging Patterns ===
 * '''DirectPath''' - Eliminate unnecessary layers and indirection that obscure the flow from input to output. The shortest path between problem and solution is usually the clearest. ''Related: CleanIsolation, SingleFocus''
Line 84: Line 57:
== Problem ==
스토리나 우화로 문제 상황 묘사
 * '''SingleFocus''' - Work on exactly one thing at a time, completing it fully before moving to the next. Multitasking in debugging leads to confusion and missed connections. ''Related: AtomicCommit, PresentMoment''
Line 87: Line 59:
== Solution ==
구체적이고 실행 가능한 해결책
문단 형태로 자연스럽게 서술
 * '''ShortLeash''' - When forming hypotheses about bugs or behavior, test them quickly rather than reasoning too far ahead. Long chains of reasoning multiply uncertainty and waste time. ''Related: DetectiveWork, TinyExperiment''
Line 91: Line 61:
== Examples ==
실제 개발 상황의 구체적 예시들
캐릭터와 스토리가 있는 경험담
 * '''SafetyNet''' - Build regression tests that catch previously fixed bugs if they reoccur. A good safety net lets you refactor and improve with confidence. ''Related: GreenRefuge, CleanIsolation''
Line 95: Line 63:
== Resulting Context ==
이 패턴 적용 후의 상황
 * '''PresentMoment''' - Focus on understanding what is actually happening right now rather than what you think should be happening. The present moment contains all the information needed to solve most problems. ''Related: DetectiveWork, RootHunting''
Line 98: Line 65:
== Related Patterns ==
 * '''Uses:''' 이 패턴이 사용하는 다른 패턴들
 * '''Used by:''' 이 패턴을 사용하는 패턴들
 * '''Enables:''' 이 패턴이 가능하게 하는 패턴들
 * '''Complements:''' 보완하는 패턴들
 * '''RootHunting''' - Dig systematically to find the actual cause rather than applying surface fixes or searching randomly. True root causes, once found, often reveal simple solutions. ''Related: PresentMoment, DetectiveWork''
Line 104: Line 67:
----
CategoryPattern
}}}
=== Programming Fundamentals ===
 * '''PatternHunting''' - Actively look for recurring structures and solutions in your code and others'. Recognizing patterns is the foundation of all programming expertise. ''Related: LanguageBuilding, MasterApprentice''
Line 108: Line 70:
== Complete Proverb List ==  * '''ComplexityTaming''' - Develop a toolkit of techniques for managing complexity: abstraction, decomposition, naming, and separation of concerns. Complexity is the enemy of maintainability. ''Related: DataAsFoundation, DirectPath''
Line 110: Line 72:
'''Data & Logic Design:'''
 1. "use data to make logic simple"
 2. "make DSL"
 3. "do not mix logic and data construction"
 * '''NamesAsDesign''' - Treat naming as a design activity that clarifies thinking and reveals abstractions. Good names make code self-documenting and express intent clearly. ''Related: LanguageBuilding, ArtisanMind''
Line 115: Line 74:
'''Programming Philosophy:'''
 4. "last 5% automation"
 5. "craft, not science"
 6. "Make it work, then make it better"
 7. "problem space, solution space"
 8. "naming itself is a design practice"
 9. "programming is to make a language system"
 * '''LanguageBuilding''' - Approach programming as building a domain-specific language that perfectly expresses your problem space. The best programs read like well-written prose in a specialized vocabulary. ''Related: DataAsFoundation, LivingVocabulary''
Line 123: Line 76:
'''Programming Fundamentals:'''
 10. "공통점과 차이점 찾기" (Find commonality and variability)
 * '''LivingVocabulary''' - Continuously evolve and refine the vocabulary used in your codebase as understanding deepens. Good vocabulary grows organically and adapts to new insights. ''Related: NamesAsDesign, OrganicGrowth''
Line 126: Line 78:
'''TDD & Evolutionary Design:'''
 11. "Baby Step"
 12. "quickly step back to closest green-bar"
 13. "TDD is a design activity"
 14. "short feedback cycle"
 15. "micro commit, one at a time"
 16. "isolation"
 17. "use abduction"
 18. "piecemeal growth, center first"
=== Collaboration Patterns ===
 * '''TechnicalCommunity''' - Choose development practices that emphasize technical excellence and continuous learning over process compliance. Strong technical practices create better collaboration than rigid processes. ''Related: SharedMind, MasterApprentice''
Line 136: Line 81:
'''Testing & Debugging:'''
 19. "eliminate/reduce intermediate layers"
 20. "넘겨짚지 말고, 마술의 동작과 동작 사이를 잘 들여다보기"
 21. "do not guess far. when you guess, validate it"
 22. "regression test"
 23. "Here and now debugging"
 * '''SharedMind''' - Work closely with other developers to combine knowledge and catch each other's blind spots. Two minds working together often produce insights neither could reach alone. ''Related: TechnicalCommunity, BuildingBridge''
Line 143: Line 83:
'''Collaboration & Team:'''
 24. "XP over Scrum for developers"
 25. "pair programming with juniors"
 26. "Yes, but / Yes, and"
 * '''FlowingFeedback''' - Structure code reviews and feedback to maintain development flow rather than creating bottlenecks. Feedback should accelerate learning, not slow down progress. ''Related: BuildingBridge, TightLoop''
Line 148: Line 85:
'''Learning & Expertise:'''
 27. "Learn from experts (CTA, CDE)"
 * '''BuildingBridge''' - Respond to ideas with "Yes, and..." rather than "Yes, but..." to build on others' contributions. Constructive dialogue creates better solutions than defensive reactions. ''Related: SharedMind, FlowingFeedback''

=== Learning & Expertise Patterns ===
 * '''MasterApprentice''' - Learn directly from experts through observation, imitation, and guided practice. The master-apprentice relationship transfers tacit knowledge that books cannot convey. ''Related: CraftPath, ArtisanMind''

 * '''CraftPath''' - Follow a deliberate progression from novice to expert, focusing on fundamentals before advanced techniques. Mastery requires patient development of core skills. ''Related: MasterApprentice, ThinkingMirror''

 * '''ThinkingMirror''' - Regularly reflect on your thinking processes and decision-making patterns. Self-awareness about how you think improves both learning and problem-solving. ''Related: ActiveReflection, InstinctiveChoice''

 * '''ActiveReflection''' - Think consciously about your actions and decisions while performing them, not just afterward. Real-time reflection improves performance and builds expertise faster. ''Related: ThinkingMirror, PresentMoment''

 * '''InstinctiveChoice''' - Develop pattern recognition that allows rapid decision-making based on experienced intuition. Expert programmers often know the right answer before they can explain why. ''Related: PatternHunting, ArtisanMind''

== Current Status ==

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

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

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

=== Validation Results ===
첫 번째 패턴 [[TinyExperiment]]의 스토리 구조가 검증되어 패턴 언어로서의 가능성을 확인했습니다.
Line 153: Line 116:
'''Phase 1: Foundation (현재)'''
 * [x] [[TinyExperiment]] (완성)
 * [ ] UseDataToMakeLogicSimple
 * [ ] ProblemSpaceSolutionSpace
=== Phase 1: Core Foundation (Current) ===
가장 기본이 되는 5-6개 패턴을 완성하여 전체 구조의 기반을 마련
Line 158: Line 119:
'''Phase 2: Intermediate Layer'''
 * [ ] BabyStep
 * [ ] NamingIsDesignPractice
 * [ ] TddIsDesignActivity
=== Phase 2: TDD & Design Patterns ===
TDD와 설계 관련 패턴들을 체계화 (10-12개 패턴)
Line 163: Line 122:
'''Phase 3: Application Patterns'''
 * [ ] MicroCommit
 * [ ] UseAbduction
 * [ ] HereAndNowDebugging
=== Phase 3: Collaboration & Learning ===
협업과 학습 관련 패턴들을 완성 (8-10개 패턴)
Line 168: Line 125:
'''Phase 4: Meta & Social'''
 * [ ] CraftNotScience
 * [ ] LastFivePercentAutomation
 * [ ] PairProgrammingWithJuniors
== Next Actions ==
Line 173: Line 127:
'''Phase 5: Integration'''
 * [ ] Update [[기술문서모음/ToJuniors]] with all pattern links
 * [ ] Create pattern relationship visualization
 * [ ] Validate semi-lattice structure
=== 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''' - 연결된 다른 패턴들
Line 180: Line 148:
'''2024-01:''' Project initiated. First pattern [[TinyExperiment]] created with story-driven approach. Enhanced from bullet-point structure to Aesop's fable style storytelling. Pattern successfully integrates assumption, validation, fail-safe, fast feedback loop, isolation, baby step, and abduction concepts. === Recent Achievements ===
 * 원본 문서에서 27+개 패턴 목록 정리 완료
 * TinyExperiment 패턴 완성 및 검증
 * 3단계 구현 전략 수립
 * Foundation 레벨 우선순위 확정
Line 182: Line 154:
== References ==

 * Christopher Alexander - "A Pattern Language", "The Timeless Way of Building"
 * [[기술문서모음/ToJuniors]] - Original proverb collection
 * [[OrgPatterns]] - Pattern language inspiration and structure
 * [[가추법]] - Abduction methodology
=== Lessons Learned ===
 * 전체 패턴 목록을 먼저 정리하는 것이 중요
 * 스토리 우선 접근법의 효과 확인
 * 패턴 간 연결 관계의 복잡성 인식
Line 190: Line 160:
CategoryAiGardenProject CategoryPattern CategoryAiGardenProject CategoryPatternLanguage

AiGarden/ToJuniorsPatternLanguage

주니어 개발자들을 위한 프로그래밍 피드백을 Christopher Alexander의 패턴 언어로 변환하는 프로젝트.

Project Vision

기술문서모음/ToJuniors 문서의 패턴들을 Alexander의 패턴 언어 형식으로 변환하여 구조적이고 교육적인 자료로 발전시키는 것이 목표입니다.

Core Principles

  • Structure-Preserving Baby Steps - 기존 구조를 보존하며 점진적 발전

  • Story-First Approach - 스토리로 시작해서 패턴으로 추상화

  • Educational Focus - 학습자 중심의 명확한 설명

  • Pattern Language Structure - Alexander 방식의 체계적 연결

Pattern Inventory

Foundation Patterns

Core Programming Principles

  • DataAsFoundation - Separate data construction from business logic to achieve simplicity; create domain-specific languages when data structures become complex. The foundation of all clean code starts with well-organized data. Related: LanguageBuilding, ComplexityTaming

  • TwoWorlds - Distinguish clearly between the problem space (what needs to be solved) and solution space (how to implement it). Many programming errors stem from mixing these concerns too early in the thinking process. Related: StrongCenter, PatternHunting

  • WorkingFirst - Get something working before making it elegant or efficient. A working solution reveals the true nature of the problem and guides better design decisions. Related: BabySteps, OrganicGrowth

  • ArtisanMind - Approach programming as a craft requiring intuition, experience, and feel rather than pure systematic methodology. The best programmers combine technical knowledge with artistic sensibility. Related: MasterApprentice, NamesAsDesign

  • The95PercentRule - Resist the temptation to automate the final 5% of any process. That remaining complexity often costs more than the manual effort it would save. Related: WorkingFirst, ShortLeash

TDD & Evolutionary Design Patterns

  • TinyExperiment ✓ - Start with the smallest possible experiment that can teach you something meaningful about the problem. Each experiment should be so small that failure costs almost nothing. Related: BabySteps, GreenRefuge

  • BabySteps - Take the smallest possible step that moves toward your goal while maintaining system integrity. Large steps hide complexity and make debugging exponentially harder. Related: TinyExperiment, AtomicCommit

  • GreenRefuge - When tests fail, immediately return to the last known working state rather than trying to fix forward. Your green bar is a safe harbor in the storm of complexity. Related: SafetyNet, PresentMoment

  • DesignThroughTest - Use test-driven development as a design activity, not just a verification tool. The act of writing tests first reveals better API designs and cleaner interfaces. Related: CleanIsolation, TightLoop

  • TightLoop - Minimize the time between making a change and seeing its effect. Long feedback cycles allow errors to compound and make root causes harder to identify. Related: AtomicCommit, PresentMoment

  • AtomicCommit - Make each commit represent one complete, coherent change that can stand alone. Atomic commits make it easier to understand, review, and revert changes. Related: BabySteps, TightLoop

  • CleanIsolation - Design tests and modules so they can run independently without hidden dependencies. Isolation makes systems easier to understand, test, and modify. Related: DesignThroughTest, DirectPath

  • DetectiveWork - Use abductive reasoning to form hypotheses about what might be causing observed behavior. Good programmers are detectives who gather evidence before drawing conclusions. Related: RootHunting, PresentMoment

  • OrganicGrowth - Grow your system incrementally from a working core rather than building all parts simultaneously. Like biological growth, software grows healthiest when it maintains wholeness at each stage. Related: StrongCenter, WorkingFirst

  • StrongCenter - Start building from the most essential core functionality and grow outward. A strong center provides stability and coherence as the system expands. Related: OrganicGrowth, TwoWorlds

Testing & Debugging Patterns

  • DirectPath - Eliminate unnecessary layers and indirection that obscure the flow from input to output. The shortest path between problem and solution is usually the clearest. Related: CleanIsolation, SingleFocus

  • SingleFocus - Work on exactly one thing at a time, completing it fully before moving to the next. Multitasking in debugging leads to confusion and missed connections. Related: AtomicCommit, PresentMoment

  • ShortLeash - When forming hypotheses about bugs or behavior, test them quickly rather than reasoning too far ahead. Long chains of reasoning multiply uncertainty and waste time. Related: DetectiveWork, TinyExperiment

  • SafetyNet - Build regression tests that catch previously fixed bugs if they reoccur. A good safety net lets you refactor and improve with confidence. Related: GreenRefuge, CleanIsolation

  • PresentMoment - Focus on understanding what is actually happening right now rather than what you think should be happening. The present moment contains all the information needed to solve most problems. Related: DetectiveWork, RootHunting

  • RootHunting - Dig systematically to find the actual cause rather than applying surface fixes or searching randomly. True root causes, once found, often reveal simple solutions. Related: PresentMoment, DetectiveWork

Programming Fundamentals

  • PatternHunting - Actively look for recurring structures and solutions in your code and others'. Recognizing patterns is the foundation of all programming expertise. Related: LanguageBuilding, MasterApprentice

  • ComplexityTaming - Develop a toolkit of techniques for managing complexity: abstraction, decomposition, naming, and separation of concerns. Complexity is the enemy of maintainability. Related: DataAsFoundation, DirectPath

  • NamesAsDesign - Treat naming as a design activity that clarifies thinking and reveals abstractions. Good names make code self-documenting and express intent clearly. Related: LanguageBuilding, ArtisanMind

  • LanguageBuilding - Approach programming as building a domain-specific language that perfectly expresses your problem space. The best programs read like well-written prose in a specialized vocabulary. Related: DataAsFoundation, LivingVocabulary

  • LivingVocabulary - Continuously evolve and refine the vocabulary used in your codebase as understanding deepens. Good vocabulary grows organically and adapts to new insights. Related: NamesAsDesign, OrganicGrowth

Collaboration Patterns

  • TechnicalCommunity - Choose development practices that emphasize technical excellence and continuous learning over process compliance. Strong technical practices create better collaboration than rigid processes. Related: SharedMind, MasterApprentice

  • SharedMind - Work closely with other developers to combine knowledge and catch each other's blind spots. Two minds working together often produce insights neither could reach alone. Related: TechnicalCommunity, BuildingBridge

  • FlowingFeedback - Structure code reviews and feedback to maintain development flow rather than creating bottlenecks. Feedback should accelerate learning, not slow down progress. Related: BuildingBridge, TightLoop

  • BuildingBridge - Respond to ideas with "Yes, and..." rather than "Yes, but..." to build on others' contributions. Constructive dialogue creates better solutions than defensive reactions. Related: SharedMind, FlowingFeedback

Learning & Expertise Patterns

  • MasterApprentice - Learn directly from experts through observation, imitation, and guided practice. The master-apprentice relationship transfers tacit knowledge that books cannot convey. Related: CraftPath, ArtisanMind

  • CraftPath - Follow a deliberate progression from novice to expert, focusing on fundamentals before advanced techniques. Mastery requires patient development of core skills. Related: MasterApprentice, ThinkingMirror

  • ThinkingMirror - Regularly reflect on your thinking processes and decision-making patterns. Self-awareness about how you think improves both learning and problem-solving. Related: ActiveReflection, InstinctiveChoice

  • ActiveReflection - Think consciously about your actions and decisions while performing them, not just afterward. Real-time reflection improves performance and builds expertise faster. Related: ThinkingMirror, PresentMoment

  • InstinctiveChoice - Develop pattern recognition that allows rapid decision-making based on experienced intuition. Expert programmers often know the right answer before they can explain why. Related: PatternHunting, ArtisanMind

Current Status

Phase 1: Foundation Patterns (In Progress)

Completed:

Next Priority:

Remaining Foundation:

Validation Results

첫 번째 패턴 TinyExperiment의 스토리 구조가 검증되어 패턴 언어로서의 가능성을 확인했습니다.

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)

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 패턴 완성 및 검증

  • 3단계 구현 전략 수립
  • Foundation 레벨 우선순위 확정

Lessons Learned

  • 전체 패턴 목록을 먼저 정리하는 것이 중요
  • 스토리 우선 접근법의 효과 확인
  • 패턴 간 연결 관계의 복잡성 인식


CategoryAiGardenProject CategoryPatternLanguage

AiGarden/ToJuniorsPatternLanguage (last edited 2025-07-24 16:15:03 by 정수)