Software Engineering Lecture

Chapter 2 (midterms)

Software Engineering

is an intellectual activity and thus human-intensive

Software

is built to meet a certain functional goal and satisfy certain qualities

Software processes

also must meet certain qualities

Software qualities

are sometimes referred to as “ilities'‘

Software Product

Different from traditional types of products

Intangible

– something that can be touched or felt. (hardware)​

• difficult to describe and evaluate

Malleable

easily influenced or controlled by other people. (software)​

human intensive

needs a lot of people to do the work involved. (peopleware)​

1. Internal Vs. External

2. Product Vs. Process

• Internal qualities affect external qualities​

• Process quality affects product quality

Classification of sw qualities​ "ilities"​

Internal Vs. External

• External - visible to users​

• Internal - concern developers

Product Vs. Process

• Our goal is to develop software products​

• The process is how we do it

1. Maintainability

2. Flexibility

3. Scalability

4. Performance

5. Reliability

6. Security

7. Testability

Internal Qualities of a Software are?

Maintainability

How easily the software can be maintained, modified, or extended without introducing errors.

This includes aspects like:

1. code readability

1. modularity

2. documentation

Flexibility

The ability of the software to adapt to changing requirements or environments without extensive modifications.

This often relates to the architecture and design choices made during development.​

Scalability

The ability of the software to handle increasing amounts of work or users without sacrificing performance.

Scalability is often a concern for large-scale systems.​

Performance

How efficiently the software executes its tasks, including factors like speed, responsiveness, and resource utilization

(internal )Reliability

The degree to which the software performs its intended functions consistently and accurately under varying conditions.

Security

The measures taken to protect the software from unauthorized access, data breaches, and other security threats.​

Testability

How easily the software can be tested to ensure that it behaves as expected and meets its requirements. This includes aspects like the presence of automated tests and the ease of setting up test environments.​

1. Usability

2. Accessibility

3. Performance

4. Reliability

5. Compatibility

6. Portability

7. Aesthetics

external qualities of a software are?

Usability

The ease with which users can interact with the software to achieve their goals. This includes factors like intuitiveness, learnability, and efficiency of use.

Accessibility

The degree to which the software can be used by people with disabilities, including considerations for factors like screen readers, keyboard navigation, and color contrast.

Performance

While performance is also an internal quality, it's worth mentioning here as it directly affects the user experience. External performance refers to how responsive and fast the software feels to users.

(external) Reliability

Similarly, external reliability relates to how consistently the software performs for end-users, without crashes, errors, or unexpected behavior.

Compatibility

The ability of the software to work seamlessly with other systems, platforms, or devices, ensuring a smooth experience for users regardless of their environment.

Portability

How easily the software can be transferred or deployed across different environments, platforms, or devices, without significant modifications.

Aesthetics

The visual design and appeal of the software, including aspects like layout, typography, color scheme, and graphical elements.

correctness of software

refers to its ability to perform its intended functions accurately and reliably, according to its specifications and requirements.

1. if it satisfies the functional requirements specifications

2. If specifications are formal, since programs are formal objects

Software is correct if:

1. Functional Requirements

2. Validation and Verification

3. Boundary and Error Handling

4. Consistency and Data Handling

5. Concurrency and Multithreading

6. Regression Testing

7. Documentation and Compliance

key aspects that contribute to the correctness of software:​

Functional Requirements

Software correctness starts with meeting its functional requirements. These are the specific behaviors and capabilities that the software is supposed to exhibit.

Validation and Verification

Validation ensures that the software meets the user's needs and expectations, while verification ensures that the software meets its specified requirements. Both processes involve testing the software through various methods such as unit testing, integration testing, system testing, and acceptance testing to identify and correct errors.​

Boundary and Error Handling

Correct software should handle both normal and exceptional conditions effectively. It should gracefully handle boundary cases and edge conditions without crashing or producing incorrect results. Proper error handling ensures that unexpected inputs or situations are managed appropriately, preventing the software from entering an inconsistent or erroneous state.​

Consistency and Data Integrity

Software correctness also involves maintaining consistency and integrity of data throughout its lifecycle. This includes proper handling of data validation, storage, retrieval, and manipulation to ensure that data remains accurate and reliable.​

Concurrency and Multithreading

In multi-threaded or concurrent systems, correctness involves ensuring that shared resources are accessed and modified safely and that race conditions, deadlocks, and other concurrency-related issues are avoided or mitigated effectively.​

Regression Testing

As software evolves through updates and enhancements, it's essential to conduct regression testing to ensure that existing functionality remains correct after changes are made. Regression testing helps detect unintended side effects or regressions introduced by new code.​

Documentation and Compliance

Comprehensive documentation helps ensure that developers, testers, and other stakeholders have a clear understanding of the software's intended behavior and how it should be used. Compliance with relevant standards, regulations, and best practices also contributes to the correctness of software, particularly in safety-critical or regulated domains.​

1. yes/no qualities

2. what if specifications are wrong?

The limits of correctness:

Reliability

1. informally, user can rely on it​

2. can be defined mathematically as “probability of absence of failures for a certain time period”

3. if specs are correct, all correct software is reliable, but not vice-versa (in practice, however, specs can be incorrect …)​

Robustness

software behaves “reasonably” even in unforeseen circumstances (e.g., incorrect input, hardware failure)​

1. Error Handling

2. Input Validation

3. Graceful Degradation

4. Resilience to External Dependencies

5. Security Measures

6. Concurrency and Multithreading

7. Fault Tolerance

8. Testing and Quality Assurance

key aspects that contribute to the robustness of software:​

Error Handling

obust software includes comprehensive error handling mechanisms to detect and manage unexpected situations. This involves catching errors, exceptions, or faults and responding to them appropriately, such as logging the error, providing informative error messages, and taking corrective actions to recover from the error state.​

Input Validation

Robust software validates input data to ensure that it meets expected criteria and does not cause unexpected behavior or vulnerabilities. This includes checking for data type mismatches, boundary conditions, format compliance, and potential security risks such as injection attacks or buffer overflows.​

Graceful Degradation

Robust software gracefully handles degradation in performance or functionality under adverse conditions, such as high load, network failures, or resource constraints. It may prioritize critical operations, throttle requests, or provide alternative functionality to maintain essential services even in degraded states.

Resilience to External Dependencies

Software often relies on external dependencies such as libraries, APIs, or services. Robust software minimizes the impact of failures or changes in these dependencies by implementing fallback mechanisms, retry strategies, caching, or alternative providers to maintain continuity of operation.​​

Security Measures

Robust software incorporates security measures to protect against malicious attacks, unauthorized access, and data breaches. This includes implementing encryption, access controls, authentication mechanisms, and security patches to mitigate vulnerabilities and threats.

Concurrency and Multithreading

In concurrent or multi-threaded systems, robustness involves managing shared resources and synchronization effectively to prevent race conditions, deadlocks, and other concurrency-related issues. Proper thread management, locking strategies, and synchronization primitives help maintain system integrity and stability.

Fault Tolerance

Robust software designs include provisions for fault tolerance, allowing the system to continue functioning even in the presence of hardware failures, software bugs, or other faults. This may involve redundancy, replication, failover mechanisms, and distributed architectures to ensure uninterrupted operation and data integrity.​

Testing and Quality Assurance

Robust software undergoes rigorous testing and quality assurance processes to identify and address vulnerabilities, bugs, and edge cases that could compromise its stability and functionality. This includes unit testing, integration testing, system testing, and user acceptance testing to validate robustness across different levels and scenarios.​

Performance

Efficient use of Resources

• memory, processing time, communication

Usability

• Expected users find the system easy to use​

• Other term: user-friendliness​

• Rather subjective, difficult to evaluate​

• Affected mostly by user interface​

  • e.g., visual vs. textual

Verifiability

• How easy it is to verify properties​

  • mostly an internal quality​

  • can be external as well (e.g., security critical application)

Maintainability

ease of maintenance

maintenance

changes after release

maintenance cost

exceeds 60 % of total cost of software

1. corrective: removing residual errors (20%)

2. adaptive: adjusting to environment changes (20%)

3. perfective: quality imporvements (>50%)

The Three main Categorues of Maintenance:

Repairability

ability to correct defects in reasonable time

Evolvability

ability to adapt sw to environment changes and to improve it in reasonable time

Reusability

existing product used to build another products

portability

software can run on different hw platforms and sw environments

Understandability

Ease of understanding Software

Program modification requires program understanding

Interoperability

• Ability of a system to coexist and cooperate with other systems ​

  • e.g., word processor and spreadsheet​

• Productivity​

  • denotes its efficiency and performance​

• Timeliness​

  • ability to deliver a product on time​

• Visibility​

  • all of its steps and current status are documented clearly

Typical process qualities

Timeliness: issues

1. development process does not follow user requirements

2. mismatch between user reqs and status of product

Application-specific qualities

• E.g., information systems​

  • Data integrity​

  • Security​

  • Data availability​

  • Transaction performance

Quality Measurement

1. subjective

2. no standard metrics defined for most qualities