Understanding Software Architecture: History, Concepts, and Principles

In software development, many programmers aspire to become competent architects, yet the transition from coding to high‑level design can be challenging.

Architecture is not a mysterious artifact; anyone can practice it, often without realizing it.

1. Machine Language

The earliest software was written in machine language, using binary codes such as 1000100111011000 to move data between registers.

Machine language is hard to write, read, and modify.

2. Assembly Language

Assembly introduced symbolic mnemonics to replace raw binary, e.g., mov ax,bx , making code clearer but still tied to specific CPU architectures.

Assembly requires separate code bases for different CPUs.

3. High‑Level Languages

High‑level languages abstract away hardware details, allowing developers to focus on business logic. For example, the Lisp expression (+ 4 6) computes a sum in a single line, and the same source can be compiled for various CPUs.

4. Two Software Crises

The first crisis arose from growing code size and low quality, exemplified by the 1963 FORTRAN error that caused a rocket failure. Structured programming introduced top‑down, modular design to mitigate this.

The second crisis stemmed from rapid hardware advancement and increasing business complexity, leading to difficulties in extending software. Object‑oriented programming attempted to address this but proved only a partial solution.

5. Emergence of Software Architecture

As systems grew, new design problems appeared: massive internal coupling, low development efficiency, and difficulty in modification and debugging. Architecture emerged to manage these challenges, introducing the concepts of modules, objects, and components.

Modules, objects, and components all aim to partition large software, differing only in granularity and abstraction level.

What Is Architecture?

Architecture defines the top‑level structure of a software system, specifying which subsystems, modules, or components exist and how they interact according to defined rules.

System vs. Subsystem

A system is a set of related elements that work together under rules to achieve capabilities beyond any single element. A subsystem is simply a system that forms part of a larger system.

Related elements form a system. Rules govern their cooperation. The system exhibits capabilities not present in individual elements.

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

Module vs. Component

Modules are logical partitions for responsibility separation, while components are physical units designed for reuse and replaceability.

Framework vs. Architecture

A framework defines conventions (the "how"), whereas architecture defines structure (the "what"). For instance, "using MVC architecture" describes the system's structure, while "using SSH framework" describes the development conventions.

Redefining Architecture

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

It identifies the constituent parts (systems, subsystems, modules, components) and the rules governing their interaction.

Summary

Architecture is a solution to software system complexity, requiring trade‑offs among constraints such as team experience, cost, resources, time, and business stage to design an appropriate structure for a given system.

Author: 猿码架构 Source: https://www.jianshu.com/p/312af3e8b94a