Critical Systems: Challenges and Development Strategies
Week 1: Critical Systems
Emerging Challenges
- Reliability: Ensuring consistent performance under specified conditions.
- Security: Safeguarding against unauthorized access and attacks.
- Trustworthiness and Privacy: Maintaining the confidentiality of user data and ensuring that the system behaves in a trustworthy manner.
- Intuitive User Interface and New Platforms: Enhancing user interaction and adapting to emerging technology platforms.
Mitigating System Failures
System failures can be prevented or mitigated through several strategies:
- Fault Prevention: Implementing robust design and development practices to prevent faults.
- Fault Tolerance: Designing systems to continue operation, possibly at a reduced level, even when faults occur.
- Fault Removal: Detecting and correcting faults before the system is deployed.
- Fault Forecasting: Predicting the occurrence of faults to mitigate their impact proactively.
V Model of Software Development
The V Model is a structured software development approach that demonstrates the relationships between each phase of the development life cycle and its associated phase of testing. The model includes:
- Requirement Analysis: Linked to Acceptance Testing.
- Architectural Design: Linked to System Tests.
- Subsystem Design: Linked to Integration Tests.
- Implementation: Linked to Unit Tests.
Design and Quality Metrics
- Coupling: This metric assesses the degree of interdependence between software modules. Lower coupling is often preferable as it indicates a more modular design.
- Cohesion: Reflects how closely related and focused the various responsibilities of a single module are. Higher cohesion within a module is generally desirable.
Principles to Mitigate Bugs
- Principle of Least Expressive Power: Choose the simplest technology capable of completing the task effectively.
- Principle of Least Privilege: Restrict access to what is necessary to perform the required tasks.
- Principle of Least Surprise: Design systems that meet user expectations.
- Principle of Least Effort and Energy: Apply principles like KISS (Keep It Simple, Stupid), YAGNI (You Aren’t Gonna Need It), and DRY (Don’t Repeat Yourself) to reduce complexity.
Object-Oriented Programming Principles
- Inheritance, Polymorphism, Abstraction, Encapsulation: Fundamental OO principles that help in creating flexible and maintainable code.
- Messaging, Late Binding and Encapsulation of State: Highlighted by Alan Kay as essential for OO design.
Functional Programming Principles
- First-Class Functions, Immutability, Pure Functions: These principles support the creation of predictable and bug-resistant code.
- Type Systems: Although not required, they are commonly applied to improve code safety and predictability.
Maintaining Robust Software Systems
Key strategies include fault isolation, error recovery, replication, and redundancy. The focus is on creating systems that can handle failures gracefully and maintain operational continuity.
- Verification: Checks if the software conforms to its specified functionality.
- Validation: Ensures the software meets the needs and expectations of its users.
Attributes of Dependable Software
A dependable system should exhibit qualities such as availability, reliability, safety, integrity, confidentiality, and maintainability. These attributes help in defining how the system is perceived by its users and how well it can adapt to changing conditions or requirements.