Header Ads

What is the features of a good Information Technology System?

Correctness :
The software system’s fulfillment of the specifications underlying its development. The correctness of a software system refers to:Agreement of program code with specificationsIndependence of the actual application of the software system.The correctness of a program becomes especially critical when it is embedded in a complex software system.Example 1.1 Let p be the probability that an individual program is correct; then the probability P of correctness of the software system consisting of n programs is computed as P = pn .If n is very large, then p must be nearly 1 in order to allow P to deviate significantly from 0
Reliability
Reliability of a software system derives from Correctness, and Availability.The behavior over time for the fulfillment of a given specification depends on the reliability of the software system.Reliability of a software system is defined as the probability that this system fulfills a function (determined by the specifications) for a specified number of input trials under specified input conditions in a specified time interval (assuming that hardware and input are free of errors).A software system can be seen as reliable if this test produces a low error rate (i.e., the probability that an error will occur in a specified time interval.)The error rate depends on the frequency of inputs and on the probability that an individual input will lead to an error.
User friendliness:
AdequacyLearnabilityRobustnessAdequacy
Factors for the requirement of Adequacy:
The input required of the user should be limited to only what is necessary. The software system should expect information only if it is necessary for the functions that the user wishes to carry out. The software system should enable flexible data input on the part of the user and should carry out plausibility checks on the input. In dialog-driven software systems, we vest particular importance in the uniformity, clarity and simplicity of the dialogs.The performance offered by the software system should be adapted to the wishes of the user with the consideration given to extensibility; i.e., the functions should be limited to these in the specification.

The results produced by the software system:
The results that a software system delivers should be output in a clear and well-structured form and be easy to interpret. The software system should afford the user flexibility with respect to the scope, the degree of detail, and the form of presentation of the results.Error messages must be provided in a form that is comprehensible for the user.


Learnability
Learnability of a software system depends on:The design of user interfacesThe clarity and the simplicity of the user instructions (tutorial or user manual).The user interface should present information as close to reality as possible and permit efficient utilization of the software’s failures.
The user manual should be structured clearly and simply and be free of all dead weight. It should explain to the user what the software system should do, how the individual functions are activated, what relationships exist between functions, and which exceptions might arise and how they can be corrected. In addition, the user manual should serve as a reference that supports the user in quickly and comfortably finding the correct answers to questions.


Robustness
Robustness reduces the impact of operational mistakes, erroneous input data, and hardware errors.A software system is robust if the consequences of an error in its operation, in the input, or in the hardware, in relation to a given application, are inversely proportional to the probability of the occurrence of this error in the given application.
Frequent errors (e.g. erroneous commands, typing errors) must be handled with particular careLess frequent errors (e.g. power failure) can be handled more laxly, but still must not lead to irreversible consequences.

Maintainability
Maintainability = suitability for debugging (localization and correction of errors) and for modification and extension of functionality.The maintainability of a software system depends on its:
Readability
Extensibility
Testability

Readability
Readability of a software system depends on its:Form of representationProgramming style

Consistency
Readability of the implementation programming languagesStructuredness of the systemQuality of the documentationTools available for inspection
Extensibility
Extensibility allows required modifications at the appropriate locations to be made without undesirable side effects.Extensibility of a software system depends on its:Structuredness (modularity) of the software systemPossibilities that the implementation language provides for this purposeReadability (to find the appropriate location) of the codeAvailability of comprehensible program documentation

Testability
Testability: suitability for allowing the programmer to follow program execution (run-time behavior under given conditions) and for debugging.The testability of a software system depends on its:
ModularityStructurednessModular, well-structured programs prove more suitable for systematic, stepwise testing than monolithic, unstructured programs.Testing tools and the possibility of formulating consistency conditions (assertions) in the source code reduce the testing effort and provide important prerequisites for the extensive, systematic testing of all system components.

Efficiency
Efficiency: ability of a software system to fulfill its purpose with the best possible utilization of all necessary resources (time, storage, transmission channels, and peripherals).


Portability
Portability: the ease with which a software system can be adapted to run on computers other than the one for which it was designed.The portability of a software system depends on:Degree of hardware independenceImplementation languageExtent of exploitation of specialized system functionsHardware properties
Structuredness:
System-dependent elements are collected in easily interchangeable program components.A software system can be said to be portable if the effort required for porting it proves significantly less than the effort necessary for a new implementation.
Powered by Blogger.