Methods and Techniques for Improving Software Reliability

Methods and Techniques for Improving Software Reliability

 

1. establish quality standards with reliability as the core

In the software project planning and demand analysis phase, a quality standard with reliability as the core should be established. This quality standard includes functions, reliability, maintainability, portability, security, and throughput. Although there is no complete system to measure the quality of software, however, you can specify a standard baseline through certain indicators.

Software Quality consists of product quality and process quality.

Product quality is the quality of software products, including the readability, reliability, correctness of various types of documents and codes, and the degree to which user requirements are met.

Process Quality is the quality of the development process environment. It is related to the technologies used, the quality of developers, the organization and communication of development, and the utilization rate of development equipment.

Quality can also be divided into dynamic quality and static quality. Static quality is the quality confirmed by reviewing the results of various development processes, including the degree of modularization, simplicity, and completeness. Dynamic Quality is the quality confirmed by observing the running status, including the average failure interval (MTBF), software fault repair time (mtrf), and available resource utilization. In many practical projects, people generally pay more attention to dynamic quality and ignore static quality.

The specified quality standard measurement should at least achieve the following two purposes:

(1) clearly divide the development process (requirement analysis process, design process, test process, and acceptance process), and ensure the early elimination of errors and certain quality through feedback of quality inspection.

(2) Implement Progress Management in various development processes, generate stage quality evaluation reports, and take countermeasures for substandard products as soon as possible.

Determine the quality metrics for each development process:

(1) Requirement Analysis Quality Measurement

Whether the requirement analysis definition is complete and accurate (with or without ambiguity), whether developers and users understand different situations, and whether the documents are completed, specific reliability requirements, analysis and design, and reliability management measures should be established.

(2). design result quality measurement

Design work hours, program capacity and readability, comprehensibility, number of test cases, evaluation results, and document completion status.

(3). Quality Measurement of test results

Test work hours, error status, error quantity, error detection rate, number of residual errors, evaluation of error impact, documents, and measures related to illegal input.

(4). Acceptance result quality measurement

Number of completed functions, performance indicators, and reliability.

Finally, a prediction model for the reliability growth curve is selected, such as time measurement, individual measurement, and availability. It is used to calculate the error convergence degree of the reliability growth curve during later development.

After quality standards are established, the quality report and evaluation form should be designed to be strictly implemented throughout the development process, quality evaluation should be made in a timely manner, and the report form should be filled in.

2. Select the development method

Software development methods also have an important impact on software reliability.

Currently, the software development methods include parnas, Yourdon, Jackson, warnier, PSL/PSA, prototype, object-oriented, visualized, and icase. methods and methods for development, other methods include BSP and CSF. The parnas method is particularly mentioned here.

The parnas method is the earliest software development method proposed by parnas in 1972. The basic idea is to estimate the potential changes in the future during the outline design, the principle of information hiding is proposed to improve software reliability and maintainability.

In the design, it is required to first list the factors that may change in the future. When dividing modules, some factors that may change are hidden inside a module, so that other modules are irrelevant to this, this improves the maintainability of the software, avoids the spread of errors, and improves the reliability of the software. Measures to improve reliability are also proposed:

(1) Considering that the hardware may fail, modules close to the hardware should check the hardware behavior and detect errors in time.

(2) considering the possible mistakes of the operator, the input module checks the validity of the input data, checks whether the input data is legal or unauthorized, and promptly corrects the error.

(3) Strengthen inter-Module checks to prevent the spread of errors, taking into account possible software errors.

Many people may not be familiar with the method. Here is a brief introduction.

The rational model is developed by American software engineering companies. The pattern is:
Object-oriented;
Spiraling rise;
Management and control;
Highly Automated;

The software life cycle is divided into five stages: initial, planning, construction, transfer, and Evolution Based on management and technical perspectives, these five stages can also be merged into the research period (initial and planned) and production period (construction and transfer), and finally the maintenance period (evolution ), it is particularly suitable for handling high-risk components and changing needs.

Among the above methods, the visualization method is mainly used for graphics-related applications. Currently, visual development tools can only provide visual development of user interfaces, this method is not required for applications that do not require a complex graphic interface. The icase technology is not yet completely mature, so the methods and icase methods can only be used as auxiliary methods. The data structure-oriented method, PSL/PSA method, and prototype method are only suitable for the development of small and medium systems.

The object-oriented method facilitates software complexity control, facilitates productivity improvement, conforms to human thinking habits, can naturally express the real world entities and problems, and has a natural modeling capability, to achieve direct and natural ing from the problem space to the solution space.

In the object-oriented method, because a large number of databases with high reliability are used, the reliability is guaranteed, and the object-oriented method is also conducive to software reuse.

Therefore, we recommend that you use the object-oriented method, draw on the ideas of parnas and the rational model, and combine other methods in the development process to absorb the advantages of other methods.

3. Software Reuse

Reusing existing mature software to the maximum extent can not only shorten the development cycle, improve development efficiency, but also improve Software maintainability and reliability. Because the existing mature software has passed strict operation detection, a large number of errors have been eliminated during development, operation and maintenance, and should be relatively reliable. Software reuse should be included in the initial stage of project planning as an indispensable part of the work, as a necessary means to improve reliability.


Software reuse not only refers to the software itself, but also to the reuse of software development ideas, methods, documents, and even environment and data. It includes three aspects:

(1) reuse of the development process refers to the development specifications, various development methods, tools and standards.

(2) Software Component Reuse refers to documents, programs, and data.

(3) Reuse of knowledge, such as the reuse of professional knowledge in related fields.

Generally, software components are reused.

The process of software reuse is as follows: candidate, selection, qualification, classification and storage, search and retrieval. When selecting reusable components, there must be strict selection criteria. reusable components must be strictly tested, or even components with proven reliability and correctness, modular (to achieve a single and complete function), clear structure (readable, understandable, and appropriate scale), and highly adaptive.

4. Use development management tools

Developing a large software system is inseparable from development management tools. As a Project Administrator, relying only on people for management is not enough, development management tools are required to help solve various problems encountered during the development process to improve development efficiency and product quality.

For example, intersolv's PVCs software development and management tools have a market share of more than 70% in the United States. using PVCs can bring many benefits: standardizing the development process, shortening the development cycle, and reducing development costs, reduces project investment risks; automatically creates complete documents to facilitate software maintenance; manages multiple software versions; manages and tracks defects and changes that compromise software quality and affect the development cycle during the development process, it facilitates software reuse, prevents data loss, and facilitates communication between developers. This can greatly improve software reliability and ensure quality.

In China, development and management tools have not been effectively used. Many software companies are still in the manual management stage, and the quality of software developed is not very high.

It is difficult to manage people. While ensuring the quality of developers, we must maintain the stability of personnel and avoid the frequent flow of personnel as much as possible. The flow of personnel affects the quality of software, the continuity of work is difficult to guarantee, the successor can not understand the situation clearly, or may affect the work process. PVCs also provides appropriate personnel management methods.

5. Enhanced Testing

After various stages of software development are completed in the early stage, to further improve the reliability, it can only be achieved through enhanced testing. To minimize software errors and improve software reliability, complete software testing is required. It is impossible to perform a complete test on a large software system. Therefore, it is necessary to determine the minimum and maximum number of tests. The former is a technical decision, and the latter is a managerial decision, in the actual process, you must determine the lower limit of the number of tests. In general, the test should be as complete as possible.

Who will perform the test? Generally, users are unlikely to conduct module tests. module tests should be carried out by programmers who originally wrote code, and module tests should be conducted by exchanging programs between them, self-designed programs cannot achieve good results in self-testing.

Before the test, determine the test standards and specifications. During the test, establish a complete test document, place the software under configuration control, and change it with formal steps, ensure that all errors and actions against errors can be archived in a timely manner.

The Test Specification includes the following three types of documents:

(1) Test Design Specifications: describes the test method in detail and specifies the characteristics of the design and its related tests. The test cases and procedures required to complete the test should also be specified, and the criteria for determining the pass/failure of the characteristics should be specified.

(2) Test Case specification: lists the specific values used for input and the expected output results. Limits the test procedure when a specific test case is used.

(3) test procedure specification: it specifies that all steps required for testing are performed for running the system and executing specified test cases.

There are multiple testing methods:

(1) walk-through, that is, manual execution. Different programmers (not designers of this module) read the code and make comments.

(2) machine testing does not produce non-logical output for a given input.

(3) program proof or alternate representation.

(4) simulated testing and hardware and I/O devices.

(5) Design Review, panel discussions on all aspects of the design, and identification of defects and violations of standards using the information obtained.

The preceding steps can be executed in parallel and cyclically. In actual testing, test tools should be used to improve the efficiency.

In addition to normal testing, we also need to test the software reliability to ensure that the software has no major impact on reliability. Develop a test plan, randomly select input based on the actual probability distribution, accurately record the running time and results, and evaluate the results.

 
A program without errors is just as impossible as a perpetual motive. Common troubleshooting methods include test, Trace, induction, and limit. You must also use appropriate troubleshooting tools, such as SDB and DBX encoding troubleshooting tools provided by UNIX. These troubleshooting tools only have the browsing function and are not modified.

6. Fault Tolerance Design

Generally, there are two types of technologies to improve reliability. One is to avoid faults. during the development process, try not to let errors and defects sneak into the software. These commonly used technologies include:

Algorithm Modeling: model the algorithms that can ensure correct implementation of required specifications.

Simulation Modeling: In order to ensure the performance of the prediction under determined resource conditions, the software runtime, memory usage, and control execution are modeled.

The reliability model uses the reliability model to predict the reliability based on the error occurrence frequency.

Verify the correctness of the algorithm by using formal symbols and mathematical induction.

Software hazard analysis and Fault Tree Analysis: Starting from the design or coding structure, we track the causes of system defects during software development.

Distributed interface Requirement Specification Description: describes the types of interface requirements used at each stage of the design to verify the possibility and completeness of the distributed interface.

These technologies generally require profound mathematical theory knowledge and modeling technology.

The other is fault tolerance technology that uses redundancy.

The basic idea of Fault Tolerance Technology is to minimize the impact of potential errors in software on reliability.

The Fault Tolerance of software can be divided into four phases: Error Analysis, damage determination, error recovery, and error handling.

Common Software Fault Tolerance technologies include N-version, block restoration, and multi-Backup.

N-Version Programming is to independently design n programs with the same functions (that is, versions) according to the same specification requirements ). Independence refers to the use of different algorithms, different design languages, different testing technologies, and even different command systems.

Recovery block technology is a fault handling technology that uses automatic forward error recovery.

The above technologies can be referred to the relevant literature. Here we will talk about error-proof programming and error check in the program. Passive error prevention technology checks the information of a computer program when it reaches the check point. Proactive error prevention techniques are used to periodically search the entire program or data, or to find unusual conditions in idle time. The adoption of Error-proof programming is based on the fact that programmers believe that their software is definitely wrong. Some programmers may not get used to this because they may trust themselves too much, I believe that my program has few or even no errors. As a Project Administrator, he should be able to persuade or force him to adopt this technology. Although it takes some time to design, but this is useful for improving reliability.