Lecture 1 Flashcards
What is a Software Architecture?
Software architecture is the fundamental structure of a software system, defining how its components interact, how data flows, and how different elements are organized to meet technical and business requirements. It serves as a blueprint for both the system and the project, guiding development and future modifications.
What are constraints in software?
Constraints in software refer to limitations, restrictions, or rules that affect the design, development, and operation of a software system. They define the boundaries within which a system must operate, ensuring that the final product meets technical, business, and user requirements.
Examples :
* Time
* Budget
* Hardware limitations
* Choice of architecture
What is architecting?
Architecting in software development refers to the process of designing, planning, and structuring a software system to ensure it meets technical, business, and user requirements. It involves making high-level design decisions about components, interactions, technologies, constraints, and quality attributes to create a scalable, maintainable, and efficient system.
Lecture definition :
The process of conceiving, defining, expressing, documenting, communicating,
certifying proper implementation of, maintaining and improving an
architecture throughout a system’s life cycle
What is architecture?
The fundamental properties of a system in its environment embodied in its
elements, relationships, and in the principles of its design and evolution
What is architecture?
- work product used to express an architecture
- work products of systems and software architecting
What is architecture viewpoint?
An architecture viewpoint is a perspective or approach used to define, analyze, and document a software system’s architecture. It provides a structured way of looking at the system, focusing on different concerns relevant to specific stakeholders, such as developers, business leaders, security teams, and system administrators.
Think of it like different blueprints for a building—one for electrical wiring, another for plumbing, and another for structural integrity. Each viewpoint highlights certain aspects of the system based on its intended audience.
Lectures definition :
The work product establishing the conventions for the construction,
interpretation and use of architecture views to frame specific
system concerns.
What is architecture view?
An architecture view is a representation of a system from a specific perspective, showing how different components interact based on the concerns of a particular stakeholder. It is the actual output of applying an architecture viewpoint to describe a software system.
Lectures definition :
The work product expressing the architecture of a system from
the perspective of specific system concerns
Views divide a software architecture into a number of interesting
and manageable representations of the system
What is environment?
In the context of software architecture, an environment refers to the physical and virtual infrastructure, configurations, and external conditions in which a software system operates, develops, and is tested. It includes hardware, software, networks, and system dependencies that influence the behavior and performance of an application
Lecture definition :
The context determining the setting and circumstances of all influences
upon a system
How does views and viewpoints relate to each other?
- Viewpoints Define the Perspective, Views Show the System
* A viewpoint is a template or guideline that defines how to structure a view.
* A view is the actual representation of the system based on a viewpoint.
Think of it like architectural blueprints:
* A viewpoint is the rulebook that tells you how to create a blueprint.
* A view is the actual blueprint of a specific building following that rulebook.
- Viewpoints Are General, Views Are Specific
* Viewpoints are reusable and can be applied to many systems.
* Views are system-specific and describe a particular software architecture.
✅ Viewpoints define what aspects of a system to focus on.
✅ Views apply those rules to create system-specific diagrams.
✅ Viewpoints are reusable frameworks, while views are concrete system representations.
What is concern?
In software architecture, a concern is a specific requirement, interest, or issue that a stakeholder has regarding the system. Concerns can be technical, business-related, or operational, and they influence architectural decisions.
Key Characteristics of Concerns
* Stakeholder-driven – Different stakeholders (developers, users, security teams, etc.) have different concerns.
* Multi-dimensional – Concerns can relate to functionality, performance, security, scalability, etc.
* Impact architectural decisions – Addressing concerns helps in choosing the right design, frameworks, and infrastructure.
Lecture definition
Interest in a system relevant to one or more of its stakeholders:
* the purposes of the system;
* the suitability of the architecture for achieving the system’s purposes;
* the feasibility of constructing and deploying the system;
* the potential risks and impacts of the system to its stakeholders
throughout its life cycle;
* maintainability and evolvability of the system
What are stakeholders?
The systems individuals, team, organization, or classes thereof, having an interest in a
system, e.g.,:
- users of the system;
- operators of the system;
- owners of the system;
- suppliers of the system;
- developers of the system;
- maintainers of the system
What is a module view?
What it describes:
* The static structure of the software.
* How the code is organized into modules, components, classes, and packages.
Purpose:
* Helps developers understand code organization and dependencies.
* Supports modularity, reusability, and maintainability.
Examples:
* UML Class Diagrams – Show class relationships, inheritance, and interfaces.
* Component Diagrams – Show how software modules interact.
* Layered Architecture – Separates concerns (e.g., UI, business logic, database).
What is a C&C view?
What it describes:
* The dynamic interactions between system components.
* Communication mechanisms like APIs, message queues, and event flows.
Purpose:
* Helps in designing real-time behavior and runtime interactions.
* Ensures correct communication, concurrency, and synchronization.
Examples:
* Sequence Diagrams – Show how messages flow between objects.
* Microservices Architecture – Shows how services communicate via REST or gRPC.
* Message Queues (e.g., Kafka, RabbitMQ) – Shows event-driven communication.
What is a Allocation view?
What it describes:
* How the software maps to hardware, cloud, and infrastructure.
* How code is deployed and executed in real-world environments.
Purpose:
* Helps DevOps engineers optimize performance, scalability, and resource allocation.
* Ensures proper hardware/software compatibility.
Examples:
* Deployment Diagrams – Show cloud, on-premises, or hybrid deployments.
* Docker & Kubernetes Architecture – Describes containerized applications.
* CI/CD Pipelines – Shows automated build, test, and deployment processes.
What is a quality view?
What it describes:
* How the system meets non-functional requirements like security, performance, reliability, and scalability.
* Architectural trade-offs (e.g., speed vs. security, scalability vs. cost).
Purpose:
* Helps ensure the system meets business goals and SLAs (Service-Level Agreements).
* Supports decision-making in performance tuning, security hardening, and fault tolerance.
Examples:
* Security Architecture – Defines authentication, authorization, and encryption mechanisms.
* Performance Models – Includes load testing strategies and bottleneck analysis.
* Scalability & Fault-Tolerance Plans – How the system handles failures and grows under load.
What is decomposition?
Decomposition is the process of breaking down a complex system into smaller, more manageable parts. This makes it easier to design, develop, test, and maintain software.
What are Architecturally significant requirements?
Architecturally significant requirements (ASRs) are the
requirements that you must satisfy with the design
– There are a small number of these
– They are the most important (by definition)
What are Architectural Patterns?
Architectural patterns are reusable solutions to common architectural problems in software design. They define how software components should be structured and interact to meet specific requirements.
What are design patterns?
Design patterns are reusable solutions to common problems in software design. They provide proven, best-practice approaches to structuring code to improve maintainability, flexibility, and scalability.
How does Architectural patterns and design patterns differ?
Unlike design patterns (which focus on individual components), architectural patterns shape the overall system structure and affect scalability, performance, maintainability, and flexibility.
