From Machine Code to Modern Systems: A Deep Dive into Software Architecture

Programmers often aspire to become architects, yet many struggle when moving from implementation details to high‑level design.

1. Machine Language

Early software was written directly in binary code, e.g., 1000100111011000, representing the instruction to move the BX register to AX. This approach is extremely hard to write, read, and modify.

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

2. Assembly Language

Assembly introduced mnemonic symbols to replace raw binary, e.g., mov ax,bx. While clearer than machine code, it remains machine‑oriented and requires separate code for each CPU architecture.

Assembly requires different code for different CPU instruction sets.

3. High‑Level Language

High‑level languages abstract away hardware details. For example, the Lisp expression (+ 4 6) computes 4 + 6 in a single line. Compilers translate such code to machine instructions for various CPUs, allowing developers to write once and run anywhere.

4. Two Software Crises

The first software crisis arose as programs grew in size, leading to low quality and project overruns; structured programming introduced modular, top‑down design to mitigate logical complexity.

The second crisis emerged with rapid hardware advances and increasingly complex business requirements, exposing difficulties in extending software. Object‑oriented programming attempted to address extension complexity but proved only a partial solution.

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

5. Emergence of Software Architecture

As systems scaled, new design challenges appeared: massive internal coupling, low development efficiency, difficulty modifying or extending, and complex logic that is hard to debug. Architecture arose to manage these issues by introducing higher‑level abstractions such as modules, objects, and components.

Huge scale and severe internal coupling lead to low efficiency. Strong coupling makes subsequent modifications and extensions difficult. Complex logic increases the likelihood of bugs and hampers troubleshooting.

Modules, objects, and components represent increasingly coarse granularity for splitting software as its complexity grows.

Modules, objects, and components are ways to partition software at different levels of granularity.

What Is Architecture?

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

An architecture defines the individuals that compose a system—subsystems, modules, components—and the rules governing their interaction.

Key Concepts

System and Subsystem

According to Wikipedia, a system is a group of related entities that operate under rules to achieve capabilities beyond those of individual parts. Subsystems are systems that exist as part of a larger system.

Association: components must be related to form a system. Rules: components operate according to coordinated rules. Capability: the system exhibits emergent abilities not present in individual parts.

Example: WeChat is a system containing subsystems such as chat, login, payment, and Moments; each of those contains further subsystems.

Module and Component

Modules are logical divisions aimed at separating responsibilities, while components are physical units designed for reuse. A component ("component") can be thought of as a replaceable part.

Framework vs. Architecture

A framework defines conventions (the "how"), whereas architecture defines the structural layout (the "what"). For instance, an application may use an MVC architecture while employing an SSH framework.

Redefining Architecture

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

It specifies which individuals (subsystems, modules, components) belong to the system and how they cooperate according to defined rules.

Conclusion

Architecture is a solution to software complexity, requiring trade‑offs among constraints such as team experience, cost, resources, time, and business stage. By analyzing these constraints, architects can design appropriate structures for specific software systems.