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
- Every app has a scary basement
- A Taxonomy for "Bad Code Smells"
- The Law of Leaky Abstractions
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
- Technical Debt Isn't Just Technical (communication solves a lot of problems up front!)
- The Developer’s Edge: How To Become A Senior Developer (notice how few of these skills are technical!)
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: