Assignment 1

1: What are some common techniques used in Software Re-engineering?

Reverse Engineering: At the forefront of software re-engineering, this technique

involves a meticulous analysis of the existing software to unveil its underlying
structure, behavior, and functionality. It serves as the initial step, providing valuable
insights into the code and documentation.

Code Refactoring: Refactoring takes the center stage, aiming to restructure the code
while preserving its external behavior. This process enhances code readability,
maintainability, and performance. It encompasses practices like variable renaming,
method extraction, and simplification of intricate code segments.

Forward Engineering: This technique revolves around the creation of a fresh system or
version of the software based on insights derived from reverse engineering. It often
necessitates the complete redesign and reimplementing of the software using
contemporary technologies and best practices.

User Involvement: Engaging end-users and stakeholders in the re-engineering process

is vital to gather requirements, validate changes, and ensure that the re-engineered
software aligns with their needs.

2. What are the benefits of Software Re-engineering?

Optimized Performance: Performance issues are addressed during the re-engineering

process, leading to software that operates more efficiently, responds swiftly, and can
handle increased workloads.

Compatibility: Legacy software often faces compatibility issues with modern hardware
and software environments. Re-engineering ensures that the software remains
compatible with current technologies.

Enhanced Maintainability: Through re-engineering, software code can be restructured,

resulting in improved readability and maintainability. This, in turn, reduces the effort
and cost associated with ongoing maintenance and updates.

Cost Savings: Although there is an initial investment in re-engineering, the long-term

savings are substantial. Lower maintenance costs, improved efficiency, and fewer
issues translate into financial benefits.

3: What are some challenges in Software Re-engineering?

Legacy Code Complexity: Grappling with intricate and poorly documented legacy code
can be a substantial challenge. Understanding and making modifications to such code
can consume significant time and lead to potential errors.

Lack of Documentation: Many legacy systems suffer from the absence of

comprehensive documentation. The scarcity of documentation makes it arduous to
comprehend the system's architecture, components, and functionality.

Cost Estimation: Precisely estimating the cost of a re-engineering project is often

elusive. Unforeseen issues and alterations in project scope can result in budget
overruns.

Integration with Existing Systems: If the re-engineered software needs to integrate

with other existing systems, ensuring seamless integration can be challenging,
particularly when there are disparities in technologies and data formats.

Time Constraints: Completing the re-engineering project within a reasonable

timeframe is often a challenge, especially if the software is critical to ongoing business
operations.

4: What is the difference between Software Re-engineering and Software Refactoring?

Aspect Software Re-engineering Software Refactoring

Software re-engineering is the process Software refactoring is the process of

of restructuring and enhancing existing improving the internal structure and
software to improve attributes like design of software without altering
maintainability, reliability, and its external functionality. It primarily
performance. It often includes focuses on enhancing code
significant changes to the software's readability, maintainability, and
Definition architecture or technology stack. efficiency.

Re-engineering typically involves a Refactoring is more narrowly

broad and extensive scope, often focused, typically targeting specific
encompassing the entire software code segments or modules within the
Scope system or a substantial portion of it. software.

- Enhancing maintainability and - Improving code quality. - Reducing

Goals
reliability. - Adapting to new technical debt. - Enhancing code
Aspect Software Re-engineering Software Refactoring

technologies or platforms. - Enhancing readability and maintainability. -

performance. - Extending the life of Minimizing the risk of introducing
legacy systems. defects.

Re-engineering often entails significant Refactoring focuses on making

changes, which may include smaller, targeted changes to the
architectural modifications, technology code, such as renaming variables,
migrations, and even rewriting parts of optimizing algorithms, or
Changes the software. restructuring code blocks.

5: What is meant by software scope?

Key elements of software scope encompass:

Functional Requirements: These delineate the specific features and functionalities that
the software must possess to fulfill its intended purpose. Functional requirements
detail the software's expected behavior and are typically documented through use
cases, user stories, or detailed feature descriptions.

Non-Functional Requirements: Non-functional requirements establish the quality

attributes of the software, including aspects such as performance, security, scalability,
and usability. These requirements specify how well the software must execute its
functions.

Inclusions: Inclusions refer to all the elements that form part of the software project,
including particular features, modules, and components. They define what the software
is expected to incorporate.

Exclusions: Conversely, exclusions explicitly specify what is not within the software
project's scope. This is a valuable element for managing expectations by clarifying
what the software will not encompass.

Constraints: Constraints are limitations or restrictions that impact the project, which
may include budget constraints, time constraints, and technological constraints. These
factors need to be considered as they can influence the project's scope.

6: What are software Requirements?

Software requirements are documented descriptions of what a software system should
achieve. They can be divided into two types:

Functional Requirements: These define what the software should do, specifying
features and interactions.

Non-Functional Requirements: These specify quality attributes like performance,

security, usability, and constraints the software must meet.

Clear and comprehensive requirements are crucial for effective software development
and ensure that the software aligns with user needs and expectations.

7: What is Software Maintenance? Explain its types.

Software maintenance involves the continuous process of managing, updating, and

enhancing software to ensure it remains effective and reliable throughout its lifecycle.
It encompasses four main types:

1. Corrective Maintenance:

 Focus: Addressing identified defects or issues.

 Activities: Identifying and fixing bugs and errors.

 Goal: Ensure error-free software operation.

2. Adaptive Maintenance:

 Focus: Adapting the software to changing environments (e.g., new

operating systems or hardware).

 Activities: Making software compatible with evolving platforms.

 Goal: Sustain functionality in changing contexts.

3. Perfective Maintenance:

 Focus: Enhancing software to improve performance, efficiency, and user

experience.

 Activities: Refactoring, optimization, and feature additions.

 Goal: Enhance quality and user satisfaction.

8: What do you know about CASE tools?

CASE (Computer-Aided Software Engineering) tools are software applications used to
aid various aspects of the software development process. These tools serve different
purposes:

1. Diagramming Tools: Create visual representations of software systems for

design and documentation.

2. Code Generation Tools: Automate code creation from high-level design models.

3. Repository Tools: Manage and store software artifacts, enabling version control
and collaboration.

4. Modeling Tools: Facilitate software modeling, aiding in system visualization and

architecture design.

5. Testing Tools: Assist in planning, executing, and managing software testing

activities.

6. Project Management Tools: Support project planning, scheduling, resource

allocation, and task tracking.

7. Requirement Management Tools: Capture, organize, and track software

requirements.

8. Analysis and Design Tools: Aid in detailed system specifications and

architectural design.

9. Documentation Tools: Generate project documents and code documentation.

10.Collaboration Tools: Enhance team collaboration, often including version control

and project communication.

11.Configuration Management Tools: Manage software component changes and

integration.

12.Quality Assurance Tools: Improve code quality through reviews, code analysis,
and metrics.

9: What is Software configuration management?

Software Configuration Management (SCM) is a systematic approach to managing and

controlling changes in software products throughout their development lifecycle. Its
primary objective is to ensure the reliability and integrity of software systems by
overseeing and documenting changes, facilitating collaboration among team members,
and supporting the software development process. Here are key elements of Software
Configuration Management:

1. Version Control: SCM systems provide mechanisms for tracking changes in

software code and documentation, enabling developers to work on different
versions of the software simultaneously and maintaining a comprehensive
history of all changes.

2. Baseline Management: SCM defines baselines, which are specific versions of the
software at significant development milestones. These baselines serve as
reference points for comparing and monitoring changes.

3. Change Control: Change control processes manage and document all proposed
changes to the software. Changes undergo review, approval, and controlled
implementation to ensure consistency and prevent unregulated alterations.

4. Release Management: SCM ensures the controlled release of software to users or

customers. It encompasses packaging, labeling, and documenting software
releases to guarantee the delivery of correct and properly tested versions.

10: Mentions some software analysis & design tools.

1. Unified Modeling Language (UML) Tools: UML tools provide a standardized way
to visually represent, specify, and document software systems. They allow
developers to create diagrams like class diagrams, sequence diagrams, and use
case diagrams.

2. Entity-Relationship Diagram (ERD) Tools: ERD tools are used for designing and
modeling database structures. They define relationships between entities in a
database, such as tables and attributes.

3. Data Flow Diagram (DFD) Tools: These tools model the flow of data within a
system, helping developers understand how data is processed and transformed
in a software application.

4. Flowchart Tools: Flowcharts are valuable for illustrating processes and decision-
making in software systems. Flowchart tools make it easier to create diagrams
that represent a system's logic.

5. Architectural Design Tools: These tools assist in designing a software system's

overall structure and architecture. They help define components, interfaces, and
system interactions.