Introduction

Solving a Complicated problem does not require a complicated approach we are meant to manage the complication, so we don't introduce more problems. The most effective way to solve a complicated problem is to keep it simple, and I know keeping things simple is easier said than done. This article is my way of thinking about achieving it. As Software Developers, our job requires us to solve complex problems, which entails breaking them down into simple sets of instructions for the Computer to execute; we call them algorithms. One thing the computer does very well is following your instructions as stipulated. So it would be best to keep it simple for clarity for you and the computer. Coming up with an algorithm on the fly is the desired goal, and I know how it makes us feel like superstars. Some top 1 percent of Software developers with the Genius tag would do this easily, But I feel that is the result; I'm here to talk about a process I think would take us there. Coming up with an algorithm is not far from solving mathematical problems, so this link advising on how to solve problems in mathematics on Wikipedia can apply to us.

Benefits of keeping it simple

Reduced Friction to start solving the problem

Rather than trying to figure out the solution on the fly, which can get you stuck on starting. The above link suggests a more practical approach to understanding the problem. This can involve asking questions about what the problem requires to be solved. This can lead to generating a plan cause each question is potential sub-tasks. By the end of this process, you have reduced the large and complex problem into smaller chunks of problems that are simpler to solve and contribute to the solving of the larger problem. Concepts like Psuedo-coding and creating sub-tasks would help in this process.

Clearer Solutions

One of the attributes excellent software engineers should strive for is being able to write maintainable code. This is because problems can be revisited for correction of some assumptions and also general improvements that come up in the future. When solutions to problems are clearly defined, as suggested in the step above, it becomes easier to compose easy-to-maintain code. Documentation also becomes easier because of the earlier step. Even unit test, which can also be a form of documentation, becomes easier to write. What you are testing for would follow the questions asked above.

Conclussion

This approach can be applied to many complex tasks, at times, not just coding. A lot of the time, focusing on the result would cause us to avoid the real work. This serves as a process of getting started on achieving the desired result. I am not sure I kept this simple enough, but I’d suggest you remind yourself to keep it simple. A step at a time. Here is an article with more information