CASE (Computer‐Aided Software Engineering)

CASE, in the field of S/W Engineering is the

application of a set of tools and methods to a
software which results in high-quality, defect-free,
and maintainable software products.

It also refers to methods for the development of

information systems together with automated tools
that can be used in the software development
process.
Computer-Aided Software Engineering (CASE)
technologies are tools that provide automated
assistance for software development .

The goal of introducing CASE tools is the reduction

of the time and cost of software development and the
enhancement of the quality of the systems
developed.

The interest in CASE tools and environments is

based on expectations about increasing productivity,
improving product quality, facilitating maintenance,
and making software engineers' task less odious and
more enjoyable.
CASE Tools and its scope broadly classed based on SDLC into these
broader areas:

Requirement Analysis Tool

Structure Analysis Tool

Software Design Tool

Code Generation Tool

Test Case Generation Tool

Document Production Tool

Reverse Engineering Tool

 Some typical CASE tools
1. Configuration management tools
2. Data modeling tools
3. Model transformation tools
4. Refactoring tools
5. Source code generation tools, and
6. Unified Modeling Language
Many CASE tools not only output code but also
generate other output typical of various systems
analysis and design methodologies such as:

1. Data flow diagram

2. Entity relationship diagram
3. Logical schema
4. Program specification
5. SSADM (Structured Systems Analysis and
Design Method : S/A & S/D)
6. User documentation
 Classification of CASE Tools
CASE 3 categories:

Tools: support specific tasks in the software life-

cycle.

Workbenches: combine two or more tools focused on

a specific part of the software life-cycle.

Environments: combine two or more tools or

workbenches and support the complete software life-
cycle.
 Tools
They can be divided into the following categories:
•Business and Analysis modeling. Graphical modeling tools. E.g., E/R
modeling, object modeling, etc.
•Development. Design and construction phases of the life-cycle.
Debugging environments.
•Verification and validation. Analyze code and specifications for
correctness, performance, etc.
•Configuration management. Control the check-in and check-out of
repository objects and files.
•Metrics and measurement. Analyze code for complexity, modularity
(e.g., no "goto"), performance, etc.
•Project management. Manage project plans, task assignments,
scheduling.
 Workbench
Workbenches integrate two or more CASE tools and support
specific software-process activities. Hence they achieve:
•a homogeneous and consistent interface (presentation
integration).
•seamless integration of tools and tool chains (control and
data integration).
•An example workbench is Microsoft's Visual Basic
programming environment. It incorporates several
development tools: a GUI builder, smart code editor,
debugger, etc.
Real CASE tools - can be separated into three
different categories, depending on where in the
development process they are most involved in:

•Upper - support analysis and design phases

•Lower - support coding phase
•Integrated - also known as I-CASE support
analysis, design and coding phases
 Environments
An environment is a collection of CASE tools or
workbenches that attempts to support the complete
software process. This contrasts with tools that focus on
one specific task or a specific part of the life-cycle. CASE
environments are classified as follows:
•Toolkits (typically build on operating system
workbenches)
• 4GL, Language-centered, Integrated, Process-centered
Upper CASE Tools:
Support strategic, planning and
construction of conceptual level product
and ignore the design aspect. They
support traditional diagrammatic
languages such as ER diagrams, Data
flow diagram, Structure charts etc.
Lower CASE Tools :
Concentrate on the back end activities of
the software life cycle and hence support
activities like physical design, debugging,
construction, testing, integration of
software components, maintenance,
reengineering and reverse engineering
activities.