Flexibility is the ability of software to add/modify/remove functionality without damaging the current system. Scalability is the ability of software to add functionality without damaging the system, so it can be considered a subset of flexibility. These functional changes may occur based on changing requirements or if the development process is one of iterative methods. Change is inevitable in software development, therefore, this is one of the most important attributes of quality software
Maintainability Flexibility is somewhat similar to flexibility, but it focuses on error correction and modification of minor functionality rather than scalability of major functionality. It can be supported by useful interface definitions, documentation, and self-documenting code and/or code documentation. The more correct and useful the documentation, the higher the maintainability.
Performance is mainly related to the response time of the software. This response time should be within an acceptable interval (e.g., a few seconds at most) and should not increase if the transaction count increases. Also, resources are expensive. Efficiency must be supported by resource utilization. As an exaggerated example, using only a 32-processor machine or 1 TB of disk space to perform a simple function is unacceptable. One must aim for the best source/performance ratio.
A scalable system responds to user operations within an acceptable time, even as load increases. Of course, more hardware can be added to handle increasing user transactions, but the architecture should not change when doing so. This is called vertical scalability. The ability to run on multiple, ever-increasing numbers of machines is multiprocessing. If software can perform such processing, it is called horizontal scalability. The preferred scalable system should accommodate both approaches.
Availability, Robustness, Fault Tolerance, and Reliability:
Robust software should not lose its availability even under most failure conditions. It may continue to operate even if some components fail. Additionally, even if the entire application crashes, it can recover on its own using backup hardware and data and fault-tolerance methods. There should always be a plan B or even C, D... Reliability also represents the integrity and consistency of software even under high load conditions. So it's related to availability and scalability. An unreliable system is also unscalable.
From the user’s perspective, the user interface is the only visible part of the software. Therefore, simplicity, taking less time to complete the work, learning quickly, etc. are very important in this case. The most famous principle of this property is KISS (Keep It Simple Stupid). Simple is always best. Available software should also support control of different accessibility types for people with disabilities.
High-quality software should run on as many platforms as possible. So, more people can take advantage of it. In different contexts we may refer to different platforms, this may be operating system platform, browser type, etc. Portability refers to adapting software to run on different platforms for better platform compatibility. In this sense, portability is also about flexibility
Testability and manageability
Quality software requires quality testing. Source code should be tested with maximum coverage and the most efficient testing methods. This can be performed through the correct use of techniques such as encapsulation, interfaces, patterns, low coupling, etc. In addition to testability, good software should be easy to manage after deployment. It can monitor, for example, performance or data usage status, or it can enable developers to easily configure the system. Creating a successful logging system is another very important issue regarding manageability.
Security is a very important issue in software development, especially for web-based or mobile device-based software development that may have millions of users Users with remote access system capabilities. You should build your security policy and apply it correctly by leaving no entry points. This may include authorization and authentication technologies, cyberattack protection, data encryption, and more. All possible types of security vulnerabilities should be considered, otherwise just one attack could one day bring down your entire application and your entire company.
Functionality (or correctness) refers to the consistency of software with actual requirements and specifications. In fact, this is a priority attribute of the application, maybe not a quality factor, but we would like to make it the last quality factor, to draw attention to it: quality factors have no meaning when we talk about software that does not work properly. First, perform the required functionality and generate the correct software, then apply quality factors to it. It would be best if the two could go hand in hand.
The above is the detailed content of 10 factors that cannot be ignored in software development. For more information, please follow other related articles on the PHP Chinese website!