UNIT-5

Software Engineering

CASE (Computer Aided Software Engineering)

Computer-aided software engineering (CASE) is the implementation of computer-

facilitated tools and methods in software development.
CASE tools are set of software application programs, which are used to automate
SDLC activities. CASE tools are used by software project managers, analysts and
engineers to develop software system.
There are number of CASE tools available to simplify various stages of Software
Development Life Cycle such as Analysis tools, Design tools, Project Management
tools, Database Management tools, Documentation tools are to name a few.
Use of CASE tools accelerates the development of project to produce desired result
and helps to uncover flaws before moving ahead with next stage in software
development.
CASE tools may support the following developmental steps:
 Creation of data flow and entity models
 Establishing a relationship between requirements and models
 Development of top-level design
 Development of functional and process description
 Development of test cases.

The CASE tools can help in automatically generating data base tables, forms and
reports and user documentation. Thus, the CASE tools:
 support contemporary development of software systems, they may
improve the quality of the software.
 help in automating the software development life cycles by use of certain
standard methods
 create an organization wide environment that minimized repetitive work
 help developers to concentrate more on top level and more creative
problem solving tasks
 support and improve the quality of documentation, testing process,
project management and software maintenance.
 UNIT-5
Software Engineering

Categories of CASE tools:

CASE tools are classified into the following categories:
1. Upper CASE tools
2. Lower CASE tools
3. Integrated CASE tools

Upper CASE: Upper CASE tools mainly focus on the analysis and design phases
of software development. They include tools for analysis modeling, reports and forms
generation.

Lower CASE: Lower CASE tools support implementation of system development.

They include tools for coding, configuration management, etc.

Integrated CASE Tools: Integrated CASE tools help in providing linkages between
the lower and upper CASE tools. Thus, creating a cohesive environment for software
development when programming by lower CASE tools may automatically be
generated for the design that has been developed in an upper CASE tool.

Types of CASE tools:

1. Diagramming tools: It helps in diagrammatic and graphical representations of

the data and system processes. It represents system elements, control flow and
data flow among different software
 UNIT-5
Software Engineering

components and system structures in a pictorial form. e.g. Flow Chart Maker tool for making
state-of-the-art flowcharts.
2. Computer Display and Report Generators: These help in understanding the data
requirements and the relationships involved.
3. Analysis Tools: It focuses on inconsistent, incorrect specifications involved in the diagram
and data flow. It helps in collecting requirements; automatically check for any irregularity,
imprecision in the diagrams, data redundancies, or erroneous omissions.
4. Central Repository: It provides a single point of storage for data diagrams, reports and
documents related to project management.
5. Documentation Generators: It helps in generating user and technical documentation as per
standards. It creates documents for technical users and end users.
6. Code Generators: It aids in the auto-generation of code, including definitions, with the help
of designs, documents and diagrams.

Advantages of the CASE approach:

 The overall quality of the product is improved as an organized approach is undertaken

during the process of development.
 Chances to meet real-world requirements are more likely and easier with a computer-aided
software engineering approach.
 CASE indirectly provides an organization with a competitive advantage by helping ensure
the development of high-quality products.
 It provides better documentation.
 It improves accuracy.
 It increases the speed of processing.

Disadvantages of the CASE Approach:

 Using case tools is very costly. Most firms engaged in software development on a small
scale do not invest in CASE tools because they think that the benefit of CASE is justifiable
only in the development of large systems.
 In most cases, programmers’ productivity may fall in the initial phase of implementation,
because users need time to learn the technology.

Characteristics of CASE Tools :

The main characteristics of the CASE Tools in Software Engineering are :
1. A graphical interface for drawing ER diagrams, DFDs, charts etc.
 UNIT-5
Software Engineering

2. A storage for information, a data dictionary for efficient information management

selection, usage and application.
3. Common user interface for integrating the various modules of the software.
4. Automated code generation.
5. Automated testing tools.
CASE Environment Architecture :
The important components of CASE environment are :

1. Project Management Tools: An organization working for the improvement of a

business process must first understand the process. It is used for representing the key
elements of a business process, so that it is better understood.

2. Risk Analysis Tool: It helps in identifying the risks in developing a plan, design and
then implementing the design.

3. Analysis and Design Tool: It enables the software to be created as a set of modules.
Analysis tool helps in analyzing the requirements of the user to determine their feasibility.
The design tool helps to convert the requirements into a detailed and easily manageable
design.

4. Quality Assurance Tool: Quality assurance tools actually consists of the metrics that
audit source code for determining their compliance with standards.

5. Testing Tool: Testing tools are mainly used for making the task of software testing
easier.

The two categories of testing tools are :

(i) Dynamic measurement.
(ii) Stimulation test management.
 UNIT-5
Software Engineering

Software Maintenance
Software Maintenance is the process of modifying a software product after it has been
delivered to the customer. The main purpose of software maintenance is to modify and
update software application after delivery to correct faults and to improve performance.
Need for Maintenance –
Software Maintenance must be performed in order to:
 Correct faults.
 Improve the design.
 Implement enhancements.
 Interface with other systems.
 Accommodate programs so that different hardware, software, system features, and
telecommunications facilities can be used.
 Migrate legacy software.
 Retire software.
 UNIT-5
Software Engineering

Categories of Software Maintenance –

Maintenance can be divided into the following:

1.Corrective maintenance:
Corrective maintenance of a software product may be essential either to rectify some bugs
observed while the system is in use, or to enhance the performance of the system.
2.Adaptive maintenance:
This includes modifications and updations when the customers need the product to run on new
platforms, on new operating systems, or when they need the product to interface with new
hardware and software.
3.Perfective maintenance:
A software product needs maintenance to support the new features that the users want or to
change different types of functionalities of the system according to the customer demands.
 UNIT-5
Software Engineering

4.Preventive maintenance:
This type of maintenance includes modifications and updations to prevent future problems of
the software. It goals to attend problems, which are not significant at this moment but may
cause serious issues in future.
Reverse Engineering –
Reverse Engineering is processes of extracting knowledge or design information from
anything man-made and reproducing it based on extracted information. It is also called
back Engineering. Software Reverse Engineering –
Software Reverse Engineering is the process of recovering the design and the requirements
specification of a product from an analysis of it’s 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.
Why Reverse Engineering?
 Providing proper system documentatiuon.
 Recovery of lost information.
 Assisting with maintenance.
 Facility of software reuse.
 Discovering unexpected flaws or faults.
Used of Software Reverse Engineering –
 Software Reverse Engineering is used in software design, reverse engineering enables the
developer or programmer to add new features to the existing software with or without
knowing the source code.
 Reverse engineering is also useful in software testing, it helps the testers to study the virus
and other malware code .
Cost of Maintenance
Reports suggest that the cost of maintenance is high. A study on estimating software
maintenance found that the cost of maintenance is as high as 67% of the cost of entire
software process cycle.
 UNIT-5
Software Engineering

On an average, the cost of software maintenance is more than 50% of all SDLC phases. There
are various factors, which trigger maintenance cost go high, such as:
Real-world factors affecting Maintenance Cost

 The standard age of any software is considered up to 10 to 15 years.

 Older softwares, which were meant to work on slow machines with less memory and
storage capacity cannot keep themselves challenging against newly coming enhanced
softwares on modern hardware.
 As technology advances, it becomes costly to maintain old software.
 Most maintenance engineers are newbie and use trial and error method to rectify
problem.
 Often, changes made can easily hurt the original structure of the software, making it
hard for any subsequent changes.
 Changes are often left undocumented which may cause more conflicts in future.
Software-end factors affecting Maintenance Cost

 Structure of Software Program

 Programming Language
 Dependence on external environment
 Staff reliability and availability
 UNIT-5
Software Engineering

Maintenance Activities
IEEE provides a framework for sequential maintenance process activities. It can be used in
iterative manner and can be extended so that customized items and processes can be
included.

These activities go hand-in-hand with each of the following phase:

 Identification & Tracing - It involves activities pertaining to identification of
requirement of modification or maintenance. It is generated by user or system may
itself report via logs or error messages.Here, the maintenance type is classified also.
 Analysis - The modification is analyzed for its impact on the system including safety
and security implications. If probable impact is severe, alternative solution is looked
for. A set of required modifications is then materialized into requirement specifications.
The cost of modification/maintenance is analyzed and estimation is concluded.
 Design - New modules, which need to be replaced or modified, are designed against
requirement specifications set in the previous stage. Test cases are created for
validation and verification.
 Implementation - The new modules are coded with the help of structured design
created in the design step.Every programmer is expected to do unit testing in parallel.
 UNIT-5
Software Engineering

 System Testing - Integration testing is done among newly created

modules. Integration testing is also carried out between new modules and
the system. Finally the system is tested as a whole, following regressive
testing procedures.
 Acceptance Testing - After testing the system internally, it is tested for
acceptance with the help of users. If at this state, user complaints some
issues they are addressed or noted to address in next iteration.
 Delivery - After acceptance test, the system is deployed all over the
organization either by small update package or fresh installation of the
system. The final testing takes place at client end after the software is
delivered.
Training facility is provided if required, in addition to the hard copy of user
manual.
Maintenance management - Configuration management is an essential part
of system maintenance. It is aided with version control tools to control
versions, semi-version or patch management

Software Reuse: An Overview

Definition:
Software reuse refers to the practice of using existing software, components, or systems in new
projects to save time, reduce development costs, and improve software quality. This
involves leveraging previously developed software modules, libraries, frameworks, or
other components in the design and implementation of new systems.
Introduction:
Software reuse aims to build on the principle of "not reinventing the wheel." Instead of starting
from scratch every time, developers can use components that have already been created
and tested, reducing the effort needed for software development. Reuse is applicable to
various levels such as code reuse, component reuse, design reuse, and even architecture
reuse. The ultimate goal is to improve productivity, consistency, and reliability across
different software systems by reusing pre-existing solutions.
 UNIT-5
Software Engineering

Reasons Behind No Reuse So Far:

Despite its benefits, there are several reasons why software reuse has not been fully realized in
many organizations:
1. Lack of Standardization: Different teams or organizations often build software
components in non-standard ways, making it hard to integrate them into different projects.
2. Lack of Awareness and Knowledge: Developers and teams may not be aware of existing
reusable components or may not know how to reuse them effectively.
3. Complexity in Reuse: Reusing software can be more complex than creating new solutions.
Components often require significant adaptation to fit into new contexts, which can
outweigh the benefits of reuse.
4. Cultural Resistance: There can be a cultural resistance to reuse because of an inclination
to reinvent or build new solutions rather than using existing ones.
5. Inadequate Documentation: For reuse to be successful, proper documentation is needed.
Without this, understanding how a component works and how it can be reused becomes a
challenge.
6. Incompatibility: The software environment or system constraints in one project may differ
significantly from the environment in which the original software component was
developed, making reuse difficult.
7. High Upfront Costs: Establishing a reusable component library or system requires upfront
investment in terms of time, money, and expertise.
Basic Issues in Any Reuse Program:
When implementing a software reuse program, several challenges and issues need to be
addressed:
1. Component Identification: Identifying which parts of the system are reusable and which
are not can be a difficult task.
2. Granularity: Determining the right level of granularity for reusable components is
challenging. Too small and it might not provide enough functionality; too large and it might
be too complex and difficult to integrate.
3. Adaptability: Reusable components often need to be adapted for use in different projects,
leading to compatibility issues and integration challenges.
4. Quality Assurance: Ensuring that reused components are of high quality, reliable, and
bug-free is critical to maintaining the overall quality of the software system.
 UNIT-5
Software Engineering

5. Maintenance: Reused software components may require ongoing maintenance and

updates, particularly as the environment and systems evolve.
6. Version Control: Managing different versions of reusable components, especially in
large-scale systems, requires a robust version control system.
7. Security: Reused software must be evaluated for security vulnerabilities, especially if it is
being integrated into a different context or environment.
A Reuse Approach:
There are several approaches to implementing software reuse within an organization:
1. Libraries and Frameworks: Building a centralized repository of reusable components
such as functions, classes, or frameworks. These libraries make it easier for developers to
find and use existing solutions.
2. Component-Based Development (CBD): Developing systems by assembling pre-
existing software components. These components can be purchased or developed
internally. CBD often uses a well-defined interface for interoperability.
3. Service-Oriented Architecture (SOA): SOA promotes reusing services over a network,
which can be developed independently and reused across multiple applications.
4. Patterns and Templates: Design patterns and software templates provide reusable
solutions to common design problems, promoting best practices and reducing the need to
reinvent solutions.
5. Automated Tools: Tools such as code analyzers, component search engines, and
integration frameworks that support and streamline the reuse process.
6. Versioning and Documentation: Ensuring that components are well-documented and that
version control systems are in place to track updates and changes.
 UNIT-5
Software Engineering

Reuse at Organization Level:

At the organizational level, software reuse involves setting up policies, processes, and tools to
promote the development and integration of reusable components across the entire
organization. Here’s how organizations can approach it:
1. Establish a Reuse Strategy: Develop an organizational strategy that defines goals,
processes, and best practices for software reuse. This strategy should also focus on how
reusable components will be maintained and updated.
2. Component Repository: Create a shared repository or knowledge base where reusable
components are stored. This could be an internal library of software modules, frameworks,
or services that developers can easily search and access.
3. Incentivize Reuse: Organizations should foster a culture of reuse by providing incentives
or recognition to teams and developers who contribute reusable components. This could
include internal awards or recognition in performance reviews.
4. Standardization and Documentation: Define clear standards for developing and
documenting reusable components to ensure consistency and ease of use. Documentation
should include information on component functionality, dependencies, and usage
instructions.
5. Training and Awareness: Provide training programs to help developers understand the
value of reuse and how to use reusable components effectively. Developers should be
educated about available resources and the benefits of reusing existing solutions.
6. Monitoring and Metrics: Track and measure the success of the reuse program using
metrics like cost savings, development time reduction, and component usage statistics.
7. Governance and Quality Control: Establish governance processes to ensure that reused
components meet the required quality standards, are secure, and are well-maintained.
8. Tool Support: Provide tools that help developers search, adapt, and integrate reusable
components. Tools for versioning, testing, and managing components are crucial to the
success of the reuse program.
UNIT-5
Software Engineering