Simplicity is the best weapon a software engineer can use

Here is an example of a task I discussed recently with a developer. It was a task to test 10 static endpoints.

I wanted a quick set of tests to ensure the service was working—a smoke test. Nothing fancy.

Given that developers were previously testing this service manually in SoapUI, and they were not testing it all, just 2-3 calls. Because of poor tests, we were repeatedly running into issues.

To have all endpoints tested by a simple script would have been a great improvement. And it was an easy thing to do. I thought.

So, the developer suggested this plan:

• I need to learn Powershell because I'm a Linux guy

• I need to put those 10 URLs into a file

• I need to run through that file to read the URLs

• I need to add some params to all URLs in some generic manner

• I need to test error responses and display them properly

Even though this is a robust solution, we do not need it now. We just need a way to test our endpoints.

What to do instead?

Let’s do it simply:

• create one file and put all 10 'curl' calls there

• run it

By doing this, we greatly improved our process by investing a little in some automation. We already have some results after this.

In other words:

• We already have an automated script that will help us smoke test our service

• We save time by using the script

• We cover all endpoints, not just a few

• We now have something that can be improved later

Focus on the result, simplify, and get the job done.

Yes, we can make it later more error-prone, more parametrized, etc. We may need it, maybe not.

Why are we trying to complicate things?

There might be several reasons:

• We are in our heads juggling many things at once, which is clouding our perceptions

• We do not concentrate on simple things

• Our ego is showing - we try to showcase our coding skills

• We concentrate on steps (details) and not on the solution (big picture)

The technology is complicated and is getting even more complicated every day. There is no need to complicate it even further.

A great sign of a mature software developer is his/her ability to see through the clouds and simplify things for everybody.

Here is what I suggest you do when facing any problem. Ask these questions:

• Is the problem clear?

• Do we even need to solve it

• Should we solve it now?

• What can we do to solve 80% of the problem?

• Is 80% enough for now? Secret: most of the time, it is.

• How can you simplify the solution even more?

This is about more than just huge architectural problems. Apply these principles to day-to-day tasks.

Instead of asking what the exact syntax to use so I can fix this problem, ask broader, high-level questions:

• What is the simplest command I can use?

• What is the tool that can solve this automatically?

• Who might have worked on this before, can I use their solution?

Here is how complicated thinking can manifest in day-to-day software practice:

• Overcomplicated architecture - you design a solution ready for millions of users when you have zero users. This will lead to a complicated environment and difficulties with development, testing, and deployment—a huge cognitive load on team members.

• Preemptive optimization - you spend a lot of time optimizing what might not be needed. Yes, we do not want to write suboptimal code. If you know how to optimize a certain piece, do it quickly. Do not spend too much time if you do not know if you have a performance problem.

• Complicated team structure and communication - Multi-step communication and communication via middleman is a recipe for disaster. Prefer direct communication, offline, and written communication.

• Designing huge features that nobody wants - yes, we want to bring the best features to our users, but no need to work on huge changes. Let’s experiment with small updates.

These principles are a direct manifestation of a simplification mindset:

• KISS - Keep It Simple, Stupid

• YAGNI - You Aren’t Gonna Need It

Use them whenever you can.

Simple solutions have many benefits:

• They are easy to understand

• They are easy to design and maintain

• Simple solutions are often more cost-effective

• They are faster built and deployed, so they show their value earlier

• They can be managed and maintained by junior staff. They do not require experts.

• Simple solutions are often more adaptable to change

• Simple solutions are a great base for future enhancements

• Simplified solutions often result in higher quality, as there is less room for errors

• Both developers and users can adopt simple solutions faster due to their straightforward nature and ease of understanding.

P.S. Thanks for reading! You might also find this article helpful: https://beyond-coding.beehiiv.com/p/engineer-magic-word-career