Product Design vs. Software Design
A few days ago, I read an article about product design inspired by the “10 principles for good design” from Dieter Rams (see https://ifworlddesignguide.com/design-specials/dieter-rams-10-principles-for-good-design). I was aware of the iconic design of Braun products in the last century, but to be honest I didn’t know the master mind behind this.
While I read the article, it came to my mind that the principles defined for physical things also hold true for the software design of an application. You just have to switch your viewpoint a little:
- Product equals Application
- Consumer/User equals Developer
Let’s have a closer look on the 10 principles and equivalents in software design. Please note that I’m not looking at UI/UX Design, but rather on the design and architecture of the underlying software.
Good Design is innovative
The possibilities for innovation are not, by any means, exhausted. Technological development is always offering new opportunities for innovative design. But innovative design always develops in tandem with innovative technology, and can never be an end in itself.
Innovation!
In IT the rising of new technologies is even faster than in the “real” world and this also includes new software design approaches and patterns. This is a no-brainer but somehow, it’s hard to keep the pace. In the last years the rise of the cloud and hyper scalers even increased the innovation speed in IT. It looks like that there are new, innovative services available each and every day. A good architect needs to understand them and decide which ones to use. Be aware that there is also the risk of decommissioning of services from time to time.
With GenAI everywhere and its impact on the software development lifecycle, even the way we design software will change once again. In this case, innovation not only in the result, but also in the way the result is built.
In addition, Software Designer & Architects are experts in selling “old wine in new bottles”, but that’s a different story.
Good Design makes a product useful
A product is bought to be used. It has to satisfy certain criteria, not only functional, but also psychological and aesthetic. Good design emphasises the usefulness of a product whilst disregarding anything that could possibly detract from it.
Usability!
In software design and architecture this has several dimensions:
- Functional Requirements: Your design must help to solve the business challenge and create business value.
- Non-Functional Requirements: Those requirements are key for success and the architecture and design is the foundation to fulfill them.
To build a working and useful application one must fulfill the functional and non-functional requirements. The chosen design and architecture must serve this purpose. Focus on the relevant parts is also key. Good applications do what they need to do best instead of solving other not relevant challenges. Actually this should be a no-brainer, but sometimes we lose track and it’s worth reminding ourselves on the basics.
Good Design is aesthetic
The aesthetic quality of a product is integral to its usefulness because products we use every day affect our person and our well-being. But only well-executed objects can be beautiful.
Software Design is Art!
This one is a little tricky, but I’ll translate it in the following: Developers need to love your design, otherwise they won’t follow it! As it is quite easy to ignore the guidance of an architect it’s very important to get the buy-in of the development team. If it’s not useful, they will ignore it and find different ways to deliver a solution. Architects tend to be artists, especially since it’s really hard to measure the quality of an architecture and design. You can define & watch KPIs, but in the end you might get judged based on “it looks good, and it really works!”.
Good Design makes a product understandable
It clarifies the products structure. Better still, it can make the product talk. At best, it is self-explanatory.
For Dummies!
This is essential for software designs. In IT it’s key to create a long-lasting design and architecture (see other design principle) that helps to understand the solution that is implemented and keeps it adaptable and maintainable. If this is not the case the maintenance will be a nightmare: error prone and very expensive! To achieve this one should adhere to common, well-known design principles like: Separation of Concerns, Information Hiding, Data sovereignty, and Layering. The Developers need to understand the design and architecture, otherwise they are not able to follow the given rules. You should also keep in mind that over time a lot of different people with different skill levels need to understand it, thus it’s strongly recommended to make it understandable for “Dummies”. This is not disrespectful, just keep in mind, the easier it is the higher the chances are that it is followed.
Good Design is unobtrusive
Products fulfilling a purpose are like tools. They are neither decorative objects nor works of art. Their design should therefore be both neutral and restrained, to leave room for the users self-expression.
Simplicity!
Design and Architecture not for the purpose of itself. In Germany we sometimes tend to over-engineering and this is something you need to prevent. In design and architecture, it’s not about adding the next level of complexity, it’s all about simplicity and this is also reflected in the KISS principle. Thus, I strongly recommend to make it as simple as possible or to quote Antoine de Saint-Exupéry: “Perfection is achieved, not when there is nothing more to add, but when there is nothing left to take away.”
Good Design is honest
It does not make a product more innovative, powerful or valuable than it really is. It does not attempt to manipulate the consumer with promises that cannot be kept.
Adapt First!
This is the holy grail and for software I would say that it’s contradicting to the principle “Good Design is unobtrusive. There is a fine-line between those two. In the Technovision (see https://bit.ly/3oUZgwz) another blog (see https://thilo-hermann.medium.com/adapt-first-expect-the-unexpected-7ec2055a06a7?source=friends_link&sk=e8da0afcc7892c7f673b570be2912538) I highlight the importance to embrace the upcoming change also in Design and Architecture. Only the best Architects can fulfill this demand.
Good Design is long-lasting
It avoids being fashionable and therefore never appears antiquated. Unlike fashionable design, it lasts many years — even in todays throwaway society.
Reflect the past!
This is key and I know a lot of examples for great IT design which are still working after more than 20 years. Only time shows if you took the right decisions during the initial design of an application. I strongly recommend reflecting what worked well in the past and adjust it to the needs of the new and/or additional requirements. Technology can help, but typically is not the “holy grail” in this journey.
Good Design is thorough down to the last detail
Nothing must be arbitrary or left to chance. Care and accuracy in the design process show respect towards the consumer.
Budget?!
This might be a difference, due to the fact that it will get very expensive for software and the benefits might be only limited. Where to start and where to stop. Less is sometimes more and we Architects should more often use the mantra: “Good is good enough!”. It also depends on what kind of Application you’re building. For a missile control you might want to have different standards compared to a shopping list.
Good Design is environmentally friendly
Design makes an important contribution to the preservation of the environment. It conserves resources and minimises physical and visual pollution throughout the lifecycle of the product.
Sustainability!
Sustainability is getting more and more important in IT, thus we need to take this non-functional requirement into account. Studies show that Enterprise IT contributes significantly to the world’s carbon footprint, thus we need to act! This is something for the whole organization and we need a holistic approach to support this:
- Set the foundations with a qualitative and quantitative diagnostic assessment and a sustainable IT strategy that aligns with the organizational overall sustainability strategy
- Create a robust governance approach with a dedicated sustainable IT team and support from the top leadership team
- Operationalize sustainable IT initiatives, with sustainability a key pillar of software architecture.
Especially the 3rd action is relevant for us as Software Designers & Architects and the following dimensions should be considered while designing and architecting a solution:
- User Hardware and Devices
- Networks and communication systems
- Applications and data
- Cloud computing
This is a huge topic so I recommend to have a look on my other blog around “Green Software Engineering” (see https://medium.com/@thilo-hermann/green-software-engineering-back-to-the-roots-56ea6d151d65).
Good Design involves as little design as possible
Less, but better — because it concentrates on the essential aspects, and the products are not burdened with non-essentials. Back to purity, back to simplicity.
KISS!
KISS (see https://en.wikipedia.org/wiki/KISS_principle) principle is well known in IT and every good Architect takes it into account.
Conclusion
Those were the principles given by Dieter Rams. In Software Architecture there are also other things to keep in mind, but I found it rather interesting to draw this analogy between physical things and software as such.
The main themes are Simplicity, Adaptability, and Usability! On top of that you should also try to improve and innovate your way of Architecting & Designing. Technology might help, but that’s not guaranteed.
The key question for me is what methodology can be used to arrive at a design that follows the rules described? Design Thinking (see https://en.wikipedia.org/wiki/Design_thinking) might be worth a look. This problem-solving method, which emphasizes creativity, empathy and iterative prototyping, is often used in workshops. It’s used across a range of industries and prioritizes understanding the needs and perspectives of end users to generate innovative solutions.
Interested in another analogy? I would recommend to read “Why Architects are like surfers”.
