Tech is a field of constant learning.
As programmers, our job is to solve problems we haven’t quite seen before.
And the languages and libraries we use change—fast. An eight month hiatus from coding, on average, would make our API-specific knowledge obsolete.
So we’re constantly updating, upgrading, broadening, and deepening our skill sets.
And for us, formal education is particularly inapplicable.
Computer science degrees, while valuable for background, are notoriously not adequate preparation for software development. Many of them barely cover API design, conventions, architecture, or (god forbid) testing. Developers joke about the O(n) notation question in the Google phone screen being the only time they have used their CS degrees at work. I suspect that question is the result of some Google Engineers sitting around thinking “How can our interview make sure people have CS degrees?” So even this application of the thing is rather tautological.
Some companies offer tests with certificates for C, Java, Spring ,or Android. You pay (a lot) to take these tests and to obtain the associated teaching materials, usually books. The books cover syntax, which is marginally helpful, and tangential information, which is decidedly unhelpful.
Example question from a Spring certification: how many libraries are in the core Spring package? The answer to this question is utterly irrelevant to writing a Spring app.
The books and tests still don’t cover application architecture, refactoring, or programming for humans. And still, of course, nary a word about testing.
So to build relevant job skills, we have to find the answers ourselves.
Googling is absolutely a skill. Choosing the best answer from a barrage of StackOverflow suggestions is also a skill. But these are scattershot skills: you use them in very specific circumstances, and any one bug fix does not necessarily level up your overall approach to building software.
In order to level up, we need habits and exercises that help us comprehensively improve our skills.
Level up is a term of art among tech people. We got the term from role-playing games in which leveling up means that your character gets better stats, hit points, and spells.
For a long time, I did not know this.
I found out what people meant by level up about three and a half years into my programming career when I played my first game of Dungeons and Dragons. I had heard the term before, but I thought about it quite differently. I’ll share my interpretation with you because I think it is useful.
It sounds like most folks picture leveling up as a little avatar of themselves advancing up a ladder of 20 levels, moving up to the next rung incrementally as they gain experience. This creates this visual of our skills improving linearly with our time spent in tech. I’ll henceforth call this the ladder interpretation.
The ladder interpretation was new to me after three and a half years in tech.
I pictured, instead, what I will call the derivative interpretation. It comprises a series of maybe three levels.
Level One: Getting better, adding skills
Level Two: Improving at getting better/adding skills
Level Three: Getting better techniques for improving at getting better/adding skills
To me, each level represents the derivative of the level below it.
In mathematics, the derivative of a function describes how fast it changes.
So a flat line has a derivative of zero: if there is no improvement or adding skills, our skill level stays the same (skill development is zero).
A line that points upward has a derivative of some constant: the same ability to develop skills forever means that skill advances linearly.
A line whose derivative is some linear function, though, looks like this:
It’s a quadratic function, and as you can see, it gets steeper and steeper as we move to the right. So if our ability to get better and add skills is improving at a constant rate, then our actual skill set improves at a faster and faster rate.
All this time before I played Dungeons and Dragons, I thought “leveling up” meant focusing on the next level up of skill development. In the very beginning, you’re focused on learning the basics of a language. But then, with a little experience, you “level up” and focus instead on learning techniques for learning more about the language. Then later you “level up” again and focus in iteratively developing better strategies for learning more about the language.
And here’s why I think it’s useful: in the ladder interpretation, our skills improve linearly with our time in the game. But in the derivative interpretation, we create opportunities for our skills to improve faster and faster: by focusing on the next level up of skill improvement, we accelerate the rate at which our programming abilities change.
So, for three and a half years, this is exactly what I was trying to do.
I got a notebook and started experimenting with comprehensive, high-bandwidth techniques for improving my skills. In the process, I came up with some things that really, really accelerated my skill development. I would like to start sharing those techniques with you.
Whether you are a new programmer with just a little app development experience or a seasoned veteran looking to make a breakthrough that will forever bear your name, I think these techniques have a place in your repertoire. So this will be the start of a new series, and I’ll share each technique in its own post with examples.
Before we begin, I want to give you the opportunity to prepare the way that I prepared.
Consider Getting a Notebook
For almost all of the techniques I use, I have some accompanying exercises and record-keeping that I do in a college-ruled journal that I have carried to every day of my job for years. It has been the same journal the whole time because I write very, very tiny, so I get the privilege of looking back on my work from years ago and seeing how much I’ve grown. You could have that to look forward to!
But in the meantime, I recommend picking up a journal and pen that you will enjoy using. The next post in the series will cover our first technique for leveling up our programming skills.