I often get asked, “isn’t designing thinking just for designers?” Or, “Why should engineers care about design thinking?”. These are all perfectly reasonable questions, after all ‘design thinking’ implies design, right? Let’s delve into why this process is not just for designers but can be extended to even the engineers.
A quick recap on what is design thinking: Design thinking is a non-linear, iterative process which seeks to understand users, challenge assumptions, redefine problems and create innovative solutions to prototype and test. The method consists of 5 phases—Empathize, Define, Ideate, Prototype and Test and is most useful when you want to tackle problems that are ill-defined or unknown. [Learn more on design thinking.]
Let’s now look at one way design thinking can be extended beyond the UI. As engineers, we tend to think that once we have followed software development best practices that’s where we should leave it. But let’s take it a bit further and look at architectures. Looking specifically at how using a modular design over the predominant monolithic design aids in fulfilling the goal behind design thinking.
Modular programming encourages the separation of the functionality in a program into distinct and independent units. Here each unit has everything required for it to execute just that aspect of the program. The elements in the interface of a module can be detected in the other modules of the program.Some of the benefits of a modular programming architecture can be outlined as:
- Unified experiences | ability to reuse code
- Easy debugging | strengthening testability
- Simplicity and ease of maintenance
- Organization
Unified experiences | ability to reuse code – carrying the same familiar experience throughout the application allows the end users to feel familiar and more comfortable using and navigating the platform. This reduces end user anxiety and gets a thumbs up towards design thinking and building a customer friendly application.
Easy debugging | strengthening testability – a program with millions of lines of code will present a huge task if not in a module when debugging is required. You can imagine what it is like to search through such a huge environment to look for errors in a program. Having each task in its discrete module makes the process a lot easier to carry out. A faulty function can easily be checked for errors when in a module.
Simplicity and ease of maintenance – no developer wants to build and release a product that has issues, bugs and crashes. Having a huge project with that’s not modular can make issue investigation and debugging very difficult. Moving to a modular approach reduces the time taken investigate, debug and resolve issues getting updates to end users in a timely manner.
Organization – Modularization makes it easier to read as well as make it easier to understand. This makes the programmer better organized in coding which helps when referencing. This also makes other programmers who may want to go through the workings of the module find it much easier to read. Modularity thus improves readability through a well-organized design.
