Chapter 13 - Evaluatiing, Refining, and Integrating Applications
- Risk from Individual Applications
3 approaches for new applications
- Customizing packages by selecting options
- Developing new functions using the macro facilities
- Developing complete custom applications
application risk = probability(error) x cost(error)
organizational risks
- faulty decisions made as aresult of erroneous information
- additional time required to correct erroneous information
- productivity lost due to personal systems development
individual risks
- errors introduced due to lack of error control
- data lost due to mistakes that destroy data files
- time lost due to use of poor tools
- Application Evaluation
- Evaluating Fit with Real Requirements
- identify unnecessary (although customary) requirements
- identify innovative requirements that add value
- use the full pontential of tools
- compensate for biases
- recency bias - don't unduly focus on recent events
- concreteness bias - physical counts "more important" than "soft data"
- availability bias - user focuses on data readily available rather than generating new data
- small sample bias - user may be unduly influenced by events that occur infrequently
- evaluating completeness of application requirements
- Are all requirements necessary?
- Does the application reflect innovation regarding the function to be performed?
- Do the requirements take into account the capabilities of the chosen development platform?
- Do thye take advantage of the strengths of the hardware and software they will operate on?
- Does the application reflect biased behavior with respect to recency ofevents, concreteness of data, and availability of data?
- Does the analysis and presentation of low occurrence of data aid the user in overcoming small sample bias?
- Does the application have requisite variety?
- Evaluating Robustness and Usability
- robustness - behavior of the application when a mistake is made or a fault occurs (error detection and error handling)
- correct responses to all correct, complete inputs
- explanation if systems make decisions or assumptions
- rejection of incorrect or incomplete inputs/messages
- instructions to users
- what to do to provide correct, complete inputs or correct errors
- what to do to recover
- usability - behavior of the application with respect to the user (user friendly)
different users require different levels of robustness
- Single developer/user and frequent use
- Single developer/user and infrequent use
- Colleague/department use
- unknown user
- Does the user understand the nature of the application, the inputs, and the use of the outputs?
- Is documentation satisfactory for persons using the application?
- Does the application present a clear and consisten image that is relatively easy to learn, use, and remember?
- Will the user be able to understand the behavior of the application if mistakes are made in using it?
- Given the intended use, will there be an appropriate and well-defined means of correcting for the effects of data and system errors?
- Evaluating Appropriateness and Suitability for the Task [task/technology fit]
- technology employed
- user interface
- organizational culture
- responsiveness to changing task needs
- Does the application employ appropriate technology?
- Is the interface suitable for all users of the application?
- Does the application violate organizational norms or culture?
- What changes can be anticipated and how feasible will it be to make them?
- Analyzing Risks [risk analysis - analysis of effects of errors in the application and its use]:
- financial loss from incorrect or incomplete data
- loss of data
- loss of time
To evaluate financial risk, assess:
- potential loss with each use of the application
- expected number of uses per year
- total exposure per year
- estimated probability of error with use
- computed financial risk
To evaluate risk of data loss, assess:
- the value of the outputs to the decisions or actions it supports.
- the per period (yearly) exposure based on the potential loss per use and number of uses
- the probability of partial or complete loss of data
- the financial risk of data loss
To evaluate risk of lost time, assess:
- the extra time required to repeat inputs or correct data and product correct outputs
- the proportion of applicationuse where time is lost due to design flaws
- lost time per period
- Using the Results of Application Evaluation
- prototype evaluation
- discard prototype
- use prototype as is
- refine prototype
- use prototype as specification, but discard as system
- testing
- if risk is relatively small, testing can be done by user/developer
- if risk is moderate, testig should involve others in the workgroup or department
- if the risk is relatively high, testing should be done by the "professional applications testing group"
- Refining the Application
- Refining the Input Interface [add input validation to detect and handle incorrect input]
- if a stored record is referenced, display its values for visual validation that the record is correct.
- display the meaning of codes when they are input
- when there is a computation involving several factors, show the factors used.
- display warning messages if a dat item appears to be out of the normal range
- display a count of input items entered and a control total for numeric data
- provide data for reconciling input data with other control information
- Refining the Output Interface - remove ambiquity
- Refining Data Integrity [referential integrity - need for referenced records to be present in the database (insertion/deletion anomalies)]
- Access Control and Backup
- authentication techniques
- backup (offsite?)
- Application Integration
- Standardization
- list all component names that must be understood to use the application in its normal use
- organize components according to external user related concepts.
- assign meaningful names to all listed objects in a consistent pattern.
- rename the objects and test to make sure functionality has not been lost or errors introduced
- Command Interface
- List the possible user actions and organize them to match the user functions provided by the application
- Design the user Command Interface using the outline of user actions and application functions
- Use the features of the software package to implement the specified menu or graphical command interface
- Linking Other Applications
- Third-Party Add-ons