SOFTWARE ENGINEERING

Computer Aided Software Engineering

CASE tool and its scope
A CASE (Computer Aided Software Engineering) tool is a generic term used to denote any form of
automated support for software engineering. In a more restrictive sense, a CASE tool means any tool used to
automate some activity associated with software development. Many CASE tools are available. Some of
these CASE tools assist in phase related tasks such as specification, structured analysis, design, coding,
testing, etc.; and others to non-phase activities such as project management and configuration management.

Reasons for using CASE tools

The primary reasons for using a CASE tool are:
• To increase productivity
• To help produce better quality software at lower cost

CASE environment
Although individual CASE tools are useful, the true power of a tool set can be realized only when these set of
tools are integrated into a common framework or environment. CASE tools are characterized by the stage or
stages of software development life cycle on which they focus. Since different tools covering different stages
share common information, it is required that they integrate through some central repository to have a
consistent view of information associated with the software development artefacts. This central repository is
usually a data dictionary containing the definition of all composite and elementary data items. Through the
central repository all the CASE tools in a CASE environment share common information among themselves.
Thus, a CASE environment facilities the automation of the step-by-step methodologies for software
development. A schematic representation of a CASE environment is shown in the figure below.

A CASE Environment
1
CASE environment vs programming environment
A CASE environment facilitates the automation of the step-by-step methodologies for software development.
In contrast to a CASE environment, a programming environment is an integrated collection of tools to support
only the coding phase of software development.

Benefits of CASE
Several benefits accrue from the use of a CASE environment or even isolated CASE tools. Some of those
benefits are:
• A key benefit arising out of the use of a CASE environment is cost saving through all development
phases. Different studies carry out to measure the impact of CASE put the effort reduction between
30% to 40%.
• Use of CASE tools leads to considerable improvements to quality. This is mainly due to the facts that
one can effortlessly iterate through the different phases of software development and the chances of
human error are considerably reduced.
• CASE tools help produce high quality and consistent documents. Since the important data relating to a
software product are maintained in a central repository, redundancy in the stored data is reduced and
therefore chances of inconsistent documentation is reduced to a great extent.
• CASE tools take out most of the drudgery in a software engineer’s work. For example, they need not
check meticulously the balancing of the DFDs but can do it effortlessly through the press of a button.
• CASE tools have led to revolutionary cost saving in software maintenance efforts. This arises not only
due to the tremendous value of a CASE environment in traceability and consistency checks, but also
due to the systematic information capture during the various phases of software development as a
result of adhering to a CASE environment.
• Introduction of a CASE environment has an impact on the style of working of a company, and makes it
oriented towards the structured and orderly approach.

Requirements of a prototyping CASE tool

Prototyping is useful to understand the requirements of complex software products, to demonstrate a
concept, to market new ideas, and so on. The important features of a prototyping CASE tool are as follows:
• Define user interaction
• Define the system control flow
• Store and retrieve data required by the system
• Incorporate some processing logic

Features of a good prototyping CASE tool

There are several stand-alone prototyping tools. But a tool that integrates with the data dictionary can make
use of the entries in the data dictionary, help in populating the data dictionary and ensure the consistency
between the design data and the prototype. A good prototyping tool should support the following features:
• Since one of the main uses of a prototyping CASE tool is graphical user interface (GUI) development,
prototyping CASE tool should support the user to create a GUI using a graphics editor. The user
should be allowed to define all data entry forms, menus and controls.
• It should integrate with the data dictionary of a CASE environment.

2
 • If possible, it should be able to integrate with external user defined modules written in C or some
popular high level programming languages.
• The user should be able to define the sequence of states through which a created prototype can run.
The user should also be allowed to control the running of the prototype.
• The run time system of prototype should support mock runs of the actual system and management of
the input and output data.

Structured analysis and design with CASE tools

Several diagramming techniques are used for structured analysis and structured design. The following
supports might be available from CASE tools.
• A CASE tool should support one or more of the structured analysis and design techniques.
• It should support effortlessly drawing analysis and design diagrams.
• It should support drawing for fairly complex diagrams, preferably through a hierarchy of levels.
• The CASE tool should provide easy navigation through the different levels and through the design and
analysis.
• The tool must support completeness and consistency checking across the design and analysis and
through all levels of analysis hierarchy. Whenever it is possible, the system should disallow any
inconsistent operation, but it may be very difficult to implement such a feature. Whenever there arises
heavy computational load while consistency checking, it should be possible to temporarily disable
consistency checking.

Code generation and CASE tools

As far as code generation is concerned, the general expectation of a CASE tool is quite low. A reasonable
requirement is traceability from source file to design data. More pragmatic supports expected from a CASE
tool during code generation phase are the following:

• The CASE tool should support generation of module skeletons or templates in one or more popular
languages. It should be possible to include copyright message, brief description of the module, author
name and the date of creation in some selectable format.
• The tool should generate records, structures, class definition automatically from the contents of the data
dictionary in one or more popular languages.
• It should generate database tables for relational database management systems.
• The tool should generate code for user interface from prototype definition for X window and MS window
based applications.

Test case generation CASE tool

The CASE tool for test case generation should have the following features:
• It should support both design and requirement testing.
• It should generate test set reports in ASCII format which can be directly imported into the test plan
document.

3
Hardware and environmental requirements
In most cases, it is the existing hardware that would place constraints upon the CASE tool selection. Thus,
instead of defining hardware requirements for a CASE tool, the task at hand becomes to fit in an optimal
configuration of CASE tool in the existing hardware capabilities. Therefore, it can be emphasized on
selecting the most optimal CASE tool configuration for a given hardware configuration.
The heterogeneous network is one instance of distributed environment and this can be chosen for illustration
as it is more popular due to its machine independent features. The CASE tool implementation in
heterogeneous network makes use of client-server paradigm. The multiple clients who run different modules
access data dictionary through this server. The data dictionary server may support one or more projects.
Though it is possible to run many servers for different projects but distributed implementation of data
dictionary is not common.
The tool set is integrated through the data dictionary which supports multiple projects, multiple users working
simultaneously and allows to share information between users and projects. The data dictionary provides
consistent view of all project entities, e.g. a data record definition and its entity-relationship diagram be
consistent. The server should depict the per-project logical view of the data dictionary. This means that it
should allow back up/restore, copy, cleaning part of the data dictionary, etc.

The tool should work satisfactorily for maximum possible number of users working simultaneously. The tool
should support multi-windowing environment for the users. This is important to enable the users to see more
than one diagram at a time. It also facilitates navigation and switching from one part to the other.

Documentation support
The deliverable documents should be organized graphically and should be able to incorporate text and diagrams
from the central repository. This helps in producing up-to-date documentation. The CASE tool should integrate
with one or more of the commercially available desktop publishing packages. It should be possible to export text,
graphics, tables, data dictionary reports to the DTP package in standard forms such as PostScript.

Project management support

The CASE tool should support collecting, storing, and analyzing information on the software project’s progress
such as the estimated task duration, scheduled and actual task start, completion date, dates and results of the
reviews, etc.

External interface
The CASE tool should allow exchange of information for reusability of design. The information which is to be
exported by the CASE tool should be preferably in ASCII format and support open architecture. Similarly, the data
dictionary should provide a programming interface to access information. It is required for integration of custom
utilities, building new techniques, or populating the data dictionary.

Reverse engineering
The CASE tool should support generation of structure charts and data dictionaries from the existing source codes.
It should populate the data dictionary from the source code. If the tool is used for re-engineering information
systems, it should contain conversion tool from indexed sequential file structure, hierarchical and network
database to relational database systems.

Data dictionary interface

The data dictionary interface should provide view and update access to the entities and relations stored in it. It
should have print facility to obtain hard copy of the viewed screens. It should provide analysis reports like cross-
referencing, impact analysis, etc. Ideally, it should support a query language to view its contents.

4
Second-generation CASE tool
An important feature of the second-generation CASE tool is the direct support of any adapted methodology. This
would necessitate the function of a CASE administrator organization who can tailor the CASE tool to a particular
methodology. In addition, the second-generation CASE tools have following features:
• Intelligent diagramming support. The fact that diagramming techniques are useful for system
analysis and design is well established. The future CASE tools would provide help to aesthetically and
automatically lay out the diagrams.
• Integration with implementation environment. The CASE tools should provide integration between
design and implementation.
• Data dictionary standards. The user should be allowed to integrate many development tools into one
environment. It is highly unlikely that any one vendor will be able to deliver a total solution. Moreover, a
preferred tool would require tuning up for a particular system. Thus the user would act as a system
integrator. This is possibly only if some standard on data dictionary emerges.
• Customization support. The user should be allowed to define new types of objects and connections.
This facility may be used to build some special methodologies. Ideally it should be possible to specify
the rules of a methodology to a rule engine for carrying out the necessary consistency checks.

Architecture of a CASE environment

The architecture of a typical modern CASE environment is shown diagrammatically in fig. 15.2. The
important components of a modern CASE environment are user interface, tool set, object management
system (OMS), and a repository. Characteristics of a tool set have been discussed earlier.

User Interface
The user interface provides a consistent framework for accessing the different tools thus making it easier for
the users to interact with the different tools and reducing the overhead of learning how the different tools are
used.
Object Management System (OMS) and Repository
Different case tools represent the software product as a set of entities such as specification, design, text data,
project plan, etc. The object management system maps these logical entities such into the underlying storage
management system (repository). The commercial relational database management systems are geared towards
supporting large volumes of information structured as simple relatively short records. There are a few types of
entities but large number of instances. By contrast, CASE tools create a large number of entity and relation types
with perhaps a few instances of each. Thus the object management system takes care of appropriately mapping
into the underlying storage management system.

Architecture of a Modern CASE Environment

5