Design or Architecture Pattern?

The difference of design and architectural pattern in Software Engineering.


The design pattern is a term referring to common solutions that be used to solving common problems that occur in certain contexts. Concerned with the (further small) components of a subsystem with their relationships and collaborations with each other. For example, this will help you to solve the problem that you get while creating an algorithm. And you just apply the design pattern that only suitable for your problem.

While architecture pattern in software development is a term for reusable solutions to commonly occurring problems in software architecture. Concerned with the subsystems of an application with their relationships and collaborations with each other. For example, this will help you do decide what structure is fit for your application or create an optimal workflow for your application project.

The Confusion

Many programmers nowadays still confused about the difference between design patterns and architecture patterns, or don’t even know much about it. Like a few hours ago before I decided to write this post, my friend debating with me about the famous MVC (Model View Controller) is a design pattern in his opinion. I’ve tried to explain to him as clear as possible and refer him to some site reference that explains MVC is an architectural pattern. Then, he replied to me with a link from GeeksforGeeks that states MVC is a design pattern.

In the first paragraph, GeeksforGeeks’s article said that

But in the second paragraph,

Later then, I asked my friend,

The Pattern of Design

Photo by ROOM on Unsplash

Let me start with the definition. Design patterns are typical solutions to commonly occurring problems in software design, or in another word, is to help you solve a problem that sometimes you meet when you do programming. They are like pre-made blueprints that you can customize to solve a recurring design problem in your code.

Design patterns are distilled commonality that you find in programs. It allows us to deconstruct a large complex structure and build using simple parts. It provides a general solution for a class of problems — pyfunc

This kind of pattern is like your cooking recipe to let you know how to cook some food. But in reality, people’s tastes vary so to use the recipe you must be adapted to the needs of ingredients and the situation.

The patterns that have been built are formulated in such a way as to find the best way to solve the problem, but still, the programmer must apply the patterns with an approach that is appropriate to the context of the problem being experienced, by adjusting to the needs.

There are 3 classifications of design patterns.

  1. Creational patterns
    to provide object creation mechanisms that increase flexibility and reuse of existing code. Types:
  2. Structural patterns
    to explain how to assemble objects and classes into larger structures, while keeping the structures flexible and efficient. Types:
  3. Behavioral patterns
    to take care of effective communication and the assignment of responsibilities between objects. Types:

The total amount of design patterns that now existed is 26.

Yup. that’s true. But the point is, you don’t need to know all these things. This pattern of design is only applied based on your use case.

The truth is that you might manage to work as a programmer for many years without knowing about a single design pattern. A lot of people do just that. Even in that case, though, you might be implementing some patterns without even knowing it. So why would you spend time learning them?.

  • Design patterns are a toolkit of tried and tested solutions to common problems in software design. Even if you never encounter these problems, knowing patterns is still useful because it teaches you how to solve all sorts of problems using principles of object-oriented design.
  • Design patterns define a common language that you and your teammates can use to communicate more efficiently. You can say, and everyone will understand the idea behind your suggestion. No need to explain what a singleton is if you know the pattern and its name.

Design patterns say how to write code effectively, easy maintainable, high re-usability, and of course readable because of abstraction — vrluckyin

I’ll give you some basic example with one of my favorite pattern,

The Observer Pattern

The observer is one of the design patterns in behavioral classification. To simplify, this pattern has 2 main components, the observer and observable. An observer is an object that observes an observable, while observable is responsible to send information (notify) the observer.

The action that the observer do to connect to the observable is called . And observable only can send information to observer that already been subscribed to him.

This is a type of one-to-many relationship. Why? because one observable can have many observers and can send information (notify) to them.

The observer pattern is a perfect solution if you need an algorithm or service that can fetch data in real-time or listen to a data change from your server. Take an example of the Weather App that needs to monitor weather in Jakarta, Indonesia.

You will need a WeatherObservable to fetch data from a server in some of the time intervals, and notify the data to WeatherObserver that already been subscribed.

Talk is cheap, show me the code

Take a look at the example below, I’ve written it in Kotlin language.

First of all, we declare the interface for observable and observer. BaseObservable is implemented with 2 functions, subscribe for the observer to get subscribed, and the update to broadcast data change to the observer. While BaseObserver has only 1 notify function to get data (notification) from observable.

Then we create the observable object that implements the BaseObservable interface. We also declare an array list to save the observer that already subscribed.

Finally, we declare the observer.

This code is ready, and when the function:


is called somewhere in the code, our observable will broadcast the data change from server to all observer that already subscribed. Simple right?

Enough for design, let’s start the architecture.

The Pattern of Architecture

Photo by ROOM on Unsplash

Architecture pattern is like an abstract explanation about how you structure your application. According to Wikipedia,

These are patterns for the overall layout of your application or applications. They all have advantages and disadvantages.

Many architectural patterns exist out there, you can see the list on Wikipedia. But, I’ll mention the 10 of common architectures:

  1. Layered pattern
  2. Client-server pattern
  3. Master-slave pattern
  4. Pipe-filter pattern
  5. Broker pattern
  6. Peer-to-peer pattern
  7. Event-bus pattern
  8. Model-view-controller pattern
  9. Blackboard pattern
  10. Interpreter pattern

These patterns are already explained in detail here:

Design vs Architecture

In general () the architecture and design both explains the “” but on the abstract view of the idea while focuses on the implementation view of the idea. Design is much more detailed than architecture.

Architecture pictures the abstract view of the whole system while Design pictures the implementation of some specific concerned domain.

Photo by Andreas Brücker on Unsplash

Suppose the government wants to build a new city. First, they will create a high-level abstract diagram explaining where will be the housing area, there will be factory areas, where parks should be located, where to locate grid systems, hospitals, schools, markets and so on. This is Architecture. Now after that, they will create diagrams explaining how houses are built, how much maximum area a single house can have. How to build houses side by side. How much wider the school front would be. How many beds and rooms the hospital would have, etc. This is Design.

Now come back to programming, an Architecture explains components and their interaction while a design explains how each component is built or would be built. So there are architecture patterns and there are design patterns and both of them are different.

From here, I hope you can see the difference between design and architectural patterns.

Do you want me to explain each single design pattern or explain more detail about this topic in the next post? please leave a comment below :)

Any criticism or suggestion is welcomed.

“An idiot admires complexity. A genius admires simplicity.” — Terry A Davis