CS 477 Lecture Notes
Week Fourteen, Tuesday: Implementation and Integration Phase
Implementation and Integration
To test modules, the interfaces need to be simulated: stubs and drivers.
Fault isolation is a problem when the modules are integrated all at once.
The solution is to combine implementation and integration.
Top-Down Implementation and Integration
Top down integration tests logic modules well, but may not sufficiently
test operational modules.
Bottom-Up Implementation and Integration
Bottom-up integration may not detect major design flaws early.
Sandwich Implementation and Integration
Combining top-down and bottom-up integration provides fault isolation,
detects major design flaws early, and sufficiently tests operational modules.
Implementation and Integration of Object Oriented Products
Use a variant of sandwhich implementation: objects are integrated bottom
up, class methods are integrated top-down.
Management Issues during the Implementation and Integration Phase
Programmer disputes can arise due to errors in design documentation.
Schach concludes: therefore, the integration process should be run by SQA.
I'm not sure I'm convinced that SQA should be in the business of resolving
design disputes. As testing seems to dominate the integration, however,
perhaps SQA should be in charge for that reason.
Testing during the Implementaion and Integration Phase
Test each new module as it is added to the product.
Integration Testing of Graphical User Interfaces
Use a special CASE tool to run a script to test a GUI.
Product Testing
Performed by SQA to approximate acceptance testing to formal test plans
(part of the SPMP). It's also a rehearsal for acceptance testing. Get it right
because acceptance testing is so important. Also perform stress testing
and volume testing. Use actual data from the customer's shop where possible.
Acceptance Testing
Correctness, robustness, performance, and documentation. Done at the customer's
site with actual data. Usually must install, run, and test the system in parallel
if it's intended to replace an existing system. When the acceptance test is passed,
the development team's job is done. Acceptance criteria should be part of the
specification.
Language-Centered Environments
Good for rapid prototyping. Examples: Microsoft's Visual Basic, Borland's Delphi.
Other phases: they are language-bound, so they are good for the implementation phase only.
They typically have no support for PMIS (project management information system).
Structure-Oriented Environments
Visual Basic, Delphi, Visual C++, etc. also have structure editors. Generally
considered useful for implementation and programming-in-the-small.
Toolkit Environments
A toolkit can handle any language. The tools may share a common user interface,
but the tools are usually not integrated.
Integrated Environments
Tools share a common interface and may have process or tool integration. Process
integration forces the user to follow a specific process. Tool integration means
that all the tools share data via a common format.
Tools can be embedded in a common "front end" (tool calling system) or by a common
"back end" (software project database).
Environments for Business Applications
Business applications generally fall into common categories. Developing these
applications can get quite repetitive, so a number of environments have been
developed specifically for certain types of business applications.
Public Tool Infrastructures
Tool standards should result in a broad range of CASE tools that should result
in better software processes.
Comparison of Environment Types
A software organization should be at the CMM level 3 before adopting CASE,
or chaos will result.
Metrics for the Implementation and Integration Phase
Lines of code, cyclomatic complexity, metrics of software science. Number of
test cases, number of failure cases. Fault-type statistics.
Statistical-based testing: equation 13.1 gives the number of fault-free test hours
remaining for assurance the product is "fault free."
This page established April 13, 1998; last updated January 17, 2000.