In 9th grade, when I first learned about Lenz’s Law1 in Physics class, I was fascinated by its implications. It states:
The direction of an induced current will always oppose the motion causing it.
In simpler terms, imagine you have a hoop and a magnet. If you move the magnet close to the hoop, the hoop generates a magnetic field that pushes the magnet away. Conversely, if you pull the magnet away, the hoop creates a magnetic field that pulls it back. This occurs because the hoop aims to prevent any change in the surrounding magnetic field. That’s Lenz’s Law: the hoop consistently acts to maintain the magnetic field’s status quo, reacting against the motion that’s the cause of the existence of the magnetic flux in the first place. Generators leverage this principle to convert mechanical motion into electrical energy.
In my experience, knowledge works like this as well. The very thing that made you good at what you do often prevents you from getting better.
The first decent program I ever wrote was a simulation in MATLAB during my sophomore year. Since then, I’ve switched career gears a few times and picked up a few programming languages along the way. The weird thing is, over the years, learning new paradigms hasn’t become any easier than I thought it’d be. I only got better at grokking technologies that are woefully similar to what I already know.
Sure, picking up a new tool or library in a familiar language has become second nature, but so has the tendency to keep doing the same thing I’m somewhat good at, slightly differently, and falling into the false lull of growth. This can be perilous in the sense that, unless you actively fight it, after a decade, you might find yourself in a situation where you actually have only a year’s worth of experience repeated ten times.
I’ve been looking for a phrase to label the dilemma where the curse of knowledge, accumulated over time, prevents you from acquiring new knowledge and adopting new ways of thinking. Turns out, there’s one for that—the Einstellung effect2. Einstellung is a German word for “attitude” or “setting.” It describes a situation where we stick to a familiar way of thinking or solving problems, which can stop us from seeing or seeking easier or better solutions. This only gets worse as we start growing older or becoming more experienced in a narrow slice of a highly specialized domain.
To put it more concretely, when I learned my first proper programming language, Python, it was much easier for me to pick up the syntax, semantics, and culture around it since all that knowledge was basically getting dumped into an empty slate. When I had to pick up some JavaScript for work, it was still relatively easy since I started to compare the features of the language with the one I knew and worked my way up. However, the time it took for me to get comfortable in the JS world wasn’t that short since I was begrudgingly resisting learning about the warts of the language and complaining about how nice Python’s type system was compared to this mess!
It was only when I started to learn Go that I became aware of the warts of Python and when it just wasn’t the right tool to solve the problem at hand. Despite Go’s fame for being simple, I had to read a few books, solve a few koans, and build a few tools before I got confident in solving problems with it. One reason why it took longer is because I was trying to emulate Python idioms inside Go while at the same time bashing people who’d write Go like Java, remaining blissfully unaware of my own stance. In each of these instances, my accumulated experience and acquired predispositions actively resisted adopting different ways of solving problems.
It’s natural for us to acquire new skills by mapping them with what we already know, and that’s true for any skill—whether it’s learning to cook a new dish or writing in an unfamiliar programming language. But at the same time, as we grow older, we actively need to strain against the tide to learn to learn like kids. Because without it, we are nothing but simulacra acting as conscious exotica3, spellbound by the allure of mimicry!
Recent posts
- SSH saga
- Injecting Pytest fixtures without cluttering test signatures
- Explicit method overriding with @typing.override
- Quicker startup with module-level __getattr__
- Docker mount revisited
- Topological sort
- Writing a circuit breaker in Go
- Discovering direnv
- Notes on building event-driven systems
- Bash namerefs for dynamic variable referencing