The Art of Simplicity In Software Engineering

Actionable steps to keep it simple in software engineering.

Hello friend! 👋

Basma here. Thank you for reading An Engineer's Echo. Your weekly publication of stories to equip you with the soft and hard skills to fast-track your growth in software engineering.

Reading Time: 5 mins.

---

Image created by the author on Canva

When I started in software engineering, I used to think that “complex” is the answer. And, that the more complex my design doc, code, or questions, the better software engineer I become.

But, let me tell you, that is far from being true.

In fact, it's quite the opposite. The simpler your code, design doc, questions, and solutions, the better software engineer you are.

Solving the most complex problems with the easiest solutions is a mastery.

So, here’s what we’ll discuss today:

• Why simplicity is a crucial skill in software engineering.

• Paradoxes about simplicity in software engineering.

• Actionable steps to keep it simple.

---

Paradoxes about Simplicity In Software Engineering

#1 Simplicity is one of the hardest skills to learn in software engineering

From my experience, writing simple code is one of the most challenging skills you can acquire.

That’s because it's not as easy as you might think.

To write simple code, you need:

• A deep understanding of the problem.

• A deep understanding of the solution.

• Deep knowledge of the basics.

• Deep knowledge of the tools.

In short, you need to understand every aspect of the problem's context and the solution.

You might wonder, "How could I not understand the problem or the solution well if I am already writing code for it?"

Believe me, you'd be surprised at how many times you could jump into solutions without fully understanding the problem or the solution. I've been guilty of that more times than you can imagine.

---

#2 Problem-solving needs gut feeling.

Unlike what you might think, logical solutions don't come from the logical brain alone. Sometimes your gut feeling about a problem tells you about your blind spots. It can point you to where you might have messed up.

To do that you need to:

• Practice self-awareness: You know yourself better than anyone. You know when you don’t understand something enough or the vague areas that you might be missing.

• Use your gut feeling: I found out that my gut feeling is usually true when it comes to problem-solving. It tells me when my solution is missing something or when I haven’t done enough research. When I started listening to these signals, things started to improve for me!

Now you might think, "How is this related to simplicity?"

Made-up answer: Simplicity is listening to your expertise represented in your gut feeling.

Honest answer: You're right; it's not directly related to simplicity, but it felt like a nice paradox to include here!

---

#3 Simplicity is “many“ in software engineering.

Unlike the norm, that simple is less, in software engineering, simplicity usually means “many”. Here are some examples:

• Simple code can be split into many small pieces that can be built incrementally.

• Simple code means many small functions.

• Simple code can be tested in many ways.

• Simple design docs can be read and understood by many engineering levels: Seniors, juniors, outside of the team, inside of the team… etc.

As Einstein once famously said:

“If you can’t explain it to a 6-year-old, you don’t understand it yourself.”

---

#4 Simplicity is the trait of the geniuses in software engineering

Working alongside many geniuses in software engineering, I can tell you that the most common trait among them is “keeping it simple.”

They always:

• Go with the easiest solutions.

• Go with the simplest way of testing.

• Write in the simplest language possible.

• Write simple code, using the simplest and most efficient algorithms.

• Explain using simple diagrams and simple formatting, e.g. bullet points.

To level up in software engineering, you need to have a “simplistic” mindset. In everything you do, from writing simple code to writing simple English.

---

What You Need to Do To Keep It Simple…

In this section, I will share with you the strategy that I have been following to keep it simple.

1. Ask yourself: Is it simple that anyone can understand this without my explanation? It’s as simple as this. You don’t need fancy tools or techniques, just need honesty and reflection with yourself. Apply this when you write code, design docs, or anything else.

   1. If the answer is yes, great.

      1. Ask someone for a review.

      2. If they don’t understand it quickly and easily, then it’s not simple enough.

      3. Then go, Reiterate.

   2. If the answer is no, don’t panic.

      1. If you need to, ask for help (e.g. pairing).

      2. Break the problem down to pieces.

      3. Use drawings and diagrams.

2. Explain it to yourself, by writing:

   1. If it’s simple enough and you understand it well, it should be simple to write it down.

   2. You’ll likely pinpoint pitfalls, and rethink your original thinking.

3. Explain it to someone:

   1. I find it super helpful to whiteboard design and thoughts.

   2. It allows other people to point you to things you missed or any potential developments.

   3. It allows you to know the strong points of your design.

---

Key Takeaways

1. Simplicity is Success: Complexity doesn't make you a better engineer. Instead, simplicity in your code, designs, and solutions is the real mark of skill.

2. Learning Simplicity is Tough: Writing simple code isn't easy. It requires a deep understanding of the problem, solution, basics, and tools.

3. Trust Your Gut: Sometimes, logical solutions aren't enough. Trust your instincts—they often reveal blind spots and mistakes in your thinking.

4. Simple Means Many: In software engineering, simplicity often means having many small pieces—small functions, tests, and documents that everyone can understand.

5. Geniuses Keep It Simple: The best engineers go for the easiest solutions. They use simple language and diagrams to explain complex ideas.

6. Keep It Simple Strategy:

   • Ask yourself: Can anyone understand this without explanation?

   • If yes, great! Get a review. If no, break it down, ask for help, and explain it to yourself and others until it's crystal clear.

Remember, simplicity isn't about perfection; it's about making things understandable for everyone.

---

Thank you for reading! I hope you enjoyed it, let me know by hitting the like button ❤️ to help others find it on Substack, and share it to spread the love!

---

Great articles you don’t want to miss:

• How to get promoted this year. by

  Caleb Mellas

• Why Tech Talks are Important by

  Junaid Effendi

• Retrospective Meetings Demystified by

  Nicola Ballotta

• How to Master Salary Negotiations by

  Hemant Pandey

---

That’s all folks, let me know what you think of this article in the comments.

Or speak to me on direct message on any tech topics you’d like! I’d love to hear from you. :)

Speak soon,

— Basma