I just came across a very interesting article that has to do with how people think and how they operate. It talks about "Simplifiers", people that like simple solutions, that like simplifying structures and processes, and "Complexifiers" that are more or less the exact opposite.
Myself, I am clearly a simplifier. That goes without saying with the BruteForce nickname. In my work I like developers that are simplifiers. Writing software is a very complex task in the first place, so if you design unnecessarily complex hierarchies and structures you only make things worse, much worse. The larger the project the worse you make it.
Here is a one liner example I recently found in some code. The programmer had to copy one buffer to another buffer. Plain old totally naked bytes, nothing fancy, no objects or hot stuff. Instead of doing a single call to CopyMemory which is part of the Win32 API (actually a define) or to memcpy from the CRT, this programmer chose to include <algorithm> and use the copy algorithm!
So instead of the simple call:
CopyMemory(TargetBuffer, SourceBuffer, Length)
the guy wrote:
copy(&SourceBuffer[0], &SourceBuffer[Length], &TargetBuffer[0]);
And this call to STL 'copy' was the sole reason for including <algorithm>.
Making things simple doesn't necessarily mean that the actual solution you design or specify is not complex. The point is not to make it more complex than it has to be. Simplifiers will choose the simplest complex solution. Oversimplifying is always something that should be watched closely as it might be equally bad to overcomplexifying. Or it just might produce a genius design.
The above are closely related to the so called KISS principle (Keep It Simple Stupid). So if you are a developer don't just smile and nod, saying KISS sounds cool, take it as a personal goal to become a software KISSer ;-) a digital simplifier. For one thing, you will make your life simpler ;-)
Dimitris Staikos
