Note: this is the second part of a mini series that I originally wrote as a newsletter titled How to Become a Better Software Developer. You can view the full table of contents here.

There are two parts to being a software developer: first, there’s the actual writing of the software (the what); second, there’s the meta stuff that surrounds this (the how). Both are important.

Getting better at the what is pretty straight forward and well-documented. If you’re fortunate enough to know by high school that you want to be a software developer (or have the bandwidth in a mid-life career change), the recommended course of action is to get a computer science degree or similar at a university. Ancillary to this, there are great courses on teaching sites like Pluralsight and Codeacademy. There are self-study books like the 4-volume set The Art of Computer Programming. There are annual developer conferences for most every major technology, language, and framework built to date. There are opportunities for continuous learning from coworkers through code reviews, lunch discussions, and pair-programming. The nitty-gritty of acquiring the skillsets to do your job is a familiar narrative. It follows similar rhythms as other professional careers, and streams of text have been written on the subject. It’s not what this mini email course is about. Instead, I want to talk about the how.

To illustrate the difference between the what and the how, let’s picture the standard advice for paper-asset-driven retirement planning. We’re advised to set aside an amount of money on a periodic basis (usually once a month or every few weeks) and invest it in a fund that we don’t plan to touch until we’re in our 60s. That’s the what. But the way we execute this plan (the how) can vary widely. Let’s say we have a preexisting fund of $0 at age 25 and invest $200 every month until we’re 65. At a 9.3% yearly return on investment, we’d have about $1 million after 40 years. In an alternate scenario, we plan to retire at the same age but this time have a preexisting fund of $25,000 at age 25. We invest this initial fund but never invest another dime. At that same 9.3% yearly return on investment, by 65 we’d also have a portfolio of about $1 million. The difference is this: in the first scenario, arriving at that $1 million retirement fund cost us $96,000 out of pocket. In the second scenario, it cost us $25,000. That’s nearly 4x less input for the same output.

If you’d known the above formula at 18, you’d have 7 years to come up with that $25,000. Which sounds harder — coming up with $300/mo for 7 years, or coming up with $200/mo for 40 years? Remember, the end result is the same, just different levels of effort to get there.

In the financial world, time serves as a major leveraging factor. In software there are similar leverages you want to be familiar with so you can use them to your advantage. In becoming a better software developer, you want your minimum input to achieve the maximum output. This gives you an indisputable, irresistible advantage. In the same way that every dollar goes 4x farther in the smarter investment scenario, so your efforts at becoming a better software developer go farther when you’ve optimized the rules of engagement and have a smarter how in place. This email course is about unlocking that advantage in practical steps.

To whet your appetite for what the target is, I’d like to share a lengthy quote from Steve Jobs which he gave during what would become known as The Lost Interview:

I observed something fairly early on at Apple, which I didn’t know how to explain then, but have thought a lot about it since. Most things in life have a dynamic range in which average to best is at most 2:1. For example if you go to New York City and get an average taxi cab driver versus the best taxi cab driver, you’ll probably get to your destination with the best taxi driver 30% faster. And an automobile; What’s the difference between the average car and the best? Maybe 20%? The best CD player versus the average CD player? Maybe 20%? So 2:1 is a big dynamic range for most things in life. Now, in software — and it used to be the case in hardware — the difference between the average software developer and the best is 50:1; Maybe even 100:1. Very few things in life are like this, but what I was lucky enough to spend my life doing, which is software, is like this. So I’ve built a lot of my success on finding these truly gifted people, and not settling for B and C players, but really going for the A players. And I found something: I found that when you get enough A players together; when you go through the incredible work to find these A players, they really like working with each other. Because most have never had the chance to do that before. And they don’t work with B and C players, so it’s self policing. They only want to hire A players. So you build these pockets of A players and it just propagates.

Where I work, there’s a slogan: “hard work beats talent.” It’s true. You aren’t born a stage 4 wizard. You become one. In terms of Jobs’ quote, going from a B or a C to an A player is achievable for those who want it, much in the same way that going from being a mediocre runner to a fast runner is achievable. The goal isn’t to win an olympic medal — that’s an elusive target — but rather to drastically improve who you are as a software developer from where you are right now. It requires hard work, and since few will make the effort, your doing so will make you stand out. For every A player there are handfuls of B and C players. Choose right now to not rest until you’re firmly in the A camp.

In the next installment we’ll look at the first game-changing shift towards becoming a better software developer. I’ll see you there!