What Is Software Architecture? Principles, Patterns, and Real‑World Design

What Is Architecture

Architecture, originally a high‑level term, describes the overall structure of a system and the relationships between its elements. In software it is an abstract description of the whole system and its components, guiding design decisions and linking business needs to technical implementation.

Why Architecture Matters

Good architecture starts from clear business scenarios, defines usage rules and constraints, provides basic capabilities, and ensures safety, performance, and maintainability. It must evolve with changing business requirements.

Design Principles

The article outlines the SOLID principles and additional guidelines:

SRP (Single Responsibility Principle) : each function or module should have one responsibility.

OCP (Open‑Closed Principle) : modules should be extensible without modification.

LSP (Liskov Substitution Principle) : sub‑types must be replaceable for their base types without altering behavior. Example code demonstrates violations using a Rectangle and Square hierarchy and a Bird / Ostrich hierarchy.

ISP (Interface Segregation Principle) : avoid forcing clients to depend on interfaces they do not use.

DIP (Dependency Inversion Principle) : depend on abstractions rather than concrete implementations.

Ockham’s Razor : prefer the simplest solution that sufficiently solves the problem.

Common Architectural Styles

Layered Architecture : organizes code into layers (typically 3‑4), with higher layers depending only on lower ones. Strict layering limits cross‑layer access, while loose layering allows any lower layer to be used.

Hexagonal (Ports‑and‑Adapters) Architecture : separates core business logic (inside) from external concerns (outside) via interfaces and dependency injection.

Onion (Clean) Architecture : builds on hexagonal ideas, adding domain models, services, and infrastructure layers, keeping dependencies pointing inward.

Domain‑Driven Design (DDD) : focuses on modeling the core business domain, defining bounded contexts, entities, value objects, aggregates, and using these concepts to drive the architecture.

Our Practical Architecture – The “Eagle Nest” Project

The team responsible for a navigation engine (named "Eagle Nest") reorganized its codebase using DDD and a loosely‑coupled layered approach. The resulting four‑layer structure consists of:

Foundation capabilities

Business layer (organized by sub‑domains)

Tool layer

Integration layer (interfacing with front‑end JavaScript)

Images illustrate the overall structure and the abstract interface layers (e.g., InterfaceMap, InterfaceTBT) introduced during an engine upgrade. By depending on these abstract interfaces, higher‑level modules remain stable even when lower‑level implementations change, giving the system characteristics of a clean architecture while still being a loosely‑coupled layered system.

Key Takeaways

Architecture design is not a rigid set of rules but a collection of guiding principles that help avoid unnecessary complexity, keep code maintainable, and align technical solutions with business goals. Understanding the problem domain and applying appropriate principles—while remaining pragmatic—are essential for building flexible, evolvable systems.

class Rectangle {
    public:
        int32_t getWidth() const { return width; }
        int32_t getHeight() const { return height; }
        virtual void setWidth(int32_t w) { width = w; }
        virtual void setHeight(int32_t h) { height = h; }
    private:
        int32_t width = 0;
        int32_t height = 0;
};

class Square : public Rectangle {
    public:
        void setWidth(int32_t w) override {
            Rectangle::setWidth(w);
            Rectangle::setHeight(w);
        }
        void setHeight(int32_t h) override {
            // ...
        }
};

void reSize(Rectangle rect) {
    while (rect.getHeight() <= rect.getWidth()) {
        rect.setHeight(rect.getWidth() + 1);
    }
}

class Bird {
    public:
        int32_t getVelocity() const { return velocity; }
    private:
        int32_t velocity = 0; // flying speed
};

class Ostrich : public Bird { };

void crossRiver(Bird bird) {
    int32_t distance = 1000;
    int32_t elapsed = distance / bird.getVelocity();
}