1. The difference between internal quality and external quality: The
most important thing is the quality of the outside, because it is a user can directly feel; but it is plays a decisive role in internal quality.
2. correctness and robustness: Depends on specifications.
In line with the specifications shall be correct, some abnormalities that is not covered by the specification, and the error is not meet specifications.
3. scalability: the software architecture more simple, the more autonomous modules more easily adapt to external changes (scalability)
4. compatibility reusability:
reusability similar function library;
compatibility stressed information exchange between programs (such as different operating systems in different file formats, leading to another operating system can not read the file transfer over on another system directly, which involves compatibility);
resolve the incompatibility the key: a standardized protocol (file formats, data structures, user interactive interface (operating system type associated))
5. efficiency: software, hardware capacity needs as little as possible;
Note: efficiency is based on the premise of correctness, while others may scalability, reusability, and it can be a compromise;
improving efficiency may be the ultimate optimization: algorithms, I / O, memory management;
6. portability hardware environment includes not only physical, but also includes soft hardware environment;
7. ease of use: includes installation, operation and monitoring of ease;
8. functionality: excessive loss of function caused by the consistency of the quality objectives, the impact of the ease of use;
solution Type: through quality improvement technology to ensure increased functionality, other quality unchanged, debug to improve quality; in the development process to ensure that the first priority in selecting quality objectives remain unchanged;
9. verify the timeliness, completeness, repairability
10. economy: not exceeding the budget.
Performance compromise
the integrity vs ease of use (to prevent unauthorized access to information integrity, tampering)
economy vs functional (economic and budget-related)
efficiency vs portability (efficiency requirements perfectly fit a particular hardware environment)
efficiency vs reusability (reusability required to solve the problem is more universal, rather than on a particular issue)
economy vs reusability
timeliness vs scalability (for a short time to meet customer needs, often using lower variability may be rapid application development)
Summary: efficiency and specific hardware and software environment, the higher the efficiency, the more tightly coupled (using a characteristic advantage of the environment)
Including the correctness of reliability, robustness; modular can solve the scalability and reusability issues.
Improve the quality of OOP method, here only where it can be ignored.
1. validity: a package simplifies the function of each module
2. Robustness: error handling package
3. scalability: Information Hiding Module package
4. reusability: Modular Design mode (it is later learned)
5 compatibility: standardized interface module
6. portability: Hide abstract
7. ease of use: the GUI component framework
8. efficiency: a reusable component (standardized interfaces encapsulated particular system, both to meet the efficiency, universal)
9. economy: multiplexing
10 functionality: enhanced scalability
In our actual software development, to improve the quality of these objectives, practical measures are:
1. understandability:
Code level: Comments to the methods of increasing specification, variable naming, code style and other
component level: bags, paper, organization of space, named
in the implementation process, using the Log, Trace and so on.
2. Reusability:
Code level: ADT, OOP implementation of the interface separation, class inheritance, parametric generified, design patterns, heavy objects combinations between members, agency relationship, the method of rewriting the like Wait.
Component level: library, using frames.
3. ensure robustness:
the code level: error exception handling, the use of assertions, defensive programming, test-first programming
components: unit testing
phase of development: rollback shaped test
run: debug carried out by observing the stack, view a stages Logging, or Tracing
4. runtime performance guarantee:
Code level: Design mode;
time and space complexity of the runtime tuning, a tuning stage of the code;
runtime components: distributed systems, multi-threaded program.