Understanding Software Architecture: From Machine Language to Modern Design

Hello, I am a top architect.

In software development, every programmer ultimately aims to become a qualified architect, but the path is often winding.

Programmers specialize in coding, low‑level principles, or logic implementation, yet many excel in their domains but falter when faced with higher‑level architectural design.

Do not be discouraged; everyone is an architect in some way, often without realizing it.

This article will gradually guide you into architecture and reveal its true essence.

1. Machine Language

The earliest software was written in machine language, using binary 0s and 1s to represent instructions and data.

1000100111011000

Facing such a string of 1s and 0s can be daunting for programmers, especially when debugging errors.

Too hard to write, too hard to read, too hard to change!

2. Assembly Language

Assembly language was created to alleviate the difficulties of machine code by using mnemonic symbols for opcodes and labels for addresses.

mov ax,bx

Although clearer than machine code, assembly remains low‑level because it requires precise knowledge of the underlying hardware.

Assembly code must be written separately for each CPU architecture.

3. High‑Level Language

High‑level languages were introduced to free programmers from low‑level details, allowing them to focus on business problems.

(+ 4 6)

Through compilation, high‑level code can be transformed into machine code for various CPUs, enabling a single source to run on multiple platforms.

4. Two Software Crises

First Software Crisis and Structured Programming

While high‑level languages liberated programmers, the rapid growth of software size and complexity led to low quality, schedule overruns, and cost overruns. The 1963 Sailor‑One rocket failure, caused by a single FORTRAN error, exemplifies this.

Software engineering emerged to address these issues, but it proved only a partial remedy.

Second Software Crisis and Object‑Oriented Programming

Structured programming mitigated logical complexity, yet expanding business requirements and hardware advances introduced a second crisis focused on extensibility.

First crisis: logic became overly complex; second crisis: extension became overly complex.

Object‑oriented programming helped manage extension complexity but was not a silver bullet.

5. Emergence of Software Architecture

When system scale grew, algorithms and data structures were no longer the main design concerns. Large systems introduced new design problems such as massive internal coupling, low development efficiency, and difficulty in modification and debugging.

Huge system scale with severe internal coupling leads to low development efficiency. Strong coupling makes changes ripple throughout the system. Complex system logic causes hard‑to‑detect and hard‑to‑fix bugs.

Software architecture arose to address these challenges, introducing the concept of “components” after modules and objects.

What Does Architecture Mean?

For engineers, “architecture” is a common term, yet its precise meaning varies. Understanding architecture requires grasping three related concepts: system vs. subsystem, module vs. component, and framework vs. architecture.

1. System and Subsystem

A system is a group of related entities that operate under rules to achieve capabilities beyond any single entity.

Relation: entities must be related to form a system. Rules: entities follow defined rules for cooperation. Capability: the system exhibits abilities not present in individual parts.

A subsystem is simply a system that is part of a larger system.

Example: WeChat is a system containing subsystems such as chat, login, payment, and Moments; Moments further contains subsystems like posts, comments, and likes, and the comment subsystem includes modules like anti‑spam, review, publishing, and storage (e.g., MySQL, Redis).

2. Module and Component

Modules are logical units obtained by splitting a system, while components are physical units aimed at reuse. Components are independent and replaceable.

3. Framework and Architecture

A framework defines “norms” (how to do things), whereas architecture defines “structure” (how things are organized). For example, “the project uses an MVC architecture” describes structure, while “the project uses the SSH framework” describes the normative guidelines.

Redefining Architecture

Software architecture is the top‑level structure of a software system.

Architecture must specify which individuals (subsystems, modules, components) compose the system, the rules governing their interaction, and the overall structure.

Designing architecture involves judgment and trade‑offs within constraints such as team experience, cost, resources, time, and business stage.

Summary

Architecture is a solution to software system complexity, requiring careful judgment and trade‑offs to design an appropriate structure for a given system.

Feel free to discuss, ask questions, or contact the author for further communication.