Reasons for Using CASE Tools

The primary reasons for employing a CASE tool are:

• To extend productivity

• To assist in turning out higher quality codes at a lower price

The architecture of a CASE environment consists of several components that work together to
provide a comprehensive solution for software development.
1. User Interface

The user interface provides a regular framework for accessing the various tools so creating it
easier for the users to act with the different tools and reducing the overhead of learning
however the different tools are used.

2. Object Management System (OMS) and Repository

Different case tools represent the product as a group of entities like specification, design, text
data, project arrange, etc. the thing management system maps these logical entities such into
the underlying storage management system (repository).

Data Management

Data management is a critical component of a CASE environment. It involves the storage,

retrieval, and manipulation of data related to the software development process. The data
management component should be able to handle a large volume of data efficiently and
provide secure access to authorized users.
• Modelling and Analysis Tools
• Modeling and analysis tools are used to create models of
software systems and analyze their behavior. These tools are
essential for understanding the requirements of a software
system and identifying potential problems before they occur.
They include tools such as flow charting, data flow diagrams,
and object-oriented modeling.
• Code Generation
• code generation is the process of automatically generating code
from models or specifications. This component of the CASE
environment helps to reduce the amount of time and effort
required to write code manually. It should support multiple
programming languages and be customizable to fit specific
project requirements
Testing and Debugging

• Testing and debugging are essential components of software engineering. The

CASE environment should provide tools to enable developers to test and debug
software systems efficiently. These tools include automated testing tools,
debugging tools, and performance profiling tools.

Version Control

Version control is a critical component of software engineering. It enables

developers to track changes to software systems and manage multiple versions of
the same software system. The CASE environment should support version control
and provide tools to enable developers to manage software versions effectively.

Collaboration

• Collaboration is a crucial component of software development. The CASE

environment should provide tools to enable developers to collaborate effectively
on software development projects. These tools include communication tools,
project management tools, and workflow tools.
1.CASE tools square measure characterized by the stage or stages of package
development life cycle that they focus on.
2.Since different tools covering different stages share common data, it’s needed
that they integrate through some central repository to possess an even read of
data related to the package development artifacts.
3.This central repository is sometimes information lexicon containing the
definition of all composite and elementary data things.
4.Through the central repository, all the CASE tools in a very CASE setting share
common data among themselves. therefore, a CASE setting facilities the
automation of the step-wise methodologies for package development
Characteristics of case tools
Second-generation CASE tool
Software Reverse Engineering
• Software Reverse Engineering is the process of recovering the
design and the requirements specification of a product from an
analysis of its code. Reverse Engineering is becoming important,
since several existing software products, lack proper
documentation, are highly unstructured, or their structure has
degraded through a series of maintenance efforts.
• Uses of Software Reverse Engineering
• Malware analysis: Reverse engineering is used to understand how malware works and to identify the vulnerabilities it
exploits, in order to develop countermeasures.

• Legacy systems: Reverse engineering can be used to understand and maintain legacy systems that are no longer supported
by the original developer.

• Intellectual property protection: Reverse engineering can be used to detect and prevent intellectual property theft by
identifying and preventing the unauthorized use of code or other assets.

• Security: Reverse engineering is used to identify security vulnerabilities in a system, such as backdoors, weak encryption, and
other weaknesses.

• Compliance: Reverse engineering is used to ensure that a system meets compliance standards, such as those for accessibility,
security, and privacy.

• Reverse-engineering of proprietary software: To understand how a software works, to improve the software, or to create
new software with similar features.

• Reverse-engineering of software to create a competing product: To create a product that functions similarly or to identify
the features that are missing in a product and create a new product that incorporates those features.

• It’s important to note that reverse engineering can be a complex and time-consuming process, and it is important to have the
necessary skills, tools, and knowledge to perform it effectively. Additionally, it is important to consider the legal and ethical
implications of reverse engineering, as it may be illegal or restricted in some jurisdictions.
Primary Uses of Boehm’s Model
The highest level of Boehm’s model has the following three primary
uses, as stated as below:
1.As is the utility: The extent to which, we can use software as-is.

2.Maintainability: Effort required to detect and fix an error during

maintenance.

3.Portability: Effort required to change the software to fit in a new

environment.
Boehm’s Primitive Constructs for Software Quality Characteristics
Boehm further classified software quality characteristics into
more fundamental components called Primitive Constructs.
These include:
• Device Independence

• Accuracy

• Completeness

• Consistency

• Device Efficiency

• Accessibility

• Communicativeness

• Self-descriptiveness

• Legibility

• Structuredness

• Conciseness

• Augment-ability
• Conciseness

• Augment-ability
What is software reuse?
Software reuse is a term used for developing the software by using the
existing software components. Some of the components that can be
reuse are as follows;
• Source code
• Design and interfaces
• User manuals
• Software Documentation
• Software requirement specifications and many more.
What are the advantages of software reuse?
• Less effort: Software reuse requires less effort because many components
use in the system are ready made components.
• Time-saving: Re-using the ready made components is time saving for the
software team.
• Reduce cost: Less effort, and time saving leads to the overall cost reduction.
• Increase software productivity: when you are provided with ready made
components, then you can focus on the new components that are not
available just like ready made components.
• Utilize fewer resources: Software reuse save many sources just like effort,
time, money etc.
• Leads to a better quality software: Software reuse save our time and we can
consume our more time on maintaining software quality and assurance.
What is reuse software engineering?
• Reuse software engineering is based on guidelines and principles for reusing the
existing software.
What are stages of reuse-oriented software engineering?

Requirement specification:
• First of all, specify the requirements. This will help to decide that we have some
existing software components for the development of software or not.
Component analysis
• Helps to decide that which component can be reused where
Requirement updations / modifications.
• If the requirements are changed by the customer, then still existing
components are helpful for reuse or not.
Reuse System design
• If the requirements are changed by the customer, then still existing
system designs are helpful for reuse or not.
Development
• Existing components are matching with new software or not.
Integration
• Can we integrate the new systems with existing components?
System validation
• To validate the system that it can be accepted by the customer or not.
software reuse success factors
1.Capturing Domain Variations
2.Easing Integration
3.Understanding Design Context
4.Effective Teamwork
5.Managing Domain Complexity
Basic issues in any reuse program
The following are some of the basic issues that must be for starting
any reuse program,
1.Component creation
2.Component indexing and storing
3.Component search
4.Component understanding
5.Component adaptation
6.Repository maintenance
1)Component creation
• The reusable components have to be first identified. The selection of
the correct kind of components having the potential for reuse is best.
2) Component indexing and storing
• Indexing requires classification of the again usable components so
that they can be easily found when looking for a component for
reuse. The components need to be stored in a Relational Database
Management System (RDBMS) or an Object-Oriented Database
System (ODBMS) for efficient access when the number of
components becomes large.
3) Component searching
• The programmers need to search for correct components matching
their needs in a database of components. To be able to search
components efficiently, the programmers require a perfect method
to tells the components that they are looking for
4) Component understanding
• The programmers need a prefect and sufficiently complete
understanding of what the component does to be able to decide
whether they can reuse the component or not. To understand, the
components should be well documented and should do something
simple in the code.
5) Component adaptation
• Before they can be reused, the components may need adaptation,
since a selected component may not exactly be mixed the problem at
hand. However, tinkering with the code is also not the best solution
because this is very likely to be a source of faults.
6) Repository maintenance
It once is created requires repeated maintenance. New
components, as and when made have to be entered inside the
repository. The faulty components have to be followed.
• Further, when new applications mixed, the older applications
become obsolete. In this case, the obsolete components might
have to be deleted from the repository.
• REUSE APPROACH
Components Classification
Components need to be properly classified in order to develop an
effective indexing and storage scheme. Hardware reuse has
been very successful. Hardware components are classified
using a multilevel hierarchy. At the lowest level, the components
are described in several forms: natural
language description, logic schema, timing information, etc. The
higher the level at which a component is described, the more is
the ambiguity. This has motivated the Prieto-Diaz’s classification
scheme
Prieto-Diaz’s classification scheme: Each component is best
described using a number of different characteristics or facets.
For example, objects can be classified using the following:
• Searching
The domain repository may contain thousands of reuse items. A
popular search technique that has proved to be very effective is
one that provides a web interface to the repository. Using such
a web interface, one would search an item using an
approximate automated search using key words, and then from
these results do a browsing using the links provided to look up
related items. The approximate automated search locates
products that appear to fulfill some of the specified
requirements. The items located through the approximate
search serve as a starting point for browsing the repository.
Repository maintenance - Repository maintenance involves
entering new items, retiring those items which are no more
necessary, and modifying the search attributes of items to
improve the effectiveness of search. The software industry is
always trying to implement something that has not been quite
done before. As patterns requirements emerge, new reusable
components are identified, which may ultimately become more
or less the standards.
Application generator -The problem- oriented languages are
known as application generators. Application generators
translate specifications into application programs. The
specification is usually written using 4GL. The specification
might also in a visual form. Application generator can be applied
successfully to data processing application, user interface, and
compiler development.
Advantages of application generators
Application generators have significant advantages over simple
parameterized programs. The biggest of these is that the
application generators can express the variant information in an
appropriate language rather than being restricted to function
parameters, named constants, or tables. The other advantages
include fewer errors, easier to maintain, substantially reduced
development effort, and the fact that one need not bother about
the implementation details.
Re-use at organization level
Achieving organization-level reuse requires adoption of the
following steps:
• Assessing a product’s potential for reuse
• Refining products for greater reusability
• • Entering the product in the reuse repository
Assessing a product’s potential for reuse. Assessment of components reuse
potential
can be obtained from an analysis of a questionnaire circulated among the
developers. The
questionnaire can be devised to access a component’s reusability. The
programmers
working in similar application domain can be used to answer the questionnaire about
the
product’s reusability. Depending on the answers given by the programmers, either
the
component be taken up for reuse as it is, it is modified and refined before it is
entered
into the reuse repository, or it is ignored. A sample questionnaire to assess a
component’s
reusability is the following.
• Is the component’s functionality required for implementation of systems in the