What is design?

Before we dive into different architectural styles, let’s discuss what a design actually is. According to the dictionary, design can be defined as a verb (to make or draw plans for something, e.g., buildings) and also as a noun (a drawing/set of drawings not only showing the design of the product to be made, but also how the finalized product will work and look). Therefore, design as a verb is an activity that will produce a document (i.e., a noun)—such as a sketch or a blueprint—that illustrates the final product’s appearance.

Different designs are made for different products every day. For example, a team discusses the shape, colors, etc., of a product—that’s a design. Similarly, building designs include the elevation of the building. There are floor designs and discussions on how many rooms a house will have, the different features of each room, their dimensions, where to plant different trees, etc. Interior designs then discuss the setup of each room—the room’s color, which furniture to buy for the room, its placement, along with other minute details.

In the same way, we have software design. When we make software, we try to visualize it from different angles. We have class diagrams (an activity of the design process), ER models to discuss database designs and architectural level designs—how different components are connected and interact with each other—along with more discussions on the software’s architecture.

But the main question remains: Why do we design software systems? Because we should think before building anything. That way, if we feel something is wrong, it can be easily erased on paper and redesigned again. Once satisfied with the design, we can start building the product. Whereas if we start constructing a product without any plan, and in the later stages, we find something that we don’t like, we’ll have to break it with a hammer and reconstruct it again—which will be a lot more costly.

Design phase in the waterfall process model

One of the most basic approaches to product development in software engineering is the waterfall model. In this process model, logical steps are defined, one step after the other. It’s a very useful approach where project requirements are clearly defined. The model is depicted as follows:

As can be seen, the second step of the model is the design and analysis phase. We’ve discussed what design is and its importance. The design phase encompasses a lot of different parts within itself. Unfortunately, more often than not, importance isn’t given to this phase due to various reasons. However, after the requirements phase, in which we describe what the system is supposed to do, the design phase specifies how the system is to be built. Therefore, we can consider the output of the design phase to be a high-level model of the software system (or it’s blueprint). Moreover, the design phase can also be considered a process of transforming a problem realized during the requirements phase into a solution.

Points under consideration during the design phase

The following are some of the points that are considered during the design phase:

• How should the different components be represented most effectively, so that they’re easily understandable for the different stakeholders?
• What tools and techniques are useful for implementing an architecture that preserves its properties?
• Apart from considering the software aspect, hardware components are also considered.
• How can the nonfunctional requirements of the system be included and handled via different architectural styles?

Phases in the design process

Within the design phase of the waterfall model, there are multiple steps, each handling a different design aspect.

The main focus of this course is architectural design, but here’s a brief description of each of the design activities:

In architectural design, the focus is on system architecture, in which subsystems are identified, followed by the abstract specification step, in which those subsystems are specified. Interface design is the next step. In simple terms, the user interface is defined during this phase. We also discuss how different system components interact with each other and how external users interact with the system. The component-level design phase decomposes the subsystems into different components, followed by the data structures and algorithms design phase.