Stop Wasting Hours on Bad Tutorials: professional-programming Is the Curated Arsenal Elite Devs Use

Stop Wasting Hours on Bad Tutorials: professional-programming Is the Curated Arsenal Elite Devs Use

The Brutal Truth About Developer Education

Let me ask you something that might sting: How many hours did you waste last month?

Not coding. Not shipping. Not solving real problems. I'm talking about the endless scroll through Medium articles promising to "transform your career in 10 minutes." The abandoned video courses at 23% completion. The bookmarked tutorials you'll "definitely read later" that now number in the hundreds.

Here's the dirty secret nobody talks about: The modern developer isn't suffering from a lack of information—they're drowning in it.

Stack Overflow has 23 million questions. GitHub hosts 200 million repositories. Every day, thousands of new "must-read" articles flood Hacker News, dev.to, and a dozen other platforms. And yet? The gap between junior and senior engineers keeps widening. Why?

Because curation beats accumulation every single time.

Enter professional-programming—a repository that's become the whispered secret among engineers who've stopped playing tutorial roulette and started building real expertise. Created by Charles-Axel Dein, this isn't another overwhelming list that buries you under links. It's a weaponized selection of resources that have genuinely transformed how elite developers think, build, and grow.

What makes this different? Abraham Lincoln's quote at the top says it all: "Give me six hours to chop down a tree and I will spend the first four sharpening the axe." This repository is your axe-sharpening station. And if you're still swinging with a dull blade, you're about to discover why the best engineers you admire seem to learn faster, code cleaner, and advance further—with what looks like less effort.

The effort isn't less. It's just directed.

What Is professional-programming? The Anti-List That Broke the Internet

professional-programming is a meticulously curated collection of learning resources for "curious software engineers"—a phrase that reveals its core philosophy immediately. This isn't for developers who want quick fixes. It's for the obsessively curious, the ones who understand that depth beats breadth and that the fundamentals transcend any framework's hype cycle.

Created by Charles-Axel Dein, a senior engineer with experience across multiple high-growth companies, this repository emerged from a simple frustration: most resource lists are comprehensive to a fault. They optimize for quantity, not impact. They include everything, which means they highlight nothing.

Dein's approach is deliberately opinionated and ruthless. The repository explicitly states it's "not meant to be comprehensive." Every inclusion must pass a brutal filter: has this resource genuinely inspired the curator, or has it become a timeless classic that continues to deliver value years after publication?

This selectivity is why professional-programming has gained traction among senior engineers who've seen technologies come and go. They recognize something rare: a curator who respects your time more than his own ego. The repository doesn't try to prove how much Dein has read. It proves how much he's thought about what actually works.

The repository's structure reveals its ambition. It spans over 80 topic areas—from algorithm fundamentals to system architecture, from career growth to incident response, from API design to the psychology of productive work. Yet within each section, you'll find perhaps five to fifteen links, not fifty. Each carries a small icon indicating its format (🧰 for resource lists, 📖 for books, ⭐️ for must-reads), and many include Dein's own contextual notes explaining why this particular piece matters.

In an ecosystem where "awesome lists" have become a genre of their own—often bloated, rarely maintained, and almost never curated with genuine expertise—professional-programming represents something almost rebellious: less, but better.

The Secret Weapons: Key Features That Separate Elite Learners

What transforms professional-programming from "another GitHub list" into an indispensable tool? Let's dissect the architectural decisions that make this repository genuinely powerful.

The "Must-Read" Stratification

The repository employs a two-tier curation system. The "Must-read books" and "Must-read articles" sections aren't afterthoughts—they're the concentrated essence. These aren't "nice to haves." These are resources Dein considers genuinely transformative, the ones that provide years of compressed experience.

Consider the book selection: The Pragmatic Programmer (described as "hands-on the most inspiring and useful book I've read about programming"), Code Complete ("gives you the necessary framework to talk about code"), Release It! ("about 3 years worth of real-world experience"), and The Linux Programming Interface (insights into "how software evolves, and the value of having simple & elegant interfaces"). Each recommendation includes a specific, memorable reason for its inclusion—not generic praise, but the concrete transformation it enables.

The Principle-Driven Philosophy

The repository opens with explicit principles that govern all inclusions:

• Lightness over comprehensiveness: "I am trying to keep it light and not too overwhelming"
• Opinionated selection: "The selection of articles is opinionated"
• Intellectual independence: "I don't necessarily agree with or endorse every single line"

This transparency builds trust. You understand the curator's lens, which lets you calibrate your own engagement. Compare this to anonymous "awesome lists" where inclusion criteria are opaque and maintenance is sporadic.

The Taxonomy of Expertise

The topic organization reveals deep systems thinking. Rather than organizing by technology (React^{↗ Bright Coding Blog}, Kubernetes, Python^{↗ Bright Coding Blog}), professional-programming organizes by capability areas that persist across technology cycles:

• Attitude, habits, mindset (including procrastination as a sub-topic)
• Buy vs. Build (technology strategy, not specific tools)
• Incident response (encompassing oncall, alerting, postmortems)
• Observability (monitoring, logging, metrics as integrated concerns)

This structure teaches something important: the problems you'll solve in year 10 of your career rhyme with year 1 problems, even when the technologies are unrecognizable.

The Living Document Model

The repository uses doctoc for automated table of contents generation, with explicit instructions: "DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE." This isn't cosmetic. It signals maintainability as a first-class concern—the same principle that separates production code from prototypes.

Four Battle-Tested Scenarios Where professional-programming Dominates

Scenario 1: The Career Transition Crisis

You're a mid-level engineer targeting senior or staff roles. You've mastered your current stack, but the promotion keeps slipping away. The feedback is vague: "needs more system thinking" or "should demonstrate broader impact."

professional-programming's weapon: The "Career growth" section, particularly "Getting to Staff Eng" with resources like Will Larson's staffeng.com guides and the FAANG Staff Engineer lessons. These aren't generic career advice—they're specific behavioral and visibility patterns that technical people often miss. The repository explicitly includes contrarian takes like "Stop Avoiding Politics" that challenge engineer instincts about "meritocracy."

Scenario 2: The Production Incident Spiral

Your team just had a 3-hour outage. The postmortem feels like blame-shifting. You're supposed to "learn from incidents" but nobody taught you how. The Five Whys feels shallow. You're writing action items that don't address root causes.

professional-programming's weapon: The "Debugging" and "Incident response" sections contain resources that fundamentally challenge common practices. John Allspaw's "The Infinite Hows" critiques Five Whys and advocates for narrative-based learning. The Saff Squeeze method provides a systematic debugging technique most engineers have never encountered. These aren't tips—they're framework upgrades.

Scenario 3: The Architecture Paralysis

Your monolith needs to split. Microservices? Modular monolith? You've read the blog posts, but they contradict each other. Every decision feels irreversible. The team is stuck in analysis while competitors ship.

professional-programming's weapon: The "System architecture" section includes Martin Fowler's data mesh evolution, the Amazon Builders' Library, and crucially, resources on when not to split (like "Microservices aren't the problem. Incompetent people are"). The "Buy vs. Build" section with "Choose Boring Technology" provides decision frameworks rather than technology prescriptions.

Scenario 4: The Skill Atrophy Trap

You've been coding for years, but something feels off. New frameworks feel harder to learn. You're cargo-culting patterns without understanding. The joy of problem-solving has faded into ticket-completion anxiety.

professional-programming's weapon: The "Attitude, habits, mindset" section is extraordinary. Kent Beck's "Mastering Programming," the "Tao of Programming," and "The Grug Brained Developer" address the psychological dimensions that technical training ignores. The inclusion of chess, sleep research, and even procrastination analysis reveals a crucial insight: sustainable excellence requires whole-person optimization, not just syntax mastery.

Your Installation Guide: How to Actually Use This Repository

Unlike tools with npm install or pip install, professional-programming requires intentional integration into your learning system. Here's how to set it up for maximum impact.

Step 1: Fork and Personalize

# Clone the repository to your own account for annotation
git clone https://github.com/charlax/professional-programming.git
cd professional-programming

# Create your own branch for personal notes
git checkout -b my-annotations

Why fork? This isn't passive consumption. The repository explicitly invites contributions via PR, but more importantly, you need your own layer of curation. What resonates with Dein won't perfectly match your context.

Step 2: Establish Your Reading Infrastructure

# Install doctoc for maintaining your own table of contents
npm install -g doctoc

# Set up a reading tracking system
# Options: Notion database, Obsidian vault, or simple Markdown↗ Smart Converter files
mkdir reading-log
cat > reading-log/template.md << 'EOF'
# Resource: [Title]
- Source: [URL]
- Date read: 
- Key insight: 
- Action item: 
- Rating (1-5): 
- Re-read date: 
EOF

The repository's icon system (🧰 📖 🎞 ⭐️ 📃) provides instant format recognition. Use this to match resources to your available energy: videos for low-focus periods, papers for deep work blocks, must-reads (⭐️) for priority scheduling.

Step 3: Implement the "One Per Week" Rule

# Create a simple scheduler
cat > reading-log/schedule.sh << 'EOF'
#!/bin/bash
# Pick one must-read (⭐️) per week from uncompleted items
# Rotate across topic areas to maintain breadth

echo "This week's focus: $(shuf -n 1 topics.txt)"
echo "Select one starred resource from this area"
EOF
chmod +x reading-log/schedule.sh

The repository's explicit goal is to be "not too overwhelming." Violate this at your peril. The curated nature enables deep engagement, but only if you actually engage deeply rather than skimming broadly.

Step 4: Build Your Synthesis Practice

# Simple script to extract your own principles from readings
# Run monthly to build personal knowledge base

import json
from datetime import datetime

def synthesize_reading(title, insights, actions):
    """
    Transform passive reading into active knowledge.
    professional-programming emphasizes 'timeless classics'—
    your synthesis should aim for the same permanence.
    """
    return {
        "source": title,
        "date": datetime.now().isoformat(),
        "core_insight": insights,  # One sentence you could teach
        "behavioral_change": actions,  # What you'll do differently
        "verification_method": "How you'll know this stuck"
    }

# Example from "Things I Learnt The Hard Way"
lesson = synthesize_reading(
    "Things I Learnt The Hard Way",
    "Future thinking is future trashing—spec first, then code",
    "Spend 30 minutes writing interface specs before any implementation"
)

print(json.dumps(lesson, indent=2))

Real Code: How professional-programming Structures Knowledge

Let's examine how the repository itself models professional practices through its construction.

Example 1: The Curated Bibliography Pattern

The "Must-read books" section demonstrates evaluative annotation—not just listing, but judging with transparency:

- 📖 [The Pragmatic Programmer: From Journeyman to Master](https://pragprog.com/titles/tpp20/): 
  hands-on the most inspiring and useful book I've read about programming.
- 📖 [Code Complete: A Practical Handbook of Software Construction](http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670): 
  a nice addition to The Pragmatic Programmer, gives you the necessary framework to talk about code.
- 📖 [Release It!](https://smile.amazon.com/Release-Design-Deploy-Production-Ready-Software/dp/1680502395): 
  this books goes beyond code and gives you best practices for building production-ready software. 
  It will give you about 3 years worth of real-world experience.

Key technique: Each annotation answers "What specific transformation does this enable?" Not "This is good" but "This gives you framework to talk about code" and "3 years worth of real-world experience." Quantified, specific value propositions.

Example 2: The Contrarian Inclusion Pattern

The "Must-read articles" section includes resources that actively challenge the reader:

- [How to be a -10x Engineer](https://taylor.town/-10x)
  - Nullify the output of 10 engineers.
  - Hold 10 engineers hostage in a technical discussion.
  - Waste 10 weeks of wages on cloud costs.
  - Waste 400 hours of engineering on bad architecture.
  - Incur 400 hours of bug triage.

Key technique: By including anti-patterns with specific, measurable damage, the repository enables negative learning—understanding what to avoid. The bullet structure makes each failure mode actionable for self-assessment.

Example 3: The Multi-Perspective Synthesis Pattern

On technical debt and architecture decisions, the repository doesn't present consensus—it curates productive disagreement:

- [Choose Boring Technology](https://boringtechnology.club/)
- [Build vs. Buy](https://entropicthoughts.com/build-vs-buy)
  - The reason we want to buy as much as possible is that an organisation has a 
    limited capacity for expertise, so we don't want to have to become experts 
    on things that don't make up a competitive advantage.
- [Platform Engineering: Build vs Buy](https://kanenarraway.com/posts/platform-engineering-build-vs-buy/)
  - If someone tells me they can build something cheaper than a vendor, 
    I'm immediately skeptical because I don't think most people can accurately 
    forecast the actual cost of maintenance in the long term.

Key technique: Three perspectives on similar decisions, each with different assumptions. The reader must engage actively rather than passively accepting "best practice."

Example 4: The Actionable Wisdom Extraction Pattern

From "Things I Learnt The Hard Way," the repository extracts immediately applicable principles:

- Spec first, then code
- Tests make better APIs
- Future thinking is future trashing
- Documentation is a love letter to your future self
- Sometimes, it's better to let the application crash than do nothing
- Understand and stay away of cargo cult
- "Right tool for the job" is just to push an agenda
- Learn the basics functional programming
- ALWAYS use timezones with your dates
- ALWAYS use UTF-8

Key technique: Each principle is binary and enforceable. You can check whether you're doing this. Contrast with vague advice like "write clean code"—these are behavioral specifications.

Advanced Usage: How Senior Engineers Actually Leverage This

The repository's power multiplies with strategic application. Here's how experienced practitioners use it differently than beginners.

The Spaced Repetition Integration

Don't read once. The "Must-read" designation exists because these resources reward re-reading. Use tools like Anki or Readwise to extract key passages for periodic review. The repository's concise annotations make excellent flashcard prompts.

The Interview Preparation Weaponization

Before system design interviews, review the "System architecture" and "Scalability" sections. But more importantly, study the framing resources like "How to Build Good Software" with its insight that "software projects rarely fail because they are too small; they fail because they get too big." This gives you interview narratives that demonstrate mature thinking.

The Team Onboarding Accelerator

New team member? Rather than overwhelming them with your codebase, assign three professional-programming resources aligned to your team's current challenges. The shared reference creates common vocabulary without forced conformity.

The Decision Documentation Template

When facing architectural decisions, use the repository's "Buy vs. Build" and related resources as pre-mortem analysis. Document not just what you decided, but which curated perspectives you considered and why your context differed.

professional-programming vs. The Alternatives: Why Curation Crushes Compilation

The decisive difference: professional-programming optimizes for reader transformation, not curator reputation or platform engagement. Every inclusion carries opportunity cost consciousness—the understanding that adding something means implicitly removing attention from everything else.

FAQ: What Developers Actually Ask

Q: Is this just for senior engineers? A: The repository serves curious engineers at all levels. Juniors benefit from the structured fundamentals; seniors gain from the career and systems-thinking resources. The key attribute isn't seniority—it's willingness to engage deeply rather than skim broadly.

Q: How often is it updated? A: The repository shows active maintenance with contemporary inclusions (agentic coding, LLM sections). However, its core value lies in timeless selections that don't require frequent updates. The curation philosophy prioritizes lasting relevance over trend coverage.

Q: Can I contribute? A: Yes, via pull request—but understand the strict filter. The maintainer explicitly states: "I will not be adding everything: as stated above, I am trying to keep the list concise." Contributions should demonstrate the same transformative quality as existing selections.

Q: What if I disagree with a selection? A: The repository explicitly anticipates this: "I don't necessarily agree with or endorse every single line that is written in every single one of those resources." Disagreement is a feature, not a bug. It forces active engagement rather than passive acceptance.

Q: How do I avoid just bookmarking and never reading? A: Implement the one-resource-per-week rule with scheduled synthesis. The repository's concision is designed to enable completion, not accumulation. If you're not finishing resources, you're using it wrong.

Q: Does it cover [specific technology]? A: Check the Topics section. The repository covers fundamental capabilities (API design, databases, testing) rather than specific frameworks. For React tutorials, look elsewhere. For understanding why APIs fail and how to prevent it, this is your resource.

Q: How does this compare to a computer science degree? A: It complements rather than replaces. The repository includes resources like "Teach Yourself Computer Science" and MIT's "Missing Semester" for foundational knowledge, but its unique value is professional practice—the craft knowledge that emerges from experience and is rarely taught formally.

The Verdict: Why Your Next Click Should Be Different

Here's what separates developers who plateau from those who compound: the quality of their information diet.

You've felt it—that moment when a resource genuinely rewires your thinking. When The Pragmatic Programmer makes you see your codebase differently. When "Release It!" prevents a production disaster before it happens. When Kent Beck's "Mastering Programming" articulates something you've intuited but couldn't express.

professional-programming is engineered to maximize these moments. Not by including everything, but by including only what generates them.

The repository's opening Lincoln quote isn't decorative—it's prescriptive. The four hours sharpening the axe aren't wasted; they're what make the two hours of chopping effective. In an industry obsessed with shipping velocity, professional-programming dares to suggest that preparation velocity matters more.

Your move. You can close this tab and return to the infinite scroll. Or you can fork the repository, pick one starred resource, and engage with it deeply this week.

The engineers you admire aren't smarter. They're not working harder. They've just stopped wasting motion on information that doesn't transform.

Start sharpening.