Software Engineering Series Article Two

Software Life Cycle

1. Feasibility Analysis and Project Development Plan
2. Requirements Analysis
3. High-Level Design
4. Detailed Design
5. Coding
6. Testing
7. Maintenance

Software Requirements

Before gathering requirements, clarify what needs to be collected, i.e., what requirements include. Software requirements are the user’s expectations for the target software system in terms of functionality, behavior, performance, design constraints, and so on.

1. Functional Requirements. Think about what the system needs to do, when, and how it will be modified or upgraded.
2. Performance Requirements. Consider the technical metrics for software development. For example, storage capacity limits, execution speed, response time, and throughput.
3. User or Human Factors. Think about user types. For example, users’ computer proficiency, required training, difficulty in understanding/using the system, and the possibility of user errors.
4. Environmental Requirements. Consider the future software application environment, including hardware and software. Hardware requirements include model, peripherals, interfaces, location, distribution, humidity, magnetic interference, etc.; software requirements include operating systems, networks, databases, etc.
5. Interface Requirements. Consider inputs from other systems, outputs to other systems, specific rules for data formats, and regulations for data storage media.
6. Documentation Requirements. Think about what documents are needed and who the target readers are.
7. Data Requirements. Consider input/output data formats, data receiving/sending frequency, data accuracy and precision, data flow, and data retention period.
8. Resource Usage Requirements. Think about resources needed during software runtime, such as data, other software, memory space; and resources needed for software development and maintenance, like personnel, support software, development equipment, etc.
9. Security and Confidentiality Requirements. Consider whether access to the system or system information needs control, methods for isolating user data, how user programs are isolated from other programs and the OS, and system backup requirements, etc.
10. Reliability Requirements. Consider system reliability requirements, whether the system must detect and isolate errors; and the allowable time to restart the system after an error.
11. Software Cost and Development Schedule Requirements. Consider if development has a defined timeline, and if there are soft/hardware investment limitations, etc.
12. Other Non-Functional Requirements. Such as adopting a specific development model, defining quality control standards, milestones, reviews, acceptance criteria, priority of various quality requirements, and maintainability requirements.

System Design

The main goal of system design is to blueprint the system. This means weighing pros and cons across various technologies and implementation methods, designing carefully, utilizing resources efficiently, and finally outlining the detailed design plan for the new system.

High-Level Design

Developers transform the identified functional requirements into the necessary system architecture.

1. Designing the Overall Software System Structure

The core task is to use a design method to break down a complex system into functional modules; define each module’s function; determine calling relationships between modules; define module interfaces, i.e., information passed between modules; and evaluate the quality of the module structure.

Designing the overall software system structure is a critical step in high-level design, directly impacting the detailed design and coding in the next phase. The quality and overall characteristics of the software system are determined during the design of its overall structure.

2. Data Structure and Database Design

(1) Data Structure Design

The progressive refinement method also applies to data structure design. In the requirements analysis phase, data composition, operational constraints, and relationships between data were described via data dictionaries, defining the data’s structural characteristics. This needs refinement in the high-level design phase, with concrete implementation details specified in the detailed design phase. During high-level design, using abstract data types is recommended.

(2) Database Design

Database design refers to the design of data storage files, primarily involving these aspects:

1. Conceptual Design. Based on data analysis, a bottom-up approach is used for view design from the user’s perspective, typically using E-R models to represent the data model. The E-R model is fundamental for both database and data structure design.
2. Logical Design. E-R models are DBMS-independent. The logical structure of the database must be built by considering the specific characteristics of the DBMS.
3. Physical Design. Different DBMSs have different physical environments, storage structures, and access methods. Physical design involves detailing the physical aspects of the data schema, such as data item storage requirements, access methods, and index creation.

3. Writing High-Level Design Documentation

The main documents include the High-Level Design Specification, Database Design Specification, User Manual, and Revised Test Plan.

4. Review

Each part of the design is reviewed for complete implementation of functional and performance requirements, feasibility of design methods, correctness and effectiveness of critical processing and internal/external interface definitions, and consistency between components.

Detailed Design

1. Perform detailed algorithm design for each module, using tools like diagrams, tables, and languages to describe the detailed algorithm for each module’s processing.
2. Design the data structures within each module.
3. Perform physical design for the database, i.e., determine the database’s physical structure.
4. Other Designs. Depending on the type of software system, the following designs might also be needed:
   1. Code Design. To improve operations like data input, classification, storage, and retrieval, and to save memory space, certain data item values in the database require code design.
   2. Input/Output Format Design
   3. User Interface Design
5. Write the Detailed Design Specification.
6. Review. Both the processing algorithms and the database’s physical structure need to be reviewed.

The result of system design is a series of system design documents. These documents form the crucial foundation for physically implementing an information system (including hardware setup and software programming).