We call it software DESIGN for a reason
Something recently changed the vision I always had of what software design is.
It is sometimes the most obvious things that we fail to see. Not so long ago, I came across this amazing Medium article about Dieter Rams 10 Principles of Good Design. If like me, you did not study design, you probably wonder who Dieter Rams is. He is a retired industrial designer, known from his consumer products company Braun where he introduced the world to functionalist industrial design. The real important thing here is the more I read about his design principles, the clearer it became :
We use the term software DESIGN for a reason.
What design is really about
Before going through the principles, Andrew James Walls, the author of the article linked above, exposes what good design is about. He first quotes Don Norman, a professor in cognitive science known for his book The Design of Everyday Things, saying :
“Design is really an act of communication, which means having a deep understanding of the person with whom the designer is communicating.”
Now, consider that quote in a software design context. A good software design starts with understanding that other people will work with you on that software. Or maybe, it is just you, a few months later. In any of those cases, you have to keep in mind that you are communicating with others what you are doing. Good design begins right in the way you organize your project, your code, how you name things, so that it is explicit to anyone what your software is about.
Dieter Rams is known for functionalist design. But what is functionalist design exactly?
In functionalist design, the purpose intended for the object is the guiding force behind its design. Every decision about the object (shape, texture, cost etc) is made to maximize the objects capacity to fulfill its intended purpose.
The same should apply to your software. Any design decision should enforce the purpose of the software. Everything should be designed so that your software is able to fulfill its purpose in the best way possible.
Going through the 10 principles of good design
Now, for every principle, I will select a quote from the article that would sum it up, and we will try to see how it applies indeed to software design.
1. Good design is innovative
It MUST push our understanding of an object forward.
if we don’t push for progress continuously — we risk stagnation and decline.
A software is an abstraction of concepts whose only purpose is to serve a real world need. That real world need is called the Domain. Software design MUST push our understanding of the Domain forward. And with every new understanding of the Domain we get, the design of the software should be updated to reflect these nuances. This is a continuous virtuous circle.
2. Good design makes a product useful
Expanding beyond the function of a product, Dieter touches on the role well designed products play in our identities, self perceptions, and the psychological natures of things.
Your project’s organization and architecture should make it easy for anyone to contribute. The more welcoming and understandable it is, the better contribution you will get. If your project gets in a mess that even you have trouble to understand, it will become unmaintainable and eventually people would stop working on it, even you.
3. Good design is aesthetic
He believes effective designers should cut away the fat of a object until all that’s left is its function.
This quote is extremely powerful. You should keep your code clean at all time. Any unused part of code should be removed. Always. Every single line of code should have a role in helping the software fulfilling its purpose.
Think the big and small hole in a pair of scissors. Without anyone explaining a thing to you, you’re able to fit your hand perfectly into the handle and begin using them.
Again, an incredible example here. The clarity of your architecture, and code should make it obvious what you are doing and how you are doing it. Every property, function or class should explicitly be understandable, by its name or even structure.
If you have not read it already, I really suggest that you read Robert C. Martin’s book on this topic, Clean Code.
4. Good design makes a product understandable
Apple also puts “slide to unlock” text in the box to signify what the grey box does.
In his article, Andrew takes the “slide to unlock” feature of iPhones as an example of this principle. He states that even though the UI element of the slider itself is well designed, Apple still clearly exposes what action will be triggered when the user actually uses it. To me, this resonates as, even if your code is as Clean as it can be, you should always document it. Documentation helps clearly state your purpose and makes everything more understandable. It can address some nuances that sometimes could be difficult to make explicit with your architecture or naming conventions. A good software design goes beyond the code itself.
5. Good design is unobtrusive
“simplicity is not the absence of clutter…simplicity is somehow essentially describing the purpose and place of an object and product.”
This is a Jony Ive quote. I really like it, because it can be very easy to lose yourself in abstract concepts, trying to make things generics and maintainable and losing sight of the functional purpose of your code. As we get more and more experience, we can sometimes go too far and come up with overkill solutions for simple tasks. Simplicity should always be on your mind when designing anything. It will serve you and others every time.
6. Good design is honest
Good design shows you exactly what the object does and nothing more. It doesn’t imply features, quality or longevity it can’t deliver on.
I find two aspects to this principle. The first, is again stripping away all the unused parts of your software and strip it down to its core. The second, is a bit more tricky and is the fact that you should not hide malfunctioning features. This means that if something is not working well, you should never put code to make it look to the users like it works fine. Procrastinating bug fixing is always a terrible idea. It will cause problems to your users, you and everyone involved in the project. If a feature is not ready, it should not appear it your software.
7. Good design is long lasting
Good design withstands trends.
This is maybe the principle that most experienced developers are aware of. Your design should make your software long lasting. Meaning easy to maintain and easy to improve. It should be easy to add new features without breaking anything. It should be easy to identify a bug and fix it.
8. Good design is thorough down to the last detail
Have you ever noticed some objects are 90% well-designed. But the designers mess up on some seemingly trivial detail which derails the whole object.
This principle is very important as well. Now matter how little you think the importance of a piece of software is, you still should work on it like it was the most important part of it. A bad designed small piece of software can sometimes ruin the rest of it. Every detail matters. If in a code review, a colleague criticizes the naming of a function that does not do nothing much, listen to him and improve it. Imagine for example, that you did not change it, and some months later someone reworks it, misunderstands what the goal of this function is and makes changes that lead to a bug in the way some of your data is stored. It can be the smallest details that makes your software fail.
9. Good design is environmentally friendly
Designing better solutions to the myriad of problems we’re constantly confronted with.
This principle, when it comes to software design is a bit more complex to identify to. However, we can think of it as making our software more efficient in terms of memory and power usage for example. Also, the quote is pretty inspiring and having that in mind pushes rule #1 even further in aiming to design better solutions.
10. Good design is as little design as possible
Good design is as little “design” as possible.
Ornamentation, conflicting goals (finish the job quick and cheap, and easily), short sighted behaviour, social motivators (status, wealth, power), and greed cause us to over-design the world around us and leads to the objects around us often causing infuriation, frustration and lead to us asking ourselves with bemused expressions “who possibly designed this?”
This last principle comes as a great conclusion to what have been said before. Good design should not be overdoing anything. We should strip it down to the core of the software purpose, keep the simplicity and make it explicit.
