Often time less experienced software developers tend to have the wrong idea of being productive in software development. They believe that to be productive, they have to be writing code all the time. Do you fall into this description?
When I first started out as a software developer, I was under the same idea as well. However, that is no longer the case. I learned that software development is about thinking/planning more than coding. Therefore, my goal in this post is to go over some of the benefits to planning ahead before coding.
Think Before Coding
Thinking about the problem you are trying to solve should be your first step in any of your projects. You need to have a grasp of the big picture idea and then from there, you start breaking the project down. Try to break the project down into as many parts as possible because that will reduce the complexity of the project into manageable pieces. When you are working with smaller pieces of a problem, you will find that it is not overwhelming.
With your project broken down into smaller parts, you can start to think about the implementation of each part. At this stage, you should be thinking in terms of pseudo-code and not be doing actual coding. You are likely to be working with a framework, so look for what functionalities the framework offers that would help you implement your pseudo-code. By approaching your project in this specific way, it allows you to backtrack easily if you do find some issues with your approach. The best part is you did not waste your time trying to code only to find out partway that the approach will not work.
Saves You Time
Planning ahead will naturally help save you time (maybe a lot of time). When you plan ahead, you are likely to think about how to implement features and do research. For example, feature X can be done with framework X and API X, but if you did not do research and jumped straight to coding, you may end up developing from the ground up. As you can imagine, using the framework and APIs will save you a massive amount of time and headache.
In addition, when you plan ahead, it can help you see potential issues and roadblocks. So instead of running into issues later on as you code, you see them ahead of time and can change your approach without spending time coding.
Helps Produce Clean and Readable Code
Planning ahead means understanding the big picture idea to the software you are writing. What follows naturally is breaking the software into multiple parts and each part into sub-parts. By having a clear breakdown of the project (at least the best possible at the time), you are able to write code that would make sense together. If you are writing a piece of code that does action X only then you might omit essential details that helps with understanding how all the pieces in the codebase fit together.
Deduces Technical Debt
Well planned out software design allows you to make better choices, which in the end means less technical debt. By planning out the software, you are able to write cleaner and more readable code. The improvement to the codebase means there will be less chance of bugs and errors throughout the lifespan of the project.
Helps with Complex Problems
Planning ahead means breaking down the problem into smaller parts. Usually, a complex problem is a combination of many problems. Therefore, when you take the time to break the complex problem into smaller parts (ideally small individual problems); you can tackle them one at a time.
Looking at the complex problem as a whole makes it difficult to deal with. However, when you solve each of the problems individually, you find that it is manageable. Once you have a solution to the smaller problems you can work your way back up to the original problem.
If you found this post helpful, share it with others so they can benefit too.
Did this post change how you decide to tackle a problem? Did you discover the benefits to planning the hard way?
Leave a comment or send me an email at steven@brightdevelopers.com. To stay in touch, follow me on Twitter.