The punk rock guide to learning - embrace productive discomfort with programming languages

A few months ago, I put my comfortable Python stack into statis and switched to Clojure. Not because it was “better” - but because sometimes the best way to level up is to burn your safety net. Here’s what I learned about the psychology of productive discomfort.

Why Language Comfort is Overrated

Your expertise is killing you.

I’ve spent 10+ years getting good at Python. Really good. The kind of good where you stop looking things up, where list comprehensions flow from muscle memory, where you know exactly which library solves which problem. That mastery became handcuffs.

The hidden cost of expertise is that you stop really thinking. Your brain runs on rails, following the same neural pathways it carved years ago. You’re not solving problems anymore - you’re pattern-matching against your cache of previous solutions.

The moment you can’t remember the last time you felt stupid writing code, you’ve stopped growing.

The DIY Approach to Language Migration

Forget bootcamps. Build your own learning infrastructure. Every major pattern I knew in Python, I rebuilt in Clojure. Side by side. Same problem, different paradigm. It became my own Rosetta Stone of code.

Project Euler became my dojo. Project Rosalind my lab. Each problem solved twice - once in comfortable Python, once in alien Clojure. Problem 1 in Python: three lines. In Clojure: wrestling with parentheses for an hour. By the 7th, I was getting the hang of s-expressions. Data is code, and code is data!

/learning-monorepo
  /euler
    /problem-001
      solution.py
      solution.clj
  /rosalind
    /dna-counting
      solution.py
      solution.clj

AI became my learning partner - not to write code for me, but to explain why Clojure developers think differently. “What’s so bad about loops anyway?” “What’s this obsession with immutability getting us?” Claude became my cultural translator, not my crutch.

The key: Don’t just learn Clojure, learn how Clojure developers think and why. The parentheses are trivial; the functional philosophy is everything.

Embracing Productive Confusion

William Gibson wrote cyberpunk on a typewriter because he didn’t understand computers. That distance created Neuromancer.

There’s power in not knowing. When you can’t rely on fluency, you’re forced to think from first principles. Every line becomes deliberate. You can’t autopilot through problems.

I started using placeholder code as scaffolding:

(defn calculate-user-score [user]
  ; I have no idea how to think functionally about this yet
  ; But I know what transformation needs to happen
  nil)

The placeholders became my map. I knew where I was going before I knew how to get there. Gibson calls it “the art of not knowing” - building the future from productive ignorance.

Making peace with being a beginner means admitting that your 10 years of experience might actually be 10 years of assumptions. The discomfort of starting over isn’t a bug - it’s the whole point.

Stop Treating Languages Like Relationships

Languages aren’t identities. They’re tools.

You’re not a “Python developer” or a “Clojure developer.” You’re not just a programmer or software engineer. You’re a problem solver who happens to use code to solve problems. The moment you attach your identity to a syntax/grammar, your growth asymptote == your chosen language’s expressiveness. You can approach it, but never transcend it.

This week, pick a less favourite (ahem) language and solve Project Euler problem 23 (my dad loves Perfect Numbers, so I have a soft spot for this one). Or tackle another little challenge. Use real problems, and come up with multiple solutions. Compare your comfortable approach with your uncomfortable one.

The goal isn’t to become fluent or even good. It’s to remember what it feels like to think again. To struggle with simple things. To delete your muscle memory and rebuild from scratch.

The discomfort is the point. That’s where growth lives.

inspired by learning about Lorem Gibson, I Am Switching to Python and Actually Liking It, Project Euler, and Project Rosalind*