Code is the manifestation of the principles (the mental models) of the software engineers who write it. How you write code is a reflection of who you are and what you believe is important in software development.
This is one of the main reasons why companies tend to have similar programming problems that cannot be solved by this or that technology. Their code is written by software engineers who either have conflicting principles between themselves or who have principles that clash with the overall goals of the company.
You can distinguish engineers on the basis of these principles. While senior, more experienced engineers will be more proficient programmers, they'll also embody different principles that make them much more valuable to the company in general. Let's call these principles growth principles.
This blog post will delve into the 11 most important growth principles that will make you a valued, productive software engineer.
1. Master Your Tools
Being a good programmer doesn't simply mean being good in a particular programming language. It also means deeply understanding the tools you work with.
By this, I mean the IDE you work in, your debugger, Unix commands, your CLI, your editor, etc... Whatever tool you use, the better you know it, the more creative, productive, and efficient you'll become.
2. Learn Every Day
You know this is important, yet it bears repeating. Learn every day. It reminds me of Warren Buffett's key tip for success:
"Read 500 pages a day. All of you can do it, but I guarantee not many of you will do it."
Reading and learning go hand in hand. I'm not saying you should read 500 pages a day, but you should dedicate a significant amount of time every day to learning something new. The pace of change in the programming world is fast. Be a student forever to stay ahead of the game.
This is particularly relevant for those who work remotely. When in doubt, overcommunicate. You'd be surprised at how often people misunderstand what you're saying. Clear and frequent communication reduces the risk of that happening.
Additionally, frequent communication between programmers increases trust and goodwill. People are more willing to rely on one another and share knowledge more easily and frequently.
4. Improve Your Writing
Much of how we communicate is through writing, whether that's email, Slack, or any other messaging app. The better and the clearer you write, the more easily you'll be understood and the less friction you'll encounter because of miscommunication.
When writing, keep in mind who you're writing to. Understand what they care for and why your message is important to them. Additionally, if you're writing a long message to a C-suite member, include an above-the-fold tl;dr summary. They'll appreciate it.
5. Unblock Yourself
The most productive developers are those who never seem to get blocked. When they're stuck on one project, they move to another while they figure out the solution. Never let your productivity drop to zero.
Instead, find ways to keep up your momentum. Whether that's escalating your problem to a colleague, switching to a different project, or something else to keep you going, never allow yourself to come to a standstill.
6. Own Your Projects
Even if you're not a lead engineer, practice running your own meetings, understand who's who in the project, write good summaries and plans, and keep the relevant stakeholders informed.
Have a sense of ownership for the projects you're on. Take responsibility. It will let other people in the team know that you're ready and willing to take on bigger projects in the future (possibly with a more senior role).
7. You're Running a Business
Along with owning your projects, think of your work as if you're the CEO of the business. You're not just a programmer. You're someone who makes decisions that will impact the bottom line.
This perspective will show you the bigger picture. You'll be able to make decisions that are good (or better) for all stakeholders involved, not just for you and your immediate team.
8. You're a Professional
Think of yourself as the professional that you are. Carry yourself with dignity and treat others with respect. Come to meetings (remote or not) on time and prepared. Pay attention. Don't let emotions cloud your judgment. Don't complain.
People appreciate a professional. It will build your personal brand in the company and you'll be better trusted as a result.
9. Done is Better Than Perfect
Nothing is ever perfect, so it's almost always better to push it live than to wait until you've reached some illusion of perfection. Perfect is too expensive and it slows you down.
So don't be afraid to get your hands dirty and submit what you have, warts and all. If you'd look back at the alpha versions of popular software today, you'd be surprised at how awful much of it was when first released. That's the nature of things. It's a process; don't try to fight it.
10. Expect Change
Another reason why you shouldn't try for perfect is because things will always change. It's inevitable. Whether a debilitating error, customer requests, or company pivots, the code you've written will change.
As such, never tie yourself into a corner too much. Write code that allows you to change things quite easily. Further down the line, you'll be grateful that you've written code that's malleable and not set in stone.
11. Learn When to Say No
The more moving parts a system has, the higher the risk of failure. The best software is software that works. The fewer moving parts in a system, the more likely it will run without problems.
As such, saying no is valuable. This could mean saying no to shiny object requests, but it could also mean simply removing lines of code. If the software can accomplish its goal without a certain moving part, you'll likely benefit from removing it.
These were 11 growth principles that will make you a more productive, creative, and efficient software engineer. Do you have any principles that you keep in mind while writing code? Let me know in the comments down below.