{
  "id": "enwiki-001373741216",
  "slug": "software-architecture",
  "title": "Software architecture",
  "qid": "",
  "lead": "Software architecture is the set of structures needed to reason about a software system and the discipline of creating such structures and systems. Each structure comprises software elements, relations among them, and properties of both elements and relations. The architecture of a software system is a metaphor, analogous to the architecture of a building. It functions as the blueprints for the system and the development project, which project management can later use to extrapolate the tasks necessary to be executed by the teams and people involved. Software architecture is about making fundamental structural choices that are costly to change once implemented. Software architecture choices include specific structural options from possibilities in the design of the software. There are two fundamental laws in software architecture: # Everything is a trade-off # \"Why is more important than how\" \"Architectural Kata\" is a teamwork which can be used to produce an architectural solution that fits the needs. Each team extracts and prioritizes architectural characteristics (aka non functional requirements) then models the components accordingly. The team can use C4 Model which is a flexible method to model the architecture just enough. Note that synchronous communication between architectural components entangles them and they must share the same architectural characteristics.…",
  "body": "Software architecture is the set of structures needed to reason about a software system and the discipline of creating such structures and systems. Each structure comprises software elements, relations among them, and properties of both elements and relations. The architecture of a software system is a metaphor, analogous to the architecture of a building. It functions as the blueprints for the system and the development project, which project management can later use to extrapolate the tasks necessary to be executed by the teams and people involved. Software architecture is about making fundamental structural choices that are costly to change once implemented. Software architecture choices include specific structural options from possibilities in the design of the software. There are two fundamental laws in software architecture: Everything is a trade-off \"Why is more important than how\" \"Architectural Kata\" is a teamwork which can be used to produce an architectural solution that fits the needs. Each team extracts and prioritizes architectural characteristics (aka non functional requirements) then models the components accordingly. The team can use C4 Model which is a flexible method to model the architecture just enough. Note that synchronous communication between architectural components entangles them and they must share the same architectural characteristics. Documenting software architecture facilitates communication between stakeholders, captures early decisions about the high-level design, and allows the reuse of design components between projects. Software architecture design is commonly juxtaposed with software application design. Whilst application design focuses on the design of the processes and data supporting the required functionality (the services offered by the system), software architecture design focuses on designing the infrastructure within which application functionality can be realized and executed such that the functionality is provided in a way which meets the system's non-functional requirements. Software architectures can be categorized into two main types: monolith and distributed architecture, each having its own subcategories. Software architecture tends to become more complex over time. Software architects should use \"fitness functions\" to continuously keep the architecture in check. ==Scope== Opinions vary as to the scope of software architectures: Macroscopic system structure: this refers to architecture as a higher-level abstraction of a software system that consists of a collection of computational components together with connectors that describe the interaction between these components. The important stuff—whatever that is: this refers to the fact that software architects should concern themselves with those decisions that have high impact on the system and its stakeholders. That which is fundamental to understanding a system in its environment Things that people perceive as hard to change: since designing the architecture takes place at the beginning of a software system's lifecycle, the architect should focus on decisions that \"have to\" be right the first time. Following this line of thought, architectural design issues may become non-architectural once their irreversibility can be overcome. A set of architectural design decisions: software architecture should not be considered merely a set of models or structures, but should include the decisions that lead to these particular structures, and the rationale behind them. This insight has led to substantial research into software architecture knowledge management. There is no sharp distinction between software architecture versus design and requirements engineering (see Related fields below). They are all part of a \"chain of intentionality\" from high-level intentions to low-level details. ==History== The comparison between software design and (civil) architecture was first drawn in the late 1960s, but the term \"software architecture\" did not see widespread usage until the 1990s. The field of computer science had encountered problems associated with complexity since its formation. Earlier problems of complexity were solved by developers by choosing the right data structures, developing algorithms, and by applying the concept of separation of concerns. Although the term \"software architecture\" is relatively new to the industry, the fundamental principles of the field have been applied sporadically by software engineering pioneers since the mid-1980s. Early attempts to capture and explain software architecture of a system were imprecise and disorganized, often characterized by a set of box-and-line diagrams. Software architecture as a concept has its origins in the research of Edsger Dijkstra in 1968 and David Parnas in the early 1970s. These scientists emphasized that the structure of a software system matters and getting the structure right is critical. During the 1990s there was a concerted effort to define and codify fundamental aspects of the discipline, with research work concentrating on architectural styles (patterns), architecture description languages, architecture documentation, and formal methods. Research institutions have played a prominent role in furthering software architecture as a discipline. Mary Shaw and David Garlan of Carnegie Mellon wrote a book titled Software Architecture: Perspectives on an Emerging Discipline in 1996, which promoted software architecture concepts such as components, connectors, and styles. The University of California, Irvine's Institute for Software Research's efforts in software architecture research is directed primarily in architectural styles, architecture description languages, and dynamic architectures. IEEE 1471-2000, \"Recommended Practice for Architecture Description of Software-Intensive Systems\", was the first formal standard in the area of software architecture. It was adopted in 2007 by ISO as ISO/IEC 42010:2007. In November 2011, IEEE 1471–2000 was superseded by ISO/IEC/IEEE 42010:2011, \"Systems and software engineering – Architecture description\" (jointly published by IEEE and ISO). While in IEEE 1471, software architecture was about the architecture of \"software-intensive systems\", defined as \"any system where software contributes essential influences to the design, construction, deployment, and evolution of the system as a whole\", the 2011 edition goes a step further by including the ISO/IEC 15288 and ISO/IEC 12207 definitions of a system, which embrace not only hardware and software, but also \"humans, processes, procedures, facilities, materials and naturally occurring entities\". This reflects the relationship between software architecture, enterprise architecture and solution architecture. ==Architecture activities== Making architectural decisions involves collecting sufficient relevant information, providing justification for the decision, documenting the decision and its rationale, and communicating it effectively to the appropriate stakeholders. It's software architect's responsibility to match architectural characteristics (aka non-functional requirements) with business requirements. For example: Having a high customer satisfactions requires availability, fault tolerance, security, testability, recoverability, agility and performance in the system. Doing mergers and acquisitions (M&A) requires extensibility, scalability, adaptability, and interoperability Constrained budget and time requires feasibility and simplicity Faster time-to-market requires maintainability, testability and deployability. There are four core activities in software architecture design. These core architecture activities are performed iteratively and at different stages of the initial software development life-cycle, as well as over the evolution of a system. Architectural analysis is the process of understanding the environment in which a proposed system will operate and determining the requirements for the system. The input or requirements to the analysis activity can come from any number of stakeholders and include items such as: what the system will do when operational (the functional requirements) how well the system will perform runtime non-functional requirements such as reliability, operability, performance efficiency, security, compatibility defined in ISO/IEC 25010:2011 standard development-time of non-functional requirements such as maintainability and transferability defined in ISO 25010:2011 standard business requirements and environmental contexts of a system that may change over time, such as legal, social, financial, competitive, and technology concerns The outputs of the analysis activity are those requirements that have a measurable impact on a software system's architecture, called architecturally significant requirements. Architectural synthesis or design is the process of creating an architecture. Given the architecturally significant requirements determined by the analysis, the current state of the design and the results of any evaluation activities, the design is created and improved. Architecture evaluation is the process of determining how well the current design or a portion of it satisfies the requirements derived during analysis. An evaluation can occur whenever an architect is considering a design decision, it can occur after some portion of the design has been completed, it can occur after the final design has been completed or it can occur after the system has been constructed. Some of the available software architecture evaluation techniques include Architecture Tradeoff Analysis Method (ATAM) and TARA. Frameworks for comparing the techniques are discussed in frameworks such as SARA Report and Architecture Reviews: Practice and Experience. Architecture evolution is the process of maintaining and adapting an existing software architecture to meet changes in requirements and environment. As software architecture provides a fundamental structure of a software system, its evolution and maintenance would necessarily impact its fundamental structure. As such, architecture evolution is concerned with adding new functionality as well as maintaining existing functionality and system behavior. Architecture requires critical supporting activities. These supporting activities take place throughout the core software architecture process. They include knowledge management and communication, design reasoning and decision-making, and documentation. ==Related fields== ==See also== ==References== ==External links== Explanation on IBM Developerworks Collection of software architecture definitions at Software Engineering Institute (SEI), Carnegie Mellon University (CMU) International Association of IT Architects (IASA Global), formerly known as the International Association for Software Architects (IASA) SoftwareArchitecturePortal.org – website of IFIP Working Group 2.10 on Software Architecture SoftwareArchitectures.com – an independent resource of information on the discipline Software Architecture, chapter 1 of Roy Fielding's REST dissertation When Good Architecture Goes Bad The Spiral Architecture Driven Development – the SDLC based on the Spiral model aims to reduce the risks of ineffective architecture Software Architecture Real Life Case Studies",
  "categories": [
    "115721027",
    "21493616",
    "22919411",
    "23117742",
    "23118434",
    "23603337",
    "24623845",
    "28269683",
    "31127017"
  ],
  "license": "CC BY-SA 4.0",
  "source_uri": "https://en.wikipedia.org/w/index.php?oldid=1373741216",
  "content_hash": "",
  "created_at": null,
  "updated_at": 1788796137.0,
  "claims": [],
  "contradictions": [],
  "confidence": 0.6,
  "csl": {
    "id": "enwiki-001373741216",
    "type": "webpage",
    "title": "Software architecture",
    "author": [
      {
        "family": "Anticloud FZ LLE",
        "literal": "Anticloud FZ LLE"
      }
    ],
    "container-title": "encyclopegia.org",
    "publisher": "Anticloud FZ LLE",
    "publisher-place": "Dubai, United Arab Emirates",
    "URL": "https://encyclopegia.org/a/software-architecture",
    "issued": {
      "date-parts": [
        [
          2026,
          11,
          21
        ]
      ]
    },
    "accessed": {
      "date-parts": [
        [
          2026,
          11,
          21
        ]
      ]
    },
    "license": "CC BY-SA 4.0",
    "DOI": "eo1:enwiki-001373741216",
    "isBasedOn": "https://en.wikipedia.org/w/index.php?oldid=1373741216",
    "note": "Immutable snapshot enwiki-001373741216"
  }
}