Architecture
A high-level plan or design of a system, outlining its components, their relationships, and the principles governing its design and evolution.
First used·1950s-1960s
Definitions·3
Synonyms·3
Category·Software Engineering
Also known as
Definitions
What it means.
- 01
Software Architecture
In the context of software engineering, architecture refers to the fundamental organization of a software system, embodied in its components, their relationships to each other and the environment, and the principles governing its design and evolution. It's the high-level blueprint that dictates how the system is structured and how its parts interact.
Key Concepts
- Components: The primary building blocks of the system (e.g., modules, classes, services, layers).
- Connectors: The mechanisms that mediate communication, coordination, or cooperation among components (e.g., function calls, message queues, APIs).
- Constraints: The rules and guidelines that must be followed (e.g., "the presentation layer cannot directly access the data layer").
- Architectural Styles/Patterns: Reusable solutions to common problems (e.g., Microservices, Layered, Client-Server, Event-Driven). A synonym for this is system structure.
Example
A web application might use a three-tier architecture, separating the system into a Presentation Tier (UI), a Logic Tier (business logic), and a Data Tier (database). This structure helps in managing complexity and allows teams to work on different tiers independently.
Usage
A good software blueprint is crucial for managing complexity, facilitating communication among stakeholders, and ensuring the system meets its quality attributes (like performance, security, and maintainability).
- 02
Computer Architecture
In the context of computer engineering, architecture (often called computer organization or instruction set architecture - ISA) defines the functional behavior of a computer system as seen by a programmer. It includes the instruction set, memory addressing modes, processor registers, and data types.
Key Concepts
- Instruction Set Architecture (ISA): The part of the processor that is visible to the programmer or compiler writer. It's the boundary between software and hardware. Examples include x86, ARM, and RISC-V.
- Microarchitecture: The internal implementation of the ISA. The same ISA can be implemented with different microarchitectures, leading to different performance and power characteristics (e.g., Intel's Core i7 and Atom processors both implement the x86 ISA but have vastly different microarchitectures).
Example
The ARM architecture is widely used in mobile devices due to its power efficiency, while the x86 architecture dominates desktop and server markets.
Usage
The choice of computer architecture has profound implications for software compatibility, performance, and power consumption.
- 03
System Architecture
This is a broader term that encompasses the entire structure of a complex system, which may include hardware, software, data, and people. System architecture, a synonym for system design, defines the components, modules, interfaces, and data for a system to satisfy specified requirements.
Key Concepts
- Holistic View: Considers all aspects of the system, including hardware, software, network infrastructure, and user interactions.
- Stakeholder Concerns: Aims to address the needs and concerns of all stakeholders, from users and developers to business owners and operators.
Example
The system architecture for an e-commerce platform would include not just the software components (web servers, databases, payment gateways) but also the hardware infrastructure (servers, load balancers), network configuration, and security protocols.
Usage
It serves as the master plan for developing and deploying complex systems, ensuring all parts work together cohesively.
Origin
Where it comes from.
Etymology
From the Latin "architectura," derived from the Greek "arkhitekton" (arkhi- 'chief' + tekton 'builder'). It originally referred to the art and science of designing buildings and other physical structures. Its use in computing began metaphorically to describe the design of complex software and hardware systems.
Historical context
The term's application to computing began in the mid-20th century, evolving significantly with the complexity of technology.
-
1950s-1960s: The term architecture was famously used by the designers of the IBM System/360, including Fred Brooks. They used it to describe the formal specification of the computer's instruction set and hardware capabilities. This innovative approach allowed different models with varying performance and cost to run the same software, establishing the concept of a computer family with a common architecture.
-
1970s-1980s: As software systems grew in complexity, the term expanded to encompass software architecture. Concepts like structured programming and modular design laid the groundwork. David Parnas's work on information hiding and modularization was pivotal, emphasizing the importance of well-defined interfaces between software components.
-
1990s: The field of software architecture became more formalized. The book "Software Architecture in Practice" by Len Bass, Paul Clements, and Rick Kazman (1998) became a foundational text. Architectural patterns and styles (e.g., client-server, layered, pipe-and-filter) were cataloged and studied. The rise of object-oriented programming further influenced architectural thinking, solidifying the idea of a software blueprint.
-
2000s-Present: The advent of the internet, distributed systems, and cloud computing led to new architectural styles like Service-Oriented Architecture (SOA) and, more recently, Microservices. The focus shifted towards concerns like scalability, resilience, and maintainability in large-scale, distributed environments. The role of the "Software Architect" became a distinct and crucial position in many organizations, responsible for the overall system structure.
Usage
In context.
In a software context, the team decided on a microservices architecture to improve scalability and allow for independent deployment of services.
Before writing any code, the senior engineers spent weeks defining the system's software blueprint to ensure it would meet the non-functional requirements.
In a hardware context, the ARM architecture is dominant in mobile phones because of its low power consumption.
A well-documented system structure is essential for onboarding new developers and maintaining the application over the long term.
FAQ
Common questions.
Software architecture is the high-level structure of the entire system, defining its major components and their interactions. A design pattern is a reusable solution to a commonly occurring problem within a given context in software design; it's a smaller-scale solution that can be applied within the overall architecture.
Taxonomy
Filed under.
Categories
Tags