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.

This quiz covers the essential concepts of software architecture as outlined in the course 'An Awesome Introduction to System Analysis and Design'. It delves into system organization, component decomposition, and the significance of architectural design in software performance and security. Additionally, it explores the diverse interpretations of software architecture as both a noun and a verb.