Tough Love

One of the first things that a journeyperson programmer will have to learn when they transition from full time student to working developer is that things in the real world are never as cut and dry as their classes may have made it seem. At the end of the day, software is not written because we love building castles of logic in the sky, it’s written to solve a real problem. That might seem like a trite observation, but it explains almost everything you observe as a working developer.

Because perfection isn’t profitable, real world applications are developed under less than ideal circumstances, often under intense pressure, and with inevitable compromises. Large applications sprawl, get messy, and develop stagnant corners and scary basements. Questionable or just plain puzzling decisions are made by developers without explanation, justification, or documentation by developers who then leave the company, never to be seen or heard from again. Most junior developers are scared of making mistakes - imagine their surprise when they find themselves working on something that was written by another junior developer who did, in fact, make some major mistakes - mistakes that are now their responsibility to fix.

Some recommended reads at this stage:

• The Number One Trait of a Great Developer opens a new window
• Every app has a scary basement opens a new window
• A Taxonomy for “Bad Code Smells” opens a new window
• The Law of Leaky Abstractions opens a new window

Social Skills

People who don’t work in the software industry are often surprised to hear just how intensely sociable it is. Despite internet and software services being a major, established part of people’s everyday lives for two decades at this point, the old stereotype of the asocial programmer still has major cultural currency. Rest assured, if you’re thinking of programming as a career because you think you’ll get to sit in front of your computer and never have to deal with people, you have definitely picked the wrong field. Another hard truth here is that technical competency, no matter how high level, is still a commodity - no matter how good you are, there are plenty of other developers out there who are at least that good. Thus the old saw about it not being what you know, but who you know, is still true even in a supposedly knowledge oriented field. Also, keeping your skills up to date will mean more than a few conferences and user group meetups throughout your career - events that are, by default, social events. Be prepared to do a lot of (human to human) networking.

On a more day to day level, a developer who can’t communicate clearly and professionally with their peers and co-workers is not going to keep their job for long. Good developers command good salaries, but good salaries always come with expectations attached, and one of those will always be that you can work well in a team and communicate with others. If someone’s going to pay you all of that money, they’ll expect a lot of transparency in return. And that expectation will only grow as you acquire more and more experience. Your experience will have value, and your employers will expect you to share that value with those around you by coaching and mentoring teammates, without stepping on any toes in the process.

Some more recommended reads:

• How to Write a Git Commit Message opens a new window
• Technical Debt Isn’t Just Technical opens a new window (communication solves a lot of problems up front!)
• The Developer’s Edge: How To Become A Senior Developer opens a new window (notice how few of these skills are technical!)

Stay Humble

It won’t take long for a newly minted developer to learn that there are plenty of developers who have a bit of an ego problem. Aside from the obvious problems that this can cause with teamwork and professional behavior, losing perspective in this way can lead to skills starting to stagnate. When you take on a job as a developer, whether you realize it or not, you’re implicitly taking on another responsibility - the responsibility of always being a student. The biggest difference between a newbie developer and a seasoned veteran is that the senior developer has been a student for a lot longer. But remaining a life long student requires you to understand the difference between confidence and ego, and commit to putting aside even the slightest shred of ego. Stay open minded, and willing to consider the possibility that your previous understanding of something was incomplete or mistaken. Recognize that no matter how much you’ve learned, it’s only the base for the next thing that you’re going to learn. And realize that no matter how far you’ve come, you can still make dumb mistakes - and program accordingly. In a field full of big personalities, stand out by staying humble.

Some reminders to read over time:

• The Greatest Developer Fallacy Or The Wisest Words You’ll Ever Hear? opens a new window
• The Ten Commandments of Egoless Programming opens a new window
• Give it five minutes opens a new window
• Are you a 10x Programmer, or Just a Jerk? opens a new window
• Beautiful Code opens a new window
• You’re a Bad Programmer. Embrace It. opens a new window
• Teach Yourself Programming in Ten Years opens a new window