1

CSE327: Software Re-engineering

Lecture #: 5
CDF Unit #: 2
Instructor:
Dr. Manzoor Ahmad
[email protected].
pk

COMSATS University Islamabad,

Vehari Campus
 3
ng Introduction
Restructuring involves transforming a system from one
representational form to another at the same relative level of
abstraction without a change in its functionality or semantics.
The transformation would usually be to a more desirable format.
This activity is based on the premise that after a string of
modifications, the structure of programs tends to degrade.
 "The addition of any function not visualized in the original design will
inevitably degenerate structure. Repairs, also, will tend to cause deviation
from structural regularity since, except under conditions of the strictest
control any repair or patch will be made in the simplest and quickest way.
No search will be made for a fix that maintains structural integrity."
 4
ng Introduction
As the degeneration continues, the programs become more
complex and difficult to understand.
To control this increase in complexity, the source code needs to
be restructured.
Restructuring is a form of preventive maintenance aimed at
improving the physical state of the target system in conformance
with a given standard.
There are various types of restructuring which differ in the part
of the system affected and the manner in which this is done.
 Control-flow-driven restructuring
 Efficiency-driven restructuring & Adaption-driven restructuring
 Control Flow 5
ng Driven
This involves the imposition of a clear control structure within
the source code and can be either intermodular (restructuring in
small) or intramodular (restructuring in large) in nature.
E.g., Intermodular is restructuring a 'spaghetti-like' module's
code so as to comply with structured programming concepts.
E.g., intramodular is regrouping physically distant routines -
located in different modules - so as to give the system a more
coherent structure.
Such as old compilers forced conceptually close routines to be
physically far apart - due to memory considerations – thus
making it difficult to understand the functionality of the code.
 Efficiency 6
ng Driven
This involves restructuring a function or algorithm to make it
more efficient.
A simple example of this form of restructuring is the
replacement of an IFTHEN-ELSIF-ELSE construct with a CASE
construct.
With the CASE statement, only one Boolean is evaluated,
whereas with the IF-THEN-ELSIF-ELSE construct, more than
one of the Boolean expressions may need to be tested during
execution thereby making it less efficient.
Note however, that for this particular example, an optimising
compiler would do this restructuring automatically.
 Efficiency 7
ng Driven
IF ExamScore >= 75 THEN
Grade := 'A‘ CASE ExamScore OF
ELSIF ExamScore >= 60 THEN
75..100 : Grade := 'A‘
Grade := 'B‘
60..74 : Grade := 'B‘
ELSIF ExamScore >= 50 THEN
50..59 : Grade := 'C
Grade := 'C
40..49 : Grade := 'D‘
ELSIF ExamScore >= 40 THEN
ELSE
Grade := 'D‘
ELSE Grade := 'F‘
Grade := 'F' ENDCASE
ENDIF
 Adaptive 8
ng Driven

This involves changing the coding style in order to adapt the

program to a new programming language or new operating
environment, for instance changing an imperative program in
Pascal into a functional program in Lisp.
Another example is the transformation of program functions in a
sequential environment to an equivalent but totally different
form of processing in a parallel environment.
 9
ng
In addition to the source code, other representations of a
software system can be restructured.
These include requirements specifications, data models and
design plans.
Although it is difficult to automate the restructuring process
completely, there exist some automatic restructuring tools.
 10
Restructuring Introduction
Code restructuring is a critical process in software
engineering that includes modifying existing code to enhance its
structure, organization, and efficiency while ensuring the code
retains its intended functionality.
Why we do?
The restructuring process is often performed to address various
issues such as code complexity, maintenance difficulties, poor
readability, performance issues, and scalability limitations.
The process makes small, targeted changes to the codebase,
ensuring that each modification maintains the same functionality.
 Importance in 11
Restructuring SE
Restructuring code improves its readability by applying consistent
formatting, removing redundant or necessary code, and organizing it in a
logical and cohesive manner.
Restructuring makes code more maintainable by breaking it down into
smaller, modular components.
It simplifies code complexity by employing design patterns, refactoring
techniques, and appropriate abstractions.
By analyzing code and making targeted improvements, such as optimizing
algorithms or reducing unnecessary computations, the overall performance
of the software can be significantly enhanced.
By restructuring the code to be updated, new features and functionality can
be added without causing widespread impact or introducing unintended
consequences.
 12
Restructuring Understanding

Code restructuring modifies code’s internal structure without

altering external behavior.
One of the main objectives of restructuring is to simplify the
codebase and make it easier to understand and maintain.
The process involves analyzing the existing codebase,
identifying areas that require improvement, and implementing
changes to address the identified issues.
Code restructuring is critical when dealing with a codebase that
has become difficult to maintain.
 13
Restructuring Understanding

It enables developers to refactor code by restructuring it into

smaller, more manageable components.
Another reason for code restructuring is to address design flaws
in the codebase.
Code restructuring allows developers to reevaluate the system’s
architecture, identify areas of improvement, and apply design
patterns and principles to enhance the overall structure.
This fosters collaboration, reduces conflicts during code
integration, and improves team productivity.
 Common 14
Restructuring Scenarios
Software Growth and Complexity
As software systems evolve and are updated with updated
features, they grow in size and complexity. This can lead to
changes and additions to the codebase that become difficult to
monitor and comprehend. Complexity can hinder the
development process and increase the likelihood of errors
occurring during modifications.
In such scenarios, code restructuring is crucial to break down the
codebase into manageable modules. It is also crucial to improve
code patterns, and refactoring techniques to simplify complex
code, enhance readability, and ensure system maintainability and
scalability.
 Common 15
Restructuring Scenarios

Adopting New Technologies and Frameworks

When software teams adopt updated technologies, programming
languages, or frameworks, the existing codebase may not align
with the updated standards and best practices of the adopted
technology. In such cases, code restructuring is important to
integrate new technologies seamlessly.
Integration might involve adapting existing code to work with
the new ecosystem, modifying dependencies, or re-architecting
certain components. Restructuring ensures the software can take
full advantage of the new technology, implementing its benefits
while maintaining backward compatibility and interoperability.
 Common 16
Restructuring Scenarios

Software Modernization Efforts

In the process of modernizing software, legacy systems are
upgraded to modern architectures. Legacy systems may have
outdated code, use obsolete technologies, and lack modern
features. Code restructuring plays a critical role in modernization
efforts by transforming the legacy code into a modern efficient,
and maintainable form.
The process involves refactoring and rewriting portions of the
codebase to align with the new architecture, ensuring compliance
with current security standards, and taking advantage of modern
framework performance improvements.
 17
Restructuring Techniques

Code restructuring techniques are crucial for improving code

quality, maintainability, and efficiency.
Here are some techniques for code restructuring;
 Refactoring
 Decomposition
 Consolidations
 Optimization
 18
Techniques Refactoring
Refactoring includes modifying a code’s internal structure to improve
its understandability and ease of modification without changing its
observable behavior.
Refactoring techniques emphasize improving code quality,
readability, and maintainability. Some common refactoring
techniques include:
 Extracting methods: Breaking down long and complex methods into
smaller, reusable units to enhance code readability and modularity.
 Variable renaming: Choosing meaningful and descriptive names for
variables, functions, and classes to improve code clarity.
 Simplifying complex expressions: Breaking down complex expressions
into simpler ones to improve readability and maintainability.
 19
Techniques Decomposition

Decomposition involves breaking down complex codebases into

smaller components, such as modules, packages, classes, and
interfaces. The technique enhances code organization,
maintainability, and reusability.
By separating concerns into distinct components, developers can
work on individual parts of the codebase independently, reducing
code dependencies and improving collaboration among team
members.
 20
Techniques Consolidations

Consolidations aim to reduce code duplication and eliminate code smells.

Code duplication often leads to maintenance issues and increases bug
introduction chances.
Techniques for consolidation include extracting common code blocks into
reusable functions or libraries, streamlining conditional statements, and
removing maintainability, and overall software quality.
One way to address tangled code is to use code restructuring techniques to
break down it into more manageable components.
Additionally using modules, packages, classes, and interfaces to separate
concerns can help to make the code more modular and easier to maintain.
 21
Techniques Optimization

Optimization techniques emphasize improving codebase performance and

efficiency. The process involves analyzing and optimizing algorithms,
leveraging appropriate data structures, and implementing caching
mechanisms where applicable.
Language-specific techniques and compiler optimization can also be
implemented to enhance code performance. Optimization techniques aim
to make the codebase more efficient, resulting in faster execution times
and better resource utilization.
 22
Restructuring Best Practices
Code restructuring is a delicate process that requires careful planning and
execution.
To ensure successful code restructuring, it is important to follow best
practices that help maintain code integrity and mitigate issues.
 Understand Goals and Objectives
 Leverage Version Control for Backups and History
 Thoroughly Test and Validate the Restructured Code
 Start with Small, Incremental Changes
 Foster Communication and Collaboration
 Document Rationale and Approach
 Continuously Monitor and Evaluate
 23
Restructuring Best Practices

Understand Goals and Objectives

Before beginning the code restructuring processes, ensure that
you have a clear understanding of the goals and objectives.
Identify the specific problems or areas of improvement that need
to be addressed through restructuring.
Having set clear objectives will guide the restructuring efforts
and ensure the changes align with the desired outcomes.
 24
Restructuring Best Practices

Leverage Version Control for Backups and History

Use a version control system, such as Git, to track and manage
code changes during the restructuring process.
Version control provides the ability to create backups, branch the
codebase, and keep a detailed history of updates and
modifications.
This enables you to revert to previous versions, if needed, and
provides a safety net during the restructuring process.
 25
Restructuring Best Practices

Thoroughly Test and Validate the Restructured Code

After making changes to the codebase, it is critical to thoroughly
test and validate the restructured code.
Run detailed test suites to ensure that the functionality remains
intact and that the changes do not introduce any regressions or
unexpected behavior.
Automated testing and continuous integration practices can help
streamline the process.
 26
Restructuring Best Practices

Start with Small, Incremental Changes

It is beneficial to start with small, incremental changes when
restructuring code.
Rather than maintaining the entire codebase at once, focus on
specific areas or modules that require immediate attention.
The approach reduces the risk of errors and makes it easier to
validate the impact of each change.
 27
Restructuring Best Practices
Foster Communication and Collaboration
Code restructuring is often a collaborative effort involving
multiple team members.
Encourage open communication, share insights, and seek
feedback loops from team members.
Frequent team meetings, code reviews including automated code
reviews, and discussions can facilitate effective collaboration.
Leveraging automated code review tools can streamline the
process, identify potential issues, and ensure adherence to coding
standards, ultimately enhancing the overall quality of the
codebase.
 28
Restructuring Best Practices

Document Rationale and Approach

In code restructuring, it is important to document the rationale
and approach.
Document the reasons for restructuring, the goals, and the
specific techniques or refactoring patterns employed.
The documentation serves as a reference for future developers
and helps them understand the thought process behind the
changes.
 29
Restructuring Best Practices

Continuously Monitor and Evaluate

Code restructuring is an ongoing process, and it is important to
continuously monitor and evaluate the codebase to identify areas
for improvement.
Regular code reviews, performance monitoring, and gathering
feedback from users can help uncover areas that may require
additional restructuring in the future.
 30
Restructuring Benefits

Code restructuring offers several significant benefits that positively impact

software development and maintenance processes.
Let’s dive into some of the benefits below.
 Enhanced Readability and Understandability
 Improved Maintainability
 Increased Reusability
 Enhanced Scalability
 Improved Testing and Debugging
 Performance Optimization
 Adherence to Coding Standards
 31
Restructuring Future in SE

As software systems grow in complexity, manual code

restructuring can become time-consuming and error-prone.
Code restructuring’s future lies in leveraging automation and AI-
powered tools to streamline this process (e.g., Mindbowser).
Advanced restructuring tools will automatically identify areas of
improvement, suggesting code refactoring patterns, and even
effort required for code restructuring, allowing developers to
focus on high-level design and problem-solving.
 32
Restructuring Future in SE

Future code restructuring promises improved code quality and

productivity.
By leveraging automation, AI assistance, and continuous
restructuring practices, developers can optimize their codebase
more efficiently.
As a result, software teams will be able to deliver higher-quality
software products with increased productivity.
 33
Restructuring Mindbowser
Mindbowser (https://www.mindbowser.com) offers code restructuring
assistance powered by artificial intelligence (AI).
We provide a range of automated tools and features to streamline code
refactoring and enhance code quality and maintainability.
We utilize AI algorithms to analyze codebases and identify areas that
require restructuring.
A suite of automated tools helps perform code refactoring tasks seamlessly
and ensures consistency.
We emphasize performance optimization during code restructuring that
provides insights and recommendations to optimize algorithms, improve
data, and structure usage, and eliminate the overall performance and
resource utilization of their software systems.
 34
Restructuring Mindbowser

Fine-tuning the codebase for efficiency, we enhance your software

system’s overall performance and resource utilization.
Our AI-powered code restructuring assistance encompasses
modularization, design patterns, and collaborative support.
By leveraging these features, developers can streamline their code
restructuring process, improve code quality and efficiency, and ensure
maintainability for your software system.