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.
