Software development is a profession that requires a unique skill set. However, over the course of my career, I’ve come to appreciate two important characteristics of good developers that aren’t unique to software at all.
I’ve found these traits extremely helpful in my work, and both of them involve habits that I’ve had to make an effort to improve over time.
1. Attention to Detail
So many things have to go right just to get a software program to compile. That’s why attention to detail is so important in many dimensions, and it’s often one of the first skills that new developers learn.
Early in my career, I would often declare work finished too early. I recall several occasions where, after letting my team lead know I was finished with a feature, they would review it and immediately find issues. Even if the code worked well enough, my pull request would still be peppered with comments—perhaps about stylistic inconsistencies or other qualities of good code that I had overlooked. Situations like this often result from poor attention to detail.
Software is complex, and so is the business logic it’s tasked with modeling. Getting things right is hard. It takes a lot of discipline and careful review.
A few strategies I’ve used that have helped me develop quality code while ensuring strong attention to detail include:
- Testing – One way to make sure your code works for the full domain of inputs is to test it. Usually, this means unit tests., and perhaps even writing test-driven code. Sometimes it means broader-scoped tests. For example, I really like tests that touch a test database or other dependencies. They help give me confidence that my code is correct and robust.
- Self Code Review – The first person to review my code is me—often, more than once. I usually open a pull request just for myself. I make sure all of the changes make sense. Then I make sure my code is stylistically consistent with the existing code. You always have some budget for bucking the trend, but not much.
- Feature Review – I always make sure to review the story or feature I’m working on to make sure my code satisfies all of the requirements and acceptance criteria. It’s easy to get lost in the implementation and miss the forest for the trees. There have been several occasions when I thought I was done, only to realize there was another requirement of the story I hadn’t addressed.
- Take Notes – I try to document decisions I made while working on any code, along with their rationale. It’s easy to make a decision in the moment, only to forget it later when someone asks you why you implemented something the way you did.
Most software projects take a long time to write correctly.
Some people compare software development to gardening. It can be difficult to control the garden as it grows. Sometimes, the best you can do is work to maintain it and keep it well-groomed. In the same way, writing software can be a slow and tedious process, and it’s critical to have patience along the way.
When developing software, the best solution is usually not the first one that comes to mind, nor is it necessarily the one that’s easiest to implement. Arriving at the best solution (or sometimes just any solution) can be difficult, and this can often lead to frustration.
It’s important to have patience and view frustration positively. Doing so often allows for the greatest amount of learning, and it sets the best developers apart from others. Having patience also helps prevent you from feeling overwhelmed.
I don’t know if I have any helpful tips for developing patience. Rather, I think it’s important to accept that writing software can–and will–be frustrating. It’s how you accept the frustration that will allow you to become a better developer.
Software is an enormous field with all types of specializations. To become an expert in just one requires a tremendous amount of effort. It’s important to accept slow incremental growth that, with patience, will compound into expertise.