Why We Need Architectural Design In Software Engineering

Have you ever wondered what architectural design is in software engineering and why we need it in software engineering? This article is for you.

I will outline what architectural design means and then provide some examples. I will also detail what a beginner and a senior programmer should know regarding that topic.

Let's start.

What Is Architectural Design?

Architectural design is a plan to address scalability issues.

We deal with architectural design when planning for a green field project where the code will be written from scratch.

Architectural design answers the following questions:

• What can go wrong if we do not follow a plan?

• What can cause rewriting parts of the code?

• How can you identify where you are in the code considering its structure?

The questions above group concrete problems that are easy to understand once we go closer to distinguishing between architectural design and when not.

What Can Go Wrong if We Do Not Follow a Plan?

The software will hit a scalability issue sooner or later without a plan for scalability.

Without well-planned and well-maintainable code (clean code), the number of bugs would exponentially rise.

Coding has a hierarchy; therefore, we will have a macro plan - the one that, for example, a junior developer receives from a senior developer to implement this.

This macro plan can be treated as one of the first manifestations of architectural design a developer encounters. We could call the implementation with clean code the micro plan.

Related: What Is A "Requirement” in Software Engineering?

What Can Go Wrong if We Do Not Follow a Plan?

General unscalability.

Suppose you have a prototype for one user so that you can test if the main functionality of your software works.

Then, you'll need to count how many users fit in one server instance, how to distribute data, and so on.

You need to think about scalability scenarios and plan how to address them.

What Can Cause Rewriting Parts of Code?

Scaling out software is not just mathematically multiplying how many users we want to serve (for example) but also thinking about more advanced features, groups of features, and interaction between software parts implementing them.

The basis of long-lasting software is paying attention to not doing scalability planning for a feature that has come to our mind in the planning phase is a long shot.

We need to do that planning thinking about interaction design, or we can quickly go down the path of rewriting the code because we need to introduce scalability-friendly technology later in software development.

Related: What Is "Code Refactoring"?

How Can I Identify Where I Am in the Code, Considering Its Structure?

This is an advanced topic. However, every type of architectural design should provide a clue about a specific part of code, what it does and what other parts it interacts with.

Complications can occur: whether there are predefined interaction rules between modules, must-use coding patterns, and clean code semantics.

To navigate the code precisely, we need to know more about concepts like a monolith, distributed systems, microservices, and domain-driven design (DDD).

Besides the OOP hierarchy, modules, and subprojects, knowing more about these systems can help you deal with and extend complex systems as a developer.

Conclusion

This article has given you a brief understanding of architectural design.

You can find an easy-to-follow pet project-driven illustration in ProScala Podcasts in Episodes Four and Five.

I hope you've found this article helpful.

Until next time!

🙋🏾‍♀️