Classification and features of CASE tools

Classification of CASE tools

CASE (Computer Aided Software Engineering) tools are software tools that support software process activities. They are classified in several ways.

1. By life-cycle phase

• Upper CASE: support early phases: requirements, analysis and design (UML and DFD modelling tools).
• Lower CASE: support later phases: coding, testing, debugging and maintenance (compilers, test tools).
• Integrated CASE (I-CASE): support the whole life cycle and share a common repository.

 Requirements  Analysis  Design | Coding  Testing  Maint.
 <------- Upper CASE --------->  <----- Lower CASE ---->
 <---------------- Integrated CASE ------------------->
               (shared central repository)

2. By level of process support (Fuggetta, used by Sommerville)

• Tools: support a single task, such as an editor or compiler.
• Workbenches: support one process phase with several integrated tools, such as an analysis-and-design workbench.
• Environments: support all or most of the software process using several integrated workbenches.

3. By function (Pressman)

4. By who uses them / their scope

• Technical tools support engineering work (design, coding, testing).
• Management tools support planning, estimation, tracking and configuration management.

Importance of CASE tools

• Higher productivity: routine tasks such as drawing diagrams, generating code and documents are automated.
• Better quality: consistency checks and standards enforcement catch errors early.
• Consistent documentation: documents are produced from the same models, so they stay up to date.
• Lower cost: fewer defects and less rework reduce development and maintenance cost.
• Easier maintenance: reverse engineering and a central repository help understand and change old systems.
• Better teamwork: all members share the same project information.
• Standardization: everyone follows the same notation and method.

Features of CASE tools

1. Diagramming: create DFDs, ER diagrams, UML class, sequence and state diagrams.
2. Central repository / data dictionary: stores all models, data definitions and their relationships.
3. Consistency and completeness checking: detects undefined data, unconnected processes or mismatched interfaces.
4. Code generation: produces code skeletons or full code from design models.
5. Reverse engineering: builds design models from existing code.
6. Documentation and report generation: creates SRS, design documents and reports automatically.
7. Prototyping and screen design: builds user interface prototypes quickly.
8. Version and configuration control: keeps track of versions of models and code.
9. Testing support: generates and runs test cases and measures coverage.
10. Project management support: estimation, scheduling and progress tracking.

Example: with StarUML a designer draws a class diagram, the tool checks it, generates Java class skeletons, and exports diagram documentation for the design report.