BIS301 Software Architecture Overview

Course Information

• Course title: An Awesome Introduction to System Analysis and Design
• Course code: BIS301
• Academic year: 2023
• Lecture notes partly based on material from Ian Sommerville

Software Architecture

• Creating reliable, secure, and efficient software requires careful attention to architectural design, encompassing:
  • Overall system organization
  • Decomposition of software into components
  • Server organization
  • Technologies used in development
• Software architecture significantly influences performance, usability, security, reliability, and maintainability.
• The term "software architecture" has diverse interpretations. Some view it as a noun (system structure), while others consider it a verb (process of defining structures).
• IEEE definition: Architecture is the fundamental organization of a software system embodied in its components, their relationships to each other and to the environment, and the principles guiding its design and evolution.

Software Architecture and Components

• A component is an element implementing a set of functionalities or features.
• A software component can be a collection of one or more services used by other components.
• Architectural design of components doesn't need to specify implementation details. Implementations of interfaces can be handled later.

Why is Architecture Important?

• Architecture fundamentally impacts non-functional system properties (shown in Table 4.2).
• Architectural design involves understanding factors affecting the architecture, and designing a description of critical components and their relations.
• Minimizing complexity is crucial for a maintainable system. Increased system complexity brings increased difficulty and expense for understanding and modification.
• Complex systems are more prone to programmer errors and introduce security vulnerabilities during modifications and extensions.

Non-functional System Quality Attributes

• This is shown in Table 4.2.
  • Responsiveness: Does the system return results in a reasonable time?
  • Reliability: Do system features behave as expected?
  • Availability: Can the system deliver services when needed?
  • Security: Does the system protect itself and user data?
  • Usability: Can users access and utilize features effectively?
  • Maintainability: Can the system be updated easily?
  • Resilience: Can the system continue service during partial failures or external attacks?

Centralized Security Architectures

• Centralized security architectures store all sensitive data in one secure location.
• This approach simplifies security protection by concentrating resources.
• However, a breach in a centralized architecture compromises the entire system.
• A distributed architecture, by contrast, would make a breach significantly more difficult, as it would require security breaches in multiple locations.

Maintainability and Performance

• A shared database architecture (Figure 4.2) can cause performance issues if changes to the database need adjustments in other parts of the system.
• A separate architecture for components with their individual copies of needed database parts resolves dependencies between components and makes maintenance less cumbersome.

Architectural Design Guidelines

• Separation of concerns: Organize components with a focus on one concern.
• Stable interfaces: Design coherent interfaces that change slowly.
• Implement once: Avoid duplicating functionality across different parts of the architecture.

Design Guidelines and Layered Architectures

• Layers represent areas of concern (e.g., user interaction, data retrieval).
• Each layer uses components independent of other layers.
• Lower layers provide general functionalities; higher layers build on those.
• Architectural models are high-level; detail implementation is excluded by the architecture model.
• Ideally, interactions happen between layers and not across layers.

Cross-Cutting Concerns

• Cross-cutting concerns apply system-wide and affect all layers.
• Examples include security, performance, and reliability.
• Modifying a system to improve security can be difficult due to the nature of cross-cutting concerns.

Security as a Cross-Cutting Concern

• Security architecture should have protection at every level.
• Single points of failure in security can compromise the entire system.
• Distributing security efforts across layers increases resilience against vulnerabilities.

Layered Architecture for Web-Based Applications

• Commonly, a web application has layers like browser interface, authentication and user interaction, application functionality, basic shared services, and database management.

iLearn Design Principles

• iLearn aimed to create an adaptable system supporting diverse tools.
• Principles included: replaceability, extensibility, age-appropriate interfaces, programmability, minimum work.

Service-Oriented Architecture

• Service-oriented architectures are stateless and can be replicated.
• This facilitates scalability and resilience to failure.
• Full and partial integration models were used in the iLearn design by establishing component interdependence based on API functionality.

Issues in Architectural Choices

• Data types/updates: consider using shared databases for structured data.
• Change frequency: if components may change often, isolate them as services.
• Execution platform: cloud architecture is often simpler for scaling, in contrast to local multi-tiered architecture.

Technology Choices

• Database technologies (Relational SQL, or NoSQL).
• Platform (mobile app and/or web-based platform).
• Server options (in-house or cloud).

Database Details

• Relational databases organize data in structured tables, suitable for transaction processing where data structure is predictable.
• NoSQL databases provide flexible data models, efficient with "big data" requiring concurrent processing, suitable for data analysis.

Delivery Platform

• Web-based deliverability may require intermittent connection handling and resource optimization.
• In contrast, mobile versions present processor power constraints, battery life limitations, and considerations for on-screen keyboards.

Server Decisions

• Decisions must be made on whether a system is client-server or cloud-based.
• Considerations are needed for consumer-facing applications versus those intended for businesses regarding cloud security considerations and potential predictability (or unpredictability) of usage patterns.

Open Source Software

• The advantage of open source is the availability and ease of reuse.
• Drawbacks include constraints imposed by the software and maintenance obligations to the open source source code.
• Choices should depend on the product type, target market, and development team expertise.

Development Tools

• Frameworks and technologies influence architecture, demanding developer adherence to embedded assumptions.
• Personal experience of development teams with technologies greatly affect decisions on particular architectural choices, either favoring relational databases over NoSQL approaches, or vice-versa.

Key Points Summarized

• Software architecture fundamentally determines a system's organization, interconnections, and evolution methodology.
• Architectural considerations significantly impact non-functional system aspects like security, reliability, and performance.
• Principles like separation of concerns, stable interfaces, and implementation once aid in system design.
• A shared understanding, fostered by informal architectural diagrams, helps development teams coordinate.
• Architecture design usually starts with high-level decomposition, refining to smaller architectural components, that can then be used by the software system.
• Understanding the nature of cross-cutting concerns is very important in software design.
• The choice of technologies, delivery platforms, and execution environment impacts the overall design.