✍️ 필사 모드: The Developer Learning Complete Guide: New Languages, New Domains, Papers, Lifelong Learning, and AI Learning Partners (2025)

Intro — "Ten years in and there is still so much to learn"

A senior in her late 30s:

"I tried Rust again and quit for the third time. Maybe my learning ability has slipped with age."

Answer: absolutely not. Most of what feels like "declining learning ability" is actually a problem with learning method.

Research:

• Adult learning capacity really starts to decline in your late 40s
• Before that, the culprit is "lack of time plus bad methods"
• With good methods, even someone in their 60s can learn a new language

This post covers:

1. The science of learning — Carey, Oakley, Ericsson
2. Conquering a new programming language in 30 days
3. Entering a new domain (ML, Security, Finance, Embedded)
4. Reading papers — the 3-pass approach
5. Zettelkasten + Obsidian system
6. How to actually finish a technical book
7. Coursera, Udemy, bootcamp ROI
8. Using AI as a learning partner
9. Learning in your 40s–50s

Season 3 Episode 11. The last episode covered recovery from mental-health issues; this one is "how to grow from a recovered state".

Chapter 1: The Science of Learning

1.1 Cognitive Load Theory

John Sweller (1988):

• Intrinsic load: the inherent complexity of the subject
• Extraneous load: load caused by confusing explanations
• Germane load: energy spent building mental schemas

Bad instruction: lots of extraneous load. Good instruction: focuses on intrinsic, induces germane.

1.2 Desirable Difficulty (Bjork)

If it is too easy, it does not stick. A little difficulty strengthens memory.

• Spaced Repetition: Anki, Quizlet
• Interleaving: rotate topics instead of grinding one
• Retrieval Practice: pull from memory instead of rereading

1.3 Focused vs Diffuse Mode (Barbara Oakley)

Focused: concentrated study, detailed understanding. Diffuse: the brain reorganizes during rest.

You need both. The shower epiphany is diffuse mode at work.

1.4 Deliberate Practice (Anders Ericsson)

Not mere repetition:

1. Specific goal
2. Focus
3. Immediate feedback
4. Attack weaknesses
5. Uncomfortable zone

Developer example: random Leetcode grind is worse than working on weak DP problems with feedback.

1.5 The misunderstood "10,000 hour rule"

Popularized by Malcolm Gladwell. Ericsson's actual message:

"Quality, not quantity. Ten thousand hours of zoned-out practice will not make you an expert."

Chapter 2: Conquering a New Programming Language in 30 Days

2.1 30-day roadmap

Week 1: Syntax basics

• Official tutorial (Rust Book, Go Tour, TypeScript Handbook)
• Hello World, variables, conditionals, loops, functions
• 1 hour a day

Week 2: Data structures + error handling

• Arrays, lists, maps, structs
• Error-handling model (Option, Result, try/catch)
• Build a small CLI tool (JSON parser, file search, etc.)

Week 3: Concurrency + ecosystem

• The language's concurrency primitives (goroutine, async/await, tokio)
• Package manager (cargo, npm, pip, go mod)
• Skim 2–3 popular frameworks

Week 4: Real project

• Small web server or CLI project
• Write tests
• README + blog post

2.2 Recommended starter resources by language

Rust:

• The Rust Book
• Rustlings: exercises
• Project: CLI tool, ripgrep clone

Go:

• A Tour of Go
• Go by Example
• Project: web server, CLI

TypeScript:

• TypeScript Handbook
• Total TypeScript by Matt Pocock
• Project: React app, Next.js blog

Python:

• Python.org Tutorial
• Real Python
• Project: data analysis, automation scripts

2.3 Common strategies

1) Connect to what you already know:

• Rust ownership ↔ C++ RAII
• TypeScript generics ↔ Java generics
• Go interfaces ↔ duck typing

2) Learn the language-specific idioms:

• Go: "Accept interfaces, return structs"
• Rust: "Expect the Result"
• Python: "Easier to ask forgiveness than permission"

3) Read real OSS code:

• Small projects (under 10K lines)
• GitHub Trending

2.4 "Beyond Hello World"

A common mistake: replaying tutorials forever, never actually coding.

Force the issue: on day 30, publish a blog post "What I learned building X in Rust".

Chapter 3: Entering a New Domain

3.1 ML/AI

Path:

1. Linear algebra + probability basics (Khan Academy)
2. Python + NumPy + Pandas
3. Andrew Ng's Coursera (Machine Learning Specialization)
4. Fast.ai (practical)
5. Andrej Karpathy's "Zero to Hero" series (YouTube)
6. Papers with Code (reimplement)

Timeline: 6–12 months.

3.2 Security

Path:

1. Networking basics (TCP/IP)
2. Web security (OWASP Top 10)
3. HackTheBox, TryHackMe (hands-on)
4. CTF competitions
5. Bug bounty (HackerOne, BugCrowd)
6. CISSP, OSCP certs (optional)

3.3 Embedded

Path:

1. Relearn C fundamentals
2. Arduino → Raspberry Pi → STM32
3. RTOS (FreeRTOS, Zephyr)
4. Rust for embedded (recent trend)
5. Hardware (oscilloscope, logic analyzer)

3.4 Finance (Fintech, HFT)

Path:

1. Finance basics (stocks, bonds, options)
2. Time series analysis
3. C++ / Rust (low latency)
4. Book: Options, Futures, and Other Derivatives (John Hull)
5. Korea: financial certs (AICPA, CFA) — not required

3.5 DevOps/SRE

Path:

1. Linux in depth (The Linux Command Line)
2. Networking (TCP, DNS, HTTP)
3. Containers (Docker → Kubernetes)
4. Terraform / Pulumi
5. Prometheus, Grafana
6. Site Reliability Engineering (Google book)

3.6 Shared principles

• Start with small projects
• Join a community (Slack, Discord)
• Follow domain experts on Twitter
• The first 6 months feel mostly awful — that is normal

Chapter 4: Reading Papers

4.1 S. Keshav's 3-Pass Method

Pass 1 (5–10 min):

• Title, abstract, introduction
• Section headers
• Conclusion
• Skim references

→ Decide: "do I even need this paper?"

Pass 2 (1 hour):

• Understand figures and tables
• Skip deep proofs/algorithms for now
• Mark up (underline, questions)
• Note cited papers

→ Get: "what is the author claiming?"

Pass 3 (4–5 hours):

• Understand every detail
• Be able to reproduce it
• From the author's seat: "why did they choose this?"

→ Complete understanding.

4.2 Which papers first

Classic CS papers:

• Time, Clocks, and the Ordering of Events (Lamport)
• MapReduce: Simplified Data Processing (Dean, Ghemawat)
• Attention is All You Need (Vaswani et al., 2017, Transformer)
• BigTable, Dynamo, GFS

Where to find them:

• Papers We Love
• ACM Digital Library
• arXiv (latest)
• The Morning Paper (Adrian Colyer's summaries)

4.3 Paper reading groups

• Internal company study group
• Twitter/X paper club
• Discord reading group

Ten times more sustainable than solo reading.

4.4 Reading papers with AI

• Claude/ChatGPT: summarize abstracts, explain stuck parts
• Semantic Scholar: related-paper recommendations
• Connected Papers: visual connections
• Elicit: paper search for specific questions

Chapter 5: Zettelkasten and Obsidian

5.1 What is Zettelkasten

Niklas Luhmann (sociologist; 90,000 notes over 70 years):

• Atomic notes (one idea = one note)
• Unique IDs
• Bidirectional links
• Flat, non-hierarchical tags

5.2 Why Obsidian

• Markdown (portable)
• Local storage (no cloud dependency)
• Bidirectional links
• Rich plugin ecosystem
• Free

5.3 Basic structure

Folders:

00_inbox/       # new notes
10_zettels/     # permanent notes (atomic)
20_literature/  # paper/book summaries
30_daily/       # daily entries
90_attachments/ # images

Note template:

---
id: 20250108-spaced-repetition
tags: [learning, memory, science]
source: [[book-make-it-stick]]
---

# The principle of spaced repetition

Long intervals between reviews are more effective
for long-term memory than short intervals.

## Why

- Re-exposure right before forgetting creates the strongest signal
- Spacing effect (Ebbinghaus, 1885)

## Links

- [[deliberate-practice]]
- [[anki-workflow]]

5.4 Daily notes

Daily Note: one file per day.

• What I learned today
• Interesting links
• Questions

Promote to permanent notes during the weekly review.

5.5 Plugin recommendations

• Dataview: DB-style queries
• Templater: template automation
• Kanban: task board
• Excalidraw: hand-drawn diagrams
• Obsidian Sync or git sync

5.6 Compared with Notion

Obsidian strengths: personal knowledge, offline, ownership. Notion strengths: collaboration, databases, sharing.

Use both: Obsidian for personal notes, Notion for team work.

Chapter 6: How to Actually Finish a Technical Book

6.1 "Finishing" is not the goal

Most technical books are reference material. Reading cover to cover is wasteful.

6.2 Adler's four levels from How to Read a Book

1. Elementary: reading the words
2. Inspectional: skimming (TOC, preface, conclusion)
3. Analytical: detailed analysis
4. Syntopical: comparing multiple books

6.3 Strategy for technical books

Level 1: Inspectional (1 hour):

• Preface, TOC, first/last paragraph of each chapter
• "What can I get out of this book?"

Level 2: Selective (5–20 hours):

• The 3–5 chapters relevant to you
• Work through the examples

Level 3: Deep (50–100 hours):

• Full read with all exercises
• Blog series
• Study group

6.4 Classics guide

SICP (Structure and Interpretation of Computer Programs):

• MIT's legendary textbook
• CS fundamentals through Scheme
• MIT 6.001 lectures (YouTube)
• 6+ months

CLRS (Introduction to Algorithms):

• The definitive algorithms book
• Not meant to be read cover to cover
• Use as a reference

DDIA (Designing Data-Intensive Applications):

• Must-read for distributed systems
• Read it and blog about it — strongly recommended
• Six months is fine

Operating Systems: Three Easy Pieces:

• Free OS textbook
• Practical and fun
• OSTEP.org

The Pragmatic Programmer:

• Early-career essential
• 20th anniversary edition

6.5 Skim vs deep read

Heavy with code/math = deep read. Essay/perspective books = skim is fine.

6.6 How to not forget what you read

1. Annotation: underline and margin notes
2. Summary notes: one-page summary per chapter
3. Blog: public writeup
4. Teach: study group
5. Apply: use it in actual code

Chapter 7: Online Courses — Coursera, Udemy, Bootcamps

7.1 Coursera

• University grade (Stanford, Yale, Princeton)
• Certificates (some free)
• Structured
• Lots of homework (actual learning)
• Recommendations: Andrew Ng (ML), Princeton Algorithms, Robert Sedgewick

7.2 edX

• MIT- and Harvard-centric
• MicroMasters programs
• Practical plus academic

7.3 Udemy

• Single purchase (often on sale for 10–20 USD)
• Practical, short-form
• Quality varies a lot
• Recommendations: Stephen Grider, Maximilian Schwarzmüller

7.4 Pluralsight / O'Reilly Learning

• Corporate subscription (often employer-sponsored)
• Broad tech coverage
• Consistent quality

7.5 Bootcamps

Korea:

• Woowa Tech Course (Woowa Brothers, free, 7 months)
• Naver Boostcamp (free)
• SSAFY (Samsung, paid stipend)
• Hanghae99, Code States (paid)

US:

• Hack Reactor
• App Academy
• Bloom Institute (ISA model)

Effectiveness:

• Bootcamp placement rate in Korea: 70–90 percent
• Intense 6–12 months
• Faster than self-study, but expensive

7.6 ROI analysis

Free path: CS50 + The Odin Project + OSS contributions (unbeatable value). Paid courses: 10–20 Udemy courses total (200–500 USD). Bootcamp: Korea free–10M KRW, US 10K–20K USD.

Choice criteria:

• Whether you can self-teach
• Time-to-employment needed
• Budget
• Network value

Chapter 8: AI as a Learning Partner

8.1 Wrong uses

• Immediately asking for the answer → copy-paste without understanding
• Having AI write every piece of code → growth stalls
• Trusting AI output without verification → hallucinations

8.2 Good uses

1) Socratic questioning:

Prompt: "I am learning Rust ownership. Quiz me.
If I answer correctly, ask a harder question next.
If I get it wrong, just explain."

2) Explanation requests:

"Explain what each line of this CSS is doing."
"Explain why this SQL query is slow given this EXPLAIN output."

3) Understanding checks:

"I will describe what I think I understand.
Point out what is wrong: [my explanation]"

4) Pattern comparison:

"Differences between Rust's Result and Go's error returns?"

5) Brainstorming:

"Give me 3 weaknesses of this architecture and 2 alternatives."

8.3 Effective prompt templates

Learning by teaching:

"I want to explain [X] to [Y]. Pick the 5 concepts I need to know,
and explain each with an analogy suited to [age/level]."

Deliberate Practice:

"In [topic], my weak areas are [A, B, C]. Give me 10 problems that
attack these weaknesses, in increasing difficulty. After each problem,
provide hint first, then answer."

8.4 Knowing AI's limits

• May lack the latest information
• Hallucinations (confidently wrong)
• Sometimes shallow on deep expertise

Verify: cross-check against official docs, authoritative books, and the community.

8.5 AI in the IDE

• GitHub Copilot: real-time autocomplete
• Cursor: chat + refactor
• Continue: open source
• Claude Code / CodeWhisperer / Gemini: agentic coding

Learning tip: turn copilot off, try on your own, then turn it on and compare. Avoid pure copy-paste.

Chapter 9: Learning in Your 40s and 50s

9.1 Age and learning

Research:

• Raw acquisition of new info slows (10–20 percent vs your 20s)
• Speed of making connections rises (more experience)
• Net result: on complex problems, the older engineer is often faster

9.2 Shift in strategy

Quantity to quality:

• Not 4 hours a day on new tech
• Instead: 1 hour a day + tying it to existing experience

Deeper T-shape:

• Go deeper in one area rather than wider
• e.g., Staff Engineer → Specialist Principal

Learn by teaching:

• Mentoring juniors
• Tech blog
• Conference talks

9.3 Health is the foundation

• Sleep is core to learning (memory consolidation)
• Exercise → BDNF (brain-derived neurotrophic factor)
• Mediterranean diet

9.4 Real examples

• Andrew Tanenbaum: still revising OS textbooks in his 70s
• Leslie Lamport: 80s, still working on TLA+
• Bjarne Stroustrup: 70s, still evolving C++
• Alan Kay: 80s, still designing new languages

9.5 Traps

• "I have to keep up with the kids" panic → sacrificing health
• "I already know it all" arrogance → stagnation
• "Too old to learn" surrender → quitting

Chapter 10: Learning Communities

10.1 Korean developer communities

• OKKY: the classic Q&A board
• Inflearn: courses plus community
• GeekNews: news sharing
• Disquiet: startup founding/building
• Newneek / Slowletter: tech newsletters

10.2 Study groups

Online:

• Discord study servers
• Live coding streams (e.g., Miku's Live)

Offline:

• Seoul: Gangnam/Pangyo developer meetups
• Outside Seoul: regional IT communities

Formats:

• Book club (one chapter per week)
• Algorithms (two problems per week)
• Projects (3-month cycles)

10.3 Global communities

• Hacker News: news and discussion
• Reddit r/programming, r/experienceddev
• Dev.to
• Stack Overflow (declining but still useful)

10.4 Conferences

• Learning accelerator
• Network
• Motivation

One to two per year is a good target.

Chapter 11: Lifelong Learning Routine

11.1 Daily

• News: 15 minutes (TLDR, scan Hacker News)
• Reading: 30 minutes (tech book or paper)
• Practice: write/review real code

11.2 Weekly

• One blog post per week (or personal note)
• One study group meeting per week
• Weekly Review

11.3 Monthly

• Start or finish one new book/course per month
• One OSS contribution per month
• One coffee chat with a tech peer per month

11.4 Quarterly

• One side project per quarter (skill experiment)
• One tech talk or presentation per quarter
• Re-evaluate interests once per quarter

11.5 Yearly

• Seriously learn 1–2 new domains/techs per year
• One conference per year
• Annual skill inventory + plan for the next year

Chapter 12: 12-Item Learning Checklist

• Daily reading: at least 30 minutes secured
• Daily practice: code something new, even a little
• Note system: Obsidian/Notion
• Spaced Repetition: Anki or similar
• Study group: at least one
• Blog: 1+ post per month
• OSS contributions: at least one per quarter
• Mentor: at least one senior
• Mentee: at least one junior
• Conferences: at least one per year
• Goal setting: three quarterly learning goals
• Review ritual: weekly/monthly/yearly

Chapter 13: Ten Learning Anti-patterns

1) Tutorial hell

Endlessly replaying beginner tutorials, never starting a real project. Real projects are real learning.

2) Book hoarding

Buying dozens of tech books and finishing zero. Finishing one beats owning ten.

3) Tool-setup addiction

Two weeks polishing Obsidian templates. Zero actual learning. Tools 10 percent, learning 90 percent.

4) "Next year I will learn it"

Updating the list every year, never executing. Start 30 minutes today.

5) Multi-start

Starting Rust, Go, and Elixir at once. Dropping all three. Finish one, then the next.

6) YouTube-only

Passive lecture watching, no coding. Passive is worse than active.

7) "I will code once I fully understand"

Waiting for 100 percent comprehension. Never starts. Get to 50 percent, then practice.

8) Not sharing

Keeping learnings to yourself. No feedback. Share through blog/conversation.

9) Avoiding hard things

Sticking to easy material. No growth. Desirable Difficulty.

10) "Too old for that"

Self-limiting. The brain can still learn in its 60s. Age is an excuse.

Closing — Lifelong Learning Is an Engineer's Fate

Principle 1: Small, daily

30 minutes a day for 5 years beats 10 hours every weekend for a month.

Principle 2: Teach while learning

Blog, mentor, speak — the fastest growth path.

Principle 3: Community beats solo

A group beats going alone. Motivation, feedback, fun.

Principle 4: Health is the foundation

Sleep, exercise, nutrition. Without them the brain does not function.

Principle 5: Tools are means

Do not over-engineer your system. Simplicity is powerful.

Principle 6: Read the originals

• A Mind for Numbers - Barbara Oakley
• Make It Stick - Brown, Roediger, McDaniel
• How to Read a Paper - S. Keshav (free PDF)
• Learning How to Learn - Coursera (Barbara Oakley)
• How to Read a Book - Mortimer Adler
• Peak - Anders Ericsson

Next up — "Developer Networking and Branding: A Practical Guide Even for Introverted Developers"

Season 3 Ep 12 will cover:

• The science of networking (the strength of weak ties — Granovetter)
• Networking strategies for introverted developers
• LinkedIn profile optimization
• Harmonizing Twitter/X, LinkedIn, and GitHub
• How to make the most of conferences, meetups, and study groups
• Creating speaking opportunities
• Building a global network (English-speaking world)
• Leveraging the Korean developer community
• The ethics of personal branding
• Networking anti-patterns

See you next time.