UNIT-5

CASE stands for Computer Aided Software Engineering.

CASE AND ITS SCOPE;

It means development and maintenance of software projects with help of various automated software tools.
CASE Tools 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.

Components of CASE Tools :

CASE tools can be broadly divided into the following parts based on their use at a particular SDLC stage:

• Central Repository - CASE tools require a central repository, which can serve as a source of common,
integrated and consistent information.

Central repository is a central place of storage where product specifications, requirement documents, related
reports and diagrams, other useful information regarding management are stored. Central repository also serves
as data dictionary

• Upper Case Tools - Upper CASE tools are used in planning, analysis and design stages of SDLC.

• Lower Case Tools - Lower CASE tools are used in implementation, testing and maintenance.

• Integrated Case Tools - Integrated CASE tools are helpful in all the stages of SDLC, from Requirement
gathering to Testing and documentation.
CASE Environment

A CASE (Computer-Aided Software Engineering) environment consists of a collection of tools, techniques, and
a central repository that helps software engineers automate and manage different stages of software
development. The central repository serves as a shared database that stores project-related information and
integrates various CASE tools.

These tools support activities such as coding, project management, prototyping, configuration management,
documentation generation, structured analysis, and reporting. The goal of a CASE environment is to improve
software quality, ensure consistency, and enhance team collaboration while reducing development time and
effort.

Components of CASE Tools

Computer aided software engineering CASE tools tool components can be divided into three main categories
depending on the Software Development Life Cycle phases. Each type plays an essential role in facilitating
specific stages of software development and providing efficiency and consistency.

Central Repository

The central repository is the core component of CASE tools. It acts as a shared database where all project-
related information, including system models, documentation, and design elements, is stored. This ensures
consistency, easy access, and collaboration among developers, testers, and project managers.
Categories of CASE tools:

CASE tools are classified into three main categories based on their role in different phases of the Software
Development Life Cycle (SDLC), CASE tools are classified into the following categories:

1. Upper CASE tools

These tools support the early stages of software development, including planning, requirement analysis, and
system design. They help in diagramming, modeling, and documentation, ensuring a well-structured blueprint
for the software. Examples include ER diagrams, data flow diagrams (DFD), and UML modeling tools.

2. Lower CASE tools

These tools assist in the later phases of development, such as coding, testing, debugging, and maintenance. They
help automate code generation, error detection, and software deployment. Examples include compilers,
debuggers, and test management tools.

3. Integrated CASE tools

Integrated CASE tools provide end-to-end support throughout the entire SDLC, combining both Upper and
Lower CASE functionalities. They allow seamless design, coding, testing, and documentation within a single
framework, improving software consistency and reducing errors. Examples include IBM Rational Rose and
Enterprise Architect.

1. Upper CASE Tools (U-CASE)

These case tools in software engineering are used during the initial stages of software development, focusing on
planning, analysis, and design. They assist developers in understanding project requirements and creating high-
level system models that act as blueprints for the software.

Functions:

 Requirements Gathering: Collecting and documenting user needs to define the size of the project.
 System Design: Developing logical structures, workflows, and architectures for the software.
 High-Level Modeling: Creating diagrams such as Use Case, Data Flow, and Entity-Relationship (ER)
models to represent the software concept.

Examples of U-CASE Tools:

Here are some examples of U-Class to help you understand and recognize them better.

 IBM Rational Rose - A powerful tool for creating Unified Modeling Language (UML) diagrams and
supports object-oriented systems and workflow design.
  Sparx Systems Enterprise Architect - A complete platform for designing and visualizing software
systems and helps in development with extensive support for UML.

2. Lower CASE Tools (L-CASE)

These tools come into space during the later stages of development and are geared toward implementing,
testing, and maintaining the software. They help simplify repetitive and detailed tasks, which ensures code
quality and easier software management post-deployment.

Functions:

 Coding Support: It Provides tools and environments that help developers write clean and efficient
code.
 Testing: It enables automated and manual testing to identify bugs and ensure functionality.‍
 Maintenance: It Supports updates and fixes after the software has been deployed.

Examples of L-CASE Tools:

Here are some examples of L-CASE Tools In Software Engineering to help you understand and identify them
effectively.

 Microsoft Visual Studio - An integrated development environment (IDE) that offers features like code
editing, debugging, and performance profiling. It also supports multiple programming languages and
frameworks.
 Git - A version control system that helps developers track code changes, manage project versions
effectively, and facilitate collaboration among team members.
 Selenium- A testing tool specifically for web applications that allows developers to automate browser
interactions to validate application functionality.

3. Integrated CASE Tools (I-CASE)

Integrated computer aided software engineering case tools provide a complete solution that supports all phases
of the SDLC, from planning and design to implementation and maintenance. They combine the features of
upper and lower CASE tools to create a unified environment for seamless workflow management.

Functions:

 This bridges the gap between early design and actual implementation.
 It facilitates traceability and consistency across the entire development lifecycle.
 This Supports model-to-code generation and vice versa.

Examples of I-CASE Tools:

Here are some examples of I-CASE tools to help you educate yourself with them.

 IBM Rational Software Architect - An end-to-end solution for designing, coding, and deploying
software applications, also offers advanced support for modelling and integrated workflows.
 Altova UModel - A tool specifically designed for creating and managing UML diagrams, Which
provides a seamless way to connect design models with underlying code.

Types of Computer Aided Software Engineering

Computer-Aided Software Engineering (CASE) tools are essential in different stages of the Software
Development Life Cycle (SDLC). These tools make development tasks more efficient by automating and
supporting various processes. Here is the list of case tools in software engineering.

1. Diagramming Tools

Diagramming tools create visual models of systems, processes, and data flows. These tools are essential in the
early stages of development, as they help with system design and understanding its structure.

Examples:

 Flowchart Makers: It designs flowcharts that represent logic or processes.

 Entity-Relationship Diagram (ERD) Tools: This helps in modelling and visualizing the relationships
between data entities in a system.
 UML Tools: It provides diagrams like use cases, class diagrams, and sequence diagrams to design
system structures and interactions.

2. Code Generation Tools

These tools help by converting high-level models or designs into executable source code. They save developers
time and reduce the chance of human error by automating the coding process.

Examples:

 IBM Rational Rose: A tool that helps transform UML models into code in various programming
languages.
 Visual Studio Code Generation: It provides features to auto-generate portions of code based on visual
designs.

3. Testing Tools

Testing tools automate and promote various types of testing to ensure the software works as intended. These
tools help catch bugs early, which improves software quality before release.
Examples:

 Selenium: An automated tool for web application testing that supports tasks like regression testing.
 JUnit: A framework for Java applications that helps in unit testing by automating tests for individual
pieces of code.

4. Debugging Tools

Debugging tools assist developers in locating and fixing bugs in their code. These tools provide step-by-step
implementation and allow developers to identify where and why errors occur.

Examples:

 GDB (GNU Debugger): A mostly used debugger for C/C++ that allows step-through code execution.
 Visual Studio Debugger: It is integrated into Visual Studio that helps find and resolve bugs while
coding in various languages.

5. Version Control Systems

Version control tools track changes to the source code over time, enabling developers to manage multiple
software versions. These tools also make it easier for teams to work on the same project without code conflicts.

Examples:

 Git: A distributed version control system that tracks code changes and enables collaboration.
 Subversion (SVN): A centralized version control system commonly used to track changes in project
files.

6. Project Management Tools

These tools help plan, organize, and monitor the progress of a software project, confirming that deadlines are
met, resources are efficiently allocated, and tasks are completed on time.

Examples:

 JIRA: A tool for tracking issues, managing projects, and supporting Agile methods.
 Trello: A simple and visual project management tool to organize and track tasks and project
milestones.

7. Documentation Tools

Documentation tools automate the creation of user manuals, technical documentation, and design specifications,
all of which directly originate from code or design models.
Examples:

 Doxygen: A tool that generates documentation from code comments and is useful for creating
reference manuals.
 Sphinx: A documentation generator used in Python projects to produce highly readable and structured
documentation.

8. Maintenance Tools

Maintenance tools track and manage software issues after deployment, which confirms that updates,
enhancements, or bug fixes are handled effectively.

Examples:

 Bugzilla: An issue-tracking tool that helps developers log and manage bugs or feature requests.
 ServiceNow: A tool for IT service management that provides features for managing software
maintenance.

9. Process-Centric CASE Tools

Process-centric computer aided software engineering CASE tools help in managing the overall software
development process, including requirements management, system design, coding, testing, and deployment.

Examples:

 IBM Rational Unified Process (RUP): A framework that defines the stages and milestones in the
software development lifecycle.
 Microsoft Visual Studio Team System: A set of tools supporting the entire development process from
planning to deployment.

10. Object-Oriented CASE Tools

These tools are designed to help with object-oriented software development by managing classes, objects, and
relationships in an object-oriented system.

Examples:

 Oracle JDeveloper: An integrated development environment supporting object-oriented development

for Java applications.
 Embarcadero Delphi: A development tool designed to build applications using object-oriented
principles like inheritance, encapsulation, and polymorphism.

CASE support in the software life cycle

 CASE (Computer-Aided Software Engineering) tools provide support throughout the Software Development
Life Cycle (SDLC) by automating various tasks and improving the overall process. They help in areas like
analysis, design, implementation, testing, and maintenance, making software development more efficient and
effective.

Here's how CASE tools support the SDLC:

 Requirement Gathering and Analysis:
CASE tools help in understanding, documenting, and analyzing user requirements, ensuring a clear
understanding of the project goals.
 Design:
They assist in designing the software architecture, database structures, and other components, ensuring a well-
structured and maintainable system.
 Implementation:
CASE tools can automate code generation, reducing manual coding effort and potential errors.
 Testing:
They help in creating test cases, automating testing procedures, and analyzing test results, ensuring the quality
of the software.
 Maintenance:
CASE tools facilitate the management of software changes, version control, and bug fixes, ensuring the long-
term viability of the system.

OTHER CHARACTERISTICS OF CASE TOOLS

CASE tools offer features like integration, collaboration, requirements traceability, and support for various
software development stages, including analysis, design, implementation, and testing.

Here's a more detailed look at other key characteristics of CASE tools:

Key Features and Characteristics:

 Automation:
CASE tools automate repetitive tasks like designing, coding, and testing, reducing manual effort and
improving efficiency.
 Consistency:
They ensure uniformity by implementing standard practices and processes across teams, leading to improved
quality and reduced errors.
 Integration:
CASE tools connect various stages of the software development process, allowing for seamless transitions and
efficient workflows.
 Collaboration:
They promote effective communication and teamwork among developers, testers, and project managers,
enhancing overall coordination.
 Requirements Traceability:
They enable tracking requirements throughout the development lifecycle, ensuring that the final product meets
the initial specifications.
 Support for Different Stages:
CASE tools can support various stages of the software development life cycle, including analysis, design,
implementation, and testing.
 Diagramming and Modeling:
 Many CASE tools provide features for creating visual diagrams, flowcharts, and UML diagrams, facilitating
understanding and communication.

 Code Generation:
Some CASE tools can automatically generate code from design specifications, accelerating the development
process.
 Documentation:
They often include features for generating comprehensive and well-organized documentation, making it easier
for team members to reference project requirements, design decisions, and coding standards.
 Centralized Repository:
Many CASE tools incorporate a central repository to store project artifacts, such as diagrams, reports, and
documents, facilitating easy access and collaboration.
 Flexibility:
They should be flexible enough to adapt to different software development methodologies and modeling
techniques.
 Reverse Engineering:
Some CASE tools support reverse engineering, allowing developers to analyze existing software and
understand its architecture and functionality.
 Integration with Testing Tools:
They should integrate with automated testing tools, enabling efficient and thorough testing of the software.
 Scalability:
CASE tools are designed to support large-scale software development projects with complex requirements.
 Improved Productivity:
By automating tasks and improving collaboration, CASE tools can lead to significant improvements in
productivity
 Enhanced Quality Assurance:
CASE tools can help ensure that the final product meets established standards and requirements by automating
testing and providing features for quality analysis.
 Cost Savings:
The CASE approach can lead to significant cost savings by reducing development time, improving quality, and
minimizing rework.

Second-generation CASE (Computer-Aided Software Engineering) tools, introduced in the 1980s and
1990s, significantly advanced software development by offering integration across the entire
Software Development Life Cycle (SDLC). Unlike first-generation tools that focused primarily on
documentation and design, second-generation tools supported requirements gathering, design,
code generation, testing, and maintenance. They also featured automatic code generation, better
database design support, and prototyping capabilities. Tools were more graphical and user-friendly,
enabling better collaboration among developers, analysts, and managers. However, they were often
complex, costly, and not always flexible for different methodologies. Examples include Rational Rose
and Oracle Designer.

You said:
towards second generation case tool IN SOFTWARE ENGINEERING 10 MARKS ANSWER POINTS WISE
Second-Generation CASE Tools in Software Engineering

1. Introduction to Second-Generation CASE Tools

Second-generation CASE (Computer-Aided Software Engineering) tools emerged in the late 1980s
and early 1990s as an advancement over first-generation tools. They were designed to support a
broader range of activities within the Software Development Life Cycle (SDLC), improving both the
automation and integration of tasks involved in software development.

2. Integration Across SDLC Phases

 Unlike first-generation tools, which focused on isolated tasks such as documentation and
design, second-generation tools provided integration across multiple SDLC phases, such as:
o Requirements gathering
o System design
o Coding
o Testing
o Maintenance
 This allowed a unified approach to software development, ensuring consistency across all
stages.

3. Support for Automated Code Generation

 One of the key innovations of second-generation CASE tools was the automatic generation
of code.
 Based on design models (e.g., Entity-Relationship diagrams or UML models), these tools
could automatically generate skeleton code in specific programming languages, reducing
manual coding efforts and potential errors.

4. Graphical User Interfaces (GUIs)

 Second-generation CASE tools introduced Graphical User Interfaces (GUIs), making them
more user-friendly and accessible to non-technical users like business analysts and project
managers.
 The GUI allowed for point-and-click interaction with tools, replacing earlier text-based or
command-line interfaces.

5. Support for Prototyping and User Interaction

  Prototyping tools became a core feature in this generation, particularly for user interface
design.
 Developers could rapidly prototype applications, allowing users to interact with early
versions of the software and provide feedback, which was crucial for iterative development.

6. Database Design and Management

 Second-generation CASE tools provided advanced database support, including:

o Entity-Relationship (ER) modeling
o Automatic SQL script generation
o Normalization of database schemas
o Data migration and management
 These tools helped bridge the gap between design and database implementation, improving
database design consistency.

SOFTWARE MAINTENANCE

Characteristics of software maintenance

 Modularity:
The software should be designed in a modular way, allowing for independent
maintenance and updates of individual components.
 Readability:
The code should be easy to understand and maintain, following coding standards and
using clear and concise naming conventions.
 Testability:
The software should be designed in a way that makes it easy to write and execute
automated tests.
 Flexibility:
The software should be flexible enough to accommodate changing requirements and
adapt to new technologies.
 Scalability:
The software should be designed to handle increasing workloads and user demands.
 Reusability:
Components and modules should be designed to be reusable in other applications.
 Portability:
The software should be able to run on different platforms and environments.
 Maintainability:
The software should be designed to be easy to maintain and modify.
 SOFTWARE REVERSE ENGINEERING

The process of analyzing a system or product to learn how it functions

without having access to the source code or design is known as reverse
engineering. This is frequently used with hardware, software, and other
technologies. "Reverse engineering" refers to the process of reproducing
the final product structure, design, or functionality by going backward
from it.

This kind of engineering is often referred to as backward engineering.

Reverse engineering is a process like forward engineering, but it is carried
out in reverse. Information from the pre-existing given application is
gathered during this step. This technique takes considerably less time
when creating an application than forward engineering. Reverse
engineering disassembles an application into little systems to discover its
internal architecture or knowledge.

DIAGRAM

SOFTWARE MAINTENANCE PROCESS MODELS

Software maintenance process models provide frameworks for managing and evolving
software systems after they are deployed. Process Model-1 typically involves directly
changing code and reflecting these changes in documentation, while Process Model-2 is
suitable for projects with significant rework, potentially involving a more iterative and
reengineering approach.

Elaboration:
Process Model-1:
 This model emphasizes direct code modification and subsequent documentation
updates.
 It's suitable for projects where the changes are relatively small and the impact on the
overall system is manageable.
 The process involves identifying a problem, analyzing its root cause, designing a
solution, implementing the changes, and then updating relevant documentation.
Process Model-2:
 This model is designed for projects with larger-scale changes or where the system's
architecture needs significant adjustments.
 It often involves a more iterative approach, where changes are made incrementally, and
the system is reengineered to accommodate the new requirements.
 Process Model-2 may also incorporate techniques like full reuse or iterative
reengineering to manage the complexity of the maintenance effort.

DIAGRAMS