|
Size: 11331
Comment:
|
Size: 5209
Comment:
|
| Deletions are marked like this. | Additions are marked like this. |
| Line 3: | Line 3: |
| = AiGarden/ToJuniorsPatternLanguage = | = 영원의 기예: 생각하는 개발자의 길 = |
| Line 5: | Line 5: |
| 주니어 개발자들을 위한 프로그래밍 피드백을 Christopher Alexander의 패턴 언어로 변환하는 프로젝트. | ''주니어 개발자들을 위한 패턴 언어 - 35개의 실천적 중심이 엮어내는 성장의 서사'' 소프트웨어는 미리 정해진 설계도대로 조립되는 결과물이 아니라, 개발자의 인식과 코드의 언어가 조화를 이루며 씨앗으로부터 자라나는 것입니다. 이 패턴 언어는 그 생명력을 유지하며 시스템을 키워가는 과정을 담고 있습니다. |
| Line 9: | Line 11: |
| == Project Vision == | == 제1장: 명료한 인식 (Clear Perception) == |
| Line 11: | Line 13: |
| [[기술문서모음/ToJuniors]] 문서의 패턴들을 Alexander의 패턴 언어 형식으로 변환하여 구조적이고 교육적인 자료로 발전시키는 것이 목표입니다. | 프로그래밍은 단순한 지식의 적용을 넘어 숙련된 감각이 필요한 '''[[ArtisanMind|기예]]'''입니다. 개발자는 자신의 고정관념에 속지 않고 '''[[PresentMoment|지금 이 순간]]''' 시스템에서 실제로 일어나는 사실을 있는 그대로 보아야 합니다. |
| Line 13: | Line 15: |
| === Core Principles === * '''Structure-Preserving Baby Steps''' - 기존 구조를 보존하며 점진적 발전 * '''Story-First Approach''' - 스토리로 시작해서 패턴으로 추상화 * '''Educational Focus''' - 학습자 중심의 명확한 설명 * '''Pattern Language Structure''' - Alexander 방식의 체계적 연결 |
복잡한 현상에 매몰되지 않으려면 '''[[SingleFocus|한 번에 한 가지]]''' 목표에만 집중해야 하며, 자신의 사고 과정을 '''[[CognitiveMicroscope|인지 현미경]]'''으로 들여다보듯 세밀하게 관찰할 때 비로소 전문성이 쌓이기 시작합니다. |
| Line 19: | Line 17: |
| == Pattern Inventory == | == 제2장: 언어와 이론 (Language and Theory) == |
| Line 21: | Line 19: |
| === 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|문제 공간과 해결 공간]]'''을 명확히 구분해야 합니다. 기술적인 도구를 고르기에 앞서 잘 정리된 '''[[DataAsFoundation|데이터를 기반]]'''으로 삼아 구조의 중심을 잡습니다. |
| Line 25: | Line 21: |
| * '''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'' | 우리는 추상적인 개념을 다루기 위해 '''[[MetaphorThinking|은유를 통해 사고]]'''하고, 적절한 이름을 붙이는 '''[[NamesAsDesign|이름 짓기를 설계 활동]]'''으로 수행하며 우리만의 '''[[LanguageBuilding|도메인 언어를 구축]]'''합니다. 이 언어는 시스템의 변화에 맞춰 '''[[LivingVocabulary|살아있는 어휘]]'''로 진화해야 하며, 이렇게 언어가 바로 설 때 비로소 거대한 '''[[ComplexityTaming|복잡성을 길들일]]''' 수 있습니다. |
| Line 27: | Line 23: |
| * '''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'' | == 제3장: 실행의 리듬 (The Rhythm of Execution) == |
| Line 29: | Line 25: |
| * '''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'' | 소프트웨어에 생명력을 불어넣는 것은 멈추지 않는 리듬입니다. 완벽한 설계에 매몰되기보다 '''[[WorkingFirst|일단 작동하는 것]]'''을 먼저 만들고, 불확실한 지점에서는 '''[[TinyExperiment|작은 실험]]'''을 수행하며 1초 이내에 결과를 확인하는 '''[[TightLoop|촘촘한 피드백 루프]]'''를 유지합니다. |
| Line 31: | Line 27: |
| * '''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'' | 안전한 전진을 위해 '''[[BabySteps|작은 보폭]]'''을 유지하며, 각 단계의 완료를 '''[[AtomicCommit|원자적인 커밋]]'''으로 기록합니다. 가설을 세울 때는 '''[[ShortLeash|추측의 끈을 짧게 쥐고]]''' 수시로 검증하며, 실패했을 때는 즉시 안전한 '''[[GreenRefuge|초록색 피난처]]'''로 돌아옵니다. 마지막 5%의 자동화에 집착하지 않는 '''[[The95PercentRule|95%의 규칙]]'''은 실무적인 효율성을 지켜줍니다. |
| Line 33: | Line 29: |
| === 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'' |
== 제4장: 유기적 성장 (Organic Growth) == |
| Line 36: | Line 31: |
| * '''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'' | 리듬을 탄 시스템은 하나의 생명체처럼 자라납니다. 무질서한 확장이 아니라 가장 본질적인 가치를 담은 '''[[StrongCenter|강한 중심]]'''에서 시작해 바깥으로 펼쳐 나가는 '''[[OrganicGrowth|유기적 성장]]'''을 지향합니다. |
| Line 38: | Line 33: |
| * '''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'' | 시스템을 키워가는 과정에서 불필요한 레이어를 걷어내고 문제에 직선으로 다가가는 '''[[DirectPath|직선 경로]]'''를 유지하십시오. 성장의 용기를 주는 것은 언제나 작동함을 보장하는 '''[[SafetyNet|안전망]]'''이며, 의존성을 끊어낸 '''[[CleanIsolation|깨끗한 격리]]'''를 통해 각 부분을 유연하게 유지해야 합니다. |
| Line 40: | Line 35: |
| * '''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'' | == 제5장: 공동체의 지혜 (Collective Wisdom) == |
| Line 42: | Line 37: |
| * '''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'' | 개인의 기예는 공동체 안에서 비로소 완성됩니다. 서로의 실력을 존중하는 '''[[TechnicalCommunity|기술 공동체]]''' 안에서, 두 명의 지혜를 하나로 모으는 '''[[SharedMind|공유된 정신]]'''을 실천합니다. |
| Line 44: | Line 39: |
| * '''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'' | 우리는 대화의 '''[[BuildingBridge|다리를 놓고]]''', 강물처럼 '''[[FlowingFeedback|흐르는 피드백]]'''을 통해 함께 성장합니다. 앞서간 이로부터 '''[[MasterApprentice|암묵지를 전수받으며]]''' 자신만의 '''[[CraftPath|성장 경로]]'''를 걷습니다. |
| Line 46: | Line 41: |
| * '''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'' | 이 여정 속에서 우리는 수많은 '''[[PatternHunting|패턴을 사냥]]'''하고, '''[[DetectiveWork|탐정의 수사]]'''처럼 버그를 추적하며, '''[[RootHunting|근본 원인을 찾아]]''' 제거합니다. 이러한 반복은 결국 데이터에 기반한 '''[[InstinctiveChoice|직관적인 선택]]'''을 가능하게 합니다. |
| Line 48: | Line 43: |
| * '''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:''' * [[TinyExperiment]] ✓ - 패턴 언어 형식으로 완성, 검증됨 '''Next Priority:''' * DataAsFoundation - 로직 단순화의 핵심 * TwoWorlds - 사고 체계의 기본 '''Remaining Foundation:''' * WorkingFirst, ArtisanMind, The95PercentRule === 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) === * 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 패턴 완성 및 검증 * 3단계 구현 전략 수립 * Foundation 레벨 우선순위 확정 === Lessons Learned === * 전체 패턴 목록을 먼저 정리하는 것이 중요 * 스토리 우선 접근법의 효과 확인 * 패턴 간 연결 관계의 복잡성 인식 |
우리는 매일의 작은 호기심을 '''[[TinyResearch|5분 연구]]'''로 채우고, 수행하는 순간을 '''[[ActiveReflection|실시간으로 성찰]]'''하며, 하루의 끝에서 자신의 사고 과정을 '''[[ThinkingMirror|거울에 비추어]]''' 봅니다. 이 모든 실천이 하나로 엮일 때, 당신은 지속 가능한 소프트웨어를 만드는 성숙한 개발자가 됩니다. |
영원의 기예: 생각하는 개발자의 길
주니어 개발자들을 위한 패턴 언어 - 35개의 실천적 중심이 엮어내는 성장의 서사
소프트웨어는 미리 정해진 설계도대로 조립되는 결과물이 아니라, 개발자의 인식과 코드의 언어가 조화를 이루며 씨앗으로부터 자라나는 것입니다. 이 패턴 언어는 그 생명력을 유지하며 시스템을 키워가는 과정을 담고 있습니다.
Contents
제1장: 명료한 인식 (Clear Perception)
프로그래밍은 단순한 지식의 적용을 넘어 숙련된 감각이 필요한 기예입니다. 개발자는 자신의 고정관념에 속지 않고 지금 이 순간 시스템에서 실제로 일어나는 사실을 있는 그대로 보아야 합니다.
복잡한 현상에 매몰되지 않으려면 한 번에 한 가지 목표에만 집중해야 하며, 자신의 사고 과정을 인지 현미경으로 들여다보듯 세밀하게 관찰할 때 비로소 전문성이 쌓이기 시작합니다.
제2장: 언어와 이론 (Language and Theory)
현실의 문제를 코드로 옮기기 위해서는 먼저 문제 공간과 해결 공간을 명확히 구분해야 합니다. 기술적인 도구를 고르기에 앞서 잘 정리된 데이터를 기반으로 삼아 구조의 중심을 잡습니다.
우리는 추상적인 개념을 다루기 위해 은유를 통해 사고하고, 적절한 이름을 붙이는 이름 짓기를 설계 활동으로 수행하며 우리만의 도메인 언어를 구축합니다. 이 언어는 시스템의 변화에 맞춰 살아있는 어휘로 진화해야 하며, 이렇게 언어가 바로 설 때 비로소 거대한 복잡성을 길들일 수 있습니다.
제3장: 실행의 리듬 (The Rhythm of Execution)
소프트웨어에 생명력을 불어넣는 것은 멈추지 않는 리듬입니다. 완벽한 설계에 매몰되기보다 일단 작동하는 것을 먼저 만들고, 불확실한 지점에서는 작은 실험을 수행하며 1초 이내에 결과를 확인하는 촘촘한 피드백 루프를 유지합니다.
안전한 전진을 위해 작은 보폭을 유지하며, 각 단계의 완료를 원자적인 커밋으로 기록합니다. 가설을 세울 때는 추측의 끈을 짧게 쥐고 수시로 검증하며, 실패했을 때는 즉시 안전한 초록색 피난처로 돌아옵니다. 마지막 5%의 자동화에 집착하지 않는 95%의 규칙은 실무적인 효율성을 지켜줍니다.
제4장: 유기적 성장 (Organic Growth)
리듬을 탄 시스템은 하나의 생명체처럼 자라납니다. 무질서한 확장이 아니라 가장 본질적인 가치를 담은 강한 중심에서 시작해 바깥으로 펼쳐 나가는 유기적 성장을 지향합니다.
시스템을 키워가는 과정에서 불필요한 레이어를 걷어내고 문제에 직선으로 다가가는 직선 경로를 유지하십시오. 성장의 용기를 주는 것은 언제나 작동함을 보장하는 안전망이며, 의존성을 끊어낸 깨끗한 격리를 통해 각 부분을 유연하게 유지해야 합니다.
제5장: 공동체의 지혜 (Collective Wisdom)
개인의 기예는 공동체 안에서 비로소 완성됩니다. 서로의 실력을 존중하는 기술 공동체 안에서, 두 명의 지혜를 하나로 모으는 공유된 정신을 실천합니다.
우리는 대화의 다리를 놓고, 강물처럼 흐르는 피드백을 통해 함께 성장합니다. 앞서간 이로부터 암묵지를 전수받으며 자신만의 성장 경로를 걷습니다.
이 여정 속에서 우리는 수많은 패턴을 사냥하고, 탐정의 수사처럼 버그를 추적하며, 근본 원인을 찾아 제거합니다. 이러한 반복은 결국 데이터에 기반한 직관적인 선택을 가능하게 합니다.
우리는 매일의 작은 호기심을 5분 연구로 채우고, 수행하는 순간을 실시간으로 성찰하며, 하루의 끝에서 자신의 사고 과정을 거울에 비추어 봅니다. 이 모든 실천이 하나로 엮일 때, 당신은 지속 가능한 소프트웨어를 만드는 성숙한 개발자가 됩니다.