I started working in software projects when C++ was the only highly popular programming language. There used to be a lot of focus in writing optimal programs or routines. So though the applications were optimal, they suffered from Waterfall mindset of thinking distant future nobody was clear on – “What if…in future…”.
Design patterns and C++ Idioms were new and that led people writing complex programs for the heck of applying patterns in the applications. Some “what if…” used to generate a lot of waste. I still remember a software project which was continuously and consciously designed for internationalized database just because what if we need to setup our company in a country like China. For years a lot of effort and money went into developing and maintaining internationalized datasets. At the end when the need really came, people realized that the same system doesn’t fit in China because the way thing works over there. So a lot of hard work simply became waste.
Agile came and along with that engineering practices Extreme Programming became mainstream. The learnings from Waterfall days gave birth to some principles which made a lot of sense in Agile perspective.
So “Keep It Simple and Stupid (KISS)” made a lot of sense to the developer community which has already seen many overengineered products and a lot of waste coming just because of “what if…” syndrome.
Along with that it was asked to avoid doing optimization on premature basis. Again the principle made a lot of sense but it had other repercussions too. So many things went into “do it later” box. Even though you know that the current piece of code is a mess from design point of view, some people started taking it for granted and conveniently moved it into “do it later” box. With the experience of so many projects already I know that “later” never comes.
So when you’ll say, does KISS always make a lot of sense, you’ll say it depends. When it’s fuzzy it’s not clear. In case of KISS also, it made a lot of sense to people who were good from software design point of view. These people were keeping the program very simple, small and at the same time correct from design point of view. However for some other people it was yet another excuse for writing bad code. They were the same people who had absolutely no background of KISS and “Don’t Optimize it Yet (DOY)”.
I am refering to people who are beginners in their software career. Even before they understand what all design principles mean and how they help in keeping design clean, extensible and maintainable, they know KISS and DOY. The definition of simple and stupid is always abstract. So if a person doesnt understand when to refactor, when to create classes and methods, the concept of SOLID principles etc, you already know that he might be writing source code with 1000-2000 lines of code, methods which are pretty big.
In my personal view, it’s very important to take these principles in holistic perspective and not in isolation. It’s also very important to focus on the software design principles and fundamentals before people can start using KISS and DOY.