Restructuring and Reengineering

Restructuring is the redevelopment of a portion of an application with a bridge to the old

application. Reengineering is the reverse analysis of an old application to conform to a new
methodology, usually Information Engineering or object orientation. Reengineering is also known
as reverse engineering. Rebuilding is the retirement and redevelopment of an application.

Software Restructuring

Software restructuring modifies source code and/or data in an effort to make it amenable to
future changes. In general, restructuring does not modify the overall program architecture. It
tends to focus on the design details of individual modules and on local data structures defined
within modules. If the restructuring effort extends beyond module boundaries and encompasses
the software architecture, restructuring becomes forward engineering .

Restructuring occurs when the basic architecture of an application is solid, even though technical
internals need work. It is initiated when major parts of the software are serviceable and only a
subset of all modules and data need extensive modification.

Kinds of Restructuring are:

1. Code Restructuring
2. Data Restructuring
3. Software Restructuring

1. Code restructuring is performed to yield a design that produces the same function but with
higher quality than the original program. In general, code restructuring techniques model
program logic using algebra and then apply a series of transformation rules that yield
restructured logic. The objective is to take "spaghetti-bowl" code and derive a procedural design
that conforms to the structured programming philosophy.

2. Data Restructuring- Before data restructuring can begin, a reverse engineering activity called
analysis of source code must be conducted. All programming language statements that contain
data definitions, file descriptions, I/O, and interface descriptions are evaluated. The intent is to
extract data items and objects, to get information on data flow, and to understand the existing
data structures that have been implemented. This activity is sometimes called data analysis .

Once data analysis has been completed, data redesign commences. In its simplest form, a data
record standardization step clarifies data definitions to achieve consistency among data item
names or physical record formats within an existing data structure or file format. Another form of
redesign, called data name rationalization, ensures that all data naming conventions conform to
local standards and that aliases are eliminated as data flow through the system.
When restructuring moves beyond standardization and rationalization, physical modifications to
existing data structures are made to make the data design more effective. This may mean a
translation from one file format to another, or in some cases, translation from one type of
database to another.

3. Software restructuring is a form of perfective maintenance that modifies the structure of a

program's source code. Its goal is increased maintainability to better facilitate other maintenance
activities, such as adding new functionality to, or correcting previously undetected errors within a
software system. Changes to the structure are introduced through the application of
transformations. Manually transforming the source code may introduce undesirable as well as
undetectable changes in the system's behaviour. It is very difficult to ensure that manual
restructuring preserves functionality and guaranteeing it is almost impossible. The problems
associated with manual restructuring can be addressed by using a restructuring tool to
automatically apply transformations. The majority of restructuring tools apply transformations by
manipulating abstract program representations and specify the conditions of the transformation
in terms of the representation structure. The context entity graph as program representation was
developed to support specific language constructs, but can be adapted to support a variety of
programming languages. The implementation of a code abstraction transformation in terms of
this structure is examined and various improvements are also suggested.

What is Software Reengineering?

Software reengineering is a transformative process that aims to enhance and update legacy
systems to meet present and future requirements. It is a complex undertaking that involves
analyzing, redesigning, and modifying the software to address limitations, improve performance,
and align it with changing business needs.

The software reengineering process encompasses key steps such as reverse engineering,
restructuring, and forward engineering. These steps empower software engineers to identify and
resolve issues within the legacy system and upgrade it to meet present and future demands.

Software reengineering holds the potential to transform underperforming software into a

valuable asset for businesses. By breathing new life into existing systems, optimizing
performance, and adapting to changing needs, reengineering empowers businesses to stay agile,
efficient, and competitive in today’s technology-driven landscape.

By reengineering the software, companies can streamline the codebase, eliminate technical debt,
and reduce the ongoing maintenance burden, resulting in cost savings and improved system
stability.

The Benefits of Software Reengineering for Businesses

A software reengineering project offers numerous benefits that directly impact businesses’
operational efficiency, competitiveness, and growth.

1. Improved Performance: Reengineering allows businesses to optimize software performance,

enhancing response times, reducing bottlenecks, and increasing overall efficiency. It enables
applications to handle larger workloads and scale effectively.
2. Enhanced Maintainability: Outdated software often becomes challenging to maintain and
support. Through reengineering, businesses can streamline and simplify the software’s structure,
making it easier to understand, update, and maintain over time.
3. Adaptability to Changing Needs: Business requirements evolve, and software must keep pace.
Reengineering enables businesses to align their software with current needs, incorporating new
features, technologies, and integrations to meet evolving market demands.
4. Cost Savings: Replacing an entire software system can be costly. Software reengineering offers
a cost-effective alternative by leveraging existing investments and incrementally improving the
software’s functionality, reducing the need for a complete overhaul.
5. Competitive Advantage: Upgrading and modernizing software through reengineering equips
businesses with a competitive edge. It allows them to offer enhanced user experiences, improved
performance, and innovative features that set them apart from their competitors.

The Journey of Software Reengineering Process

The software reengineering process can indeed be broadly categorized into three main phases:
reverse engineering, restructuring, and forward engineering. These phases work together to
enhance and modernize existing software systems. Let’s explore each phase in more detail.

Phase 1: Reverse Engineering

Reverse engineering entails examining and comprehending the current software architecture. It
aims to gain insights into the system’s architecture, design, and functionality. Here are some key
aspects of reverse engineering:

A. Code Examination: Developers examine the source code, documentation, and other available
resources to understand how the software works. They analyze the code structure, algorithms,
and patterns used in the system.
B. Documentation Review: Existing documentation, such as system specifications, user manuals,
and design documents, is reviewed to gather information about the system’s intended
functionality and design decisions.
C. System Analysis: Developers analyze the system’s behavior, data flow, and interactions with
external components. They may use tools to visualize the system’s structure, identify
dependencies, and trace the execution flow.
The primary goal of reverse engineering is to obtain a comprehensive understanding of the
existing software system. This knowledge helps identify areas for improvement and lays the
foundation for the subsequent phases.
Phase 2: Restructuring
The restructuring phase focuses on redesigning and reorganizing the software system to enhance
its performance, maintainability, and scalability. Here are the key aspects of the restructuring
phase:

A. Code Refactoring: Developers modify the existing codebase to improve its structure,
readability, and maintainability. This may involve removing duplicate code, extracting reusable
components, and applying design patterns to enhance the system’s modularity.
B. Architecture Enhancements: The system’s architecture may be redesigned to address
architectural flaws, improve scalability, or incorporate new technologies. This includes
reevaluating component interactions, introducing layers or modules, and optimizing system
performance.
C. Removal of Obsolete Code: Outdated or unused code is identified and removed, reducing
complexity and improving system performance. This declutters the codebase and makes it easier
to understand and maintain.
The restructuring phase aims to optimize the software system’s structure, making it more
efficient, flexible, and maintainable. It addresses identified weaknesses and prepares the system
for future enhancements.

Phase 3: Forward Engineering

The forward engineering phase involves using the knowledge gained from reverse engineering
and the improvements made during the restructuring phase to develop a new and improved
version of the software. Here are key aspects of forward engineering:

A. Implementation of Redesigned Components: Developers implement the redesigned or

refactored components based on the insights gained from reverse engineering and restructuring.
This may involve rewriting code, introducing new libraries or frameworks, and integrating modern
technologies.

B. Introduction of New Features: The re-engineered software may include new features or
functionality to meet updated business requirements. This involves designing and developing
additional modules or modules with enhanced capabilities.

C. Testing and Quality Assurance: Rigorous testing is conducted to ensure that the reengineered
software meets the defined requirements and functions as intended. This includes various testing
techniques, such as unit testing, integration testing, and system testing, to validate the system’s
stability, reliability, and performance.
The forward engineering phase culminates in a new version of the software that incorporates the
insights gained from reverse engineering and the improvements made during restructuring. The
re-engineered software is now ready for deployment and use.

By following these three phases of reverse engineering, restructuring, and forward engineering,
the software reengineering process allows businesses to breathe new life into their existing
systems. It enables them to optimize performance, enhance maintainability, and align with
modern requirements, ensuring the system remains robust and adaptable in the face of evolving
business needs.