The purpose of software architecture is to address software qualities. Various software qualities are detailed below.
Characteristic in ease of identifying and fixing a fault with the product.
Tradeoff: Customizability, Efficiency
Characteristic in preventing unauthorized access to features of the product.
The software should not only be able to protect unauthorized access to the users' personal information, but as well as prevent any user from using the software maliciously against other users of the software. An example of where this is an issue is email, where adware, spyware, and viruses can be sent to other users.
Characteristic in having essential functions for the intended purpose.
The software should not only have the necessary functions required for the users to execute their tasks, but the software should also make it as easy as possible for these users to execute their tasks. However, the amount of functions made available to the users should also be limited due to its inherent negative effect on navigation, usability. If there are too many possibly different functions that are dependent on the users' preferences, customizability and extensibility should be considered.
Characteristic in being fault tolerant.
The chance is likely that large software can crash on certain occasions, but if any software does crash, the software should at the very least be able to recover and automatically save the users' information before the crash. The software should also recover within a minimal time frame.
Characteristic in attracting clients.
In order for a software product to survive, it has to be marketable. Small software companies should adopt strategies such as innovating and exploiting similar software weaknesses when up against larger software companies (i.e. do not compete in an area you are not recognized as a top contender). Whereas larger software companies should adopt strategies such as customer service, innovating, patching uncovered weaknesses of their software and provide a variety of functionality so that there are few reasons why users would consider a smaller company's software other than perhaps price.
Characteristic in two or more things being able to work in conjunction in harmony.
Each updated version of the software should be compatible with previous versions; this includes the users extended functionalities from previous software versions. This will require careful coding and therefore, makes optimizing software efficiency more difficult.
Characteristic in ease of changing in size.
It is important that software can be scaled from smaller to larger because of expansions, as well as from larger to smaller because of portability to devices with less memory or saving memory (space). The use of good coding practice is important for software scalability.
Characteristic in ease of use.
The software should be as easy to navigate, execute, and troubleshoot for the users as possible, but at the same time, the software needs to provide enough information and functions as possible.
Characteristic in degree of user configurations.
If the software functions are best to be based on the users' preferences, allowing options for users to define their preferences and providing typical, advanced, and custom installation is standard.
Characteristic in enabling a user to extend the product's capabilities.
If customizability is not enough to provide satisfactory software functions, then allowing the users to extend the software is a possible option. However, how the users can extend the software should be restricted, unless compatibility can be sacrificed.
Tradeoff: Compatibility, Reliability, Security
Characteristic in minimizing the amount of resources the product consumes to function.
When considering software efficiency, both the non-technical and technical users should be accounted for. Even though a large majority of the consumers are the non-technical users, the technical users are usually more vocal as well as persuasive, which can affect the marketability of the software product. Because the consumers value faster software over slower ones, many software engineers make use of the splash screen and preloading the software components during the starting up of the operating system. When a splash screen is incorporated, the technical user will know that this requires a minimal addition of time and space for the software to load, but normally the lost in efficiency is usually worth the tradeoff with information appearing on the splash screen. Therefore, both the non-technical and technical users will likely be satisfied. When the software components are preloaded while the operating system is starting up, the software will appear to load much faster to the non-technical users, but the technical users will know it actually takes more memory and time for the process and will especially be annoyed if the technical users do not plan to use the software for those sessions. Therefore, it is not always a good idea to have software components preloaded while the operating system is starting up.
Tradeoff: Compatibility, Localizability, Maintainability
Characteristic in ease of use through various means.
Software should cater to many different kinds of users since some (occasional users) prefer using the keyboard with shortcuts, while others (usually casual users) prefer the ease of the mouse.
Characteristic in ease of adapting the product to another platform.
Code should not be platform dependent so that porting the software can be a possible option because the chance that the software can benefit from being ported to another platform is unpredictable just as localization.
Characteristic in ease of re-appropriating the product to other environments.
The software text visible to the users should all be kept in separate files rather than embedded directly in the code. Even though this is an additional burden to software efficiency due to the additional necessity of parsing the text files, the chance to localize software is rather unpredictable and translating or maintaining text directly embedded in the code is difficult.