MODULE: SOFTWARE ENGINEERING
TOPIC 7: REUSABILITY AND PORTABILITY
Reusability and Portability in Software Development
Reusability and portability are two crucial concepts in software engineering that can significantly improve the efficiency, costeffectiveness, and longevity of software products. Reuse involves utilizing existing software components to develop new
applications, while portability refers to the ease with which a software system can be adapted to run on different hardware or
software platforms. In this presentation, we will explore the benefits, challenges, and best practices associated with these
concepts, drawing insights from both historical and contemporary developments in the field.
Da
The Evolution of Reuse and Portability
1
Early Programming Efforts
In the early days of computing, software development was characterized by a high degree of
repetition and manual coding. Programmers often had to write entire programs from scratch,
even if they required functionality that had already been implemented elsewhere.
2
Subroutine Libraries
The development of subroutine libraries marked a significant step towards reusability.
Programmers could now access pre-written code snippets, known as subroutines, to perform
common tasks, reducing the need for redundant coding.
3
Advanced Libraries
Over time, software libraries became increasingly sophisticated, offering advanced
functionalities such as statistical and numerical analysis tools, as well as powerful class
libraries that enhanced object-oriented programming practices, further promoting reuse and
portability.
The Benefits of Reuse and Portability
Improved Efficiency
Cost Savings
Enhanced Quality
By leveraging existing software
Reusing and porting software
Reused components have often
components, developers can
components can lead to
been extensively tested and
significantly reduce the time
substantial cost savings, as it
refined, leading to improved
and effort required to create
eliminates the need to recode
software quality and reliability,
new applications, allowing them
from scratch and reduces the
which can translate to better
to focus on more innovative and
overall development and
user experiences and fewer
value-adding features.
maintenance expenses.
bugs.
Impediments to Reuse and Portability
1
Not Invented Here (NIH) Syndrome
2
Concerns over Software Quality
A preference for self-coded routines, often
Developers may be hesitant to use external
stemming from a desire for control or a lack of
components due to concerns about their
trust in externally developed components.
quality, reliability, and the potential
introduction of faults.
3
Costs of Making Components
Reusable
4
Challenges with COTS Components
Preparing software components for reuse can
The lack of access to source code and limited
involve additional effort and costs, which may
customization options for commercial off-the-
be perceived as unnecessary or unwarranted
shelf (COTS) components can make it difficult
by some organizations.
to integrate them into existing systems.
Reuse and Object-Oriented Design
Functional Cohesion
Informational Cohesion
In traditional software design, modules are often
Object-oriented design emphasizes
organized based on functional cohesion,
informational cohesion, where modules are
meaning they group together related functions
organized around the data they manipulate
or operations. While this approach can be
rather than the specific tasks they perform. This
efficient, it may not always promote reuse.
promotes reuse by creating self-contained,
modular components that can be easily
integrated into different systems.
Encapsulation and Abstraction
Inheritance and Polymorphism
Key principles of object-oriented design, such
Object-oriented concepts like inheritance and
as encapsulation and abstraction, further
polymorphism enable the creation of generic,
support reuse by hiding implementation details
reusable components that can be easily
and providing well-defined interfaces. This
adapted to different contexts, enhancing the
allows developers to focus on the functionality
overall portability of the software system.
of a component without needing to understand
its internal workings.
Strategies for Effective Reuse
Planned Reuse
Robust
Documentation
Rigorous Testing
Incentivizing
Reuse
components with future
Comprehensive and
Thorough testing of
Providing
reuse in mind, rather
well-organized
reusable components,
organizational
than ad-hoc reuse, can
documentation,
both in isolation and
incentives and
significantly improve
including clear
within different
recognition for
the success and
instructions for usage
integration contexts,
developers who
scalability of a reuse
and integration, can
helps ensure their
actively contribute to
program.
greatly facilitate the
reliability and
and leverage the reuse
adoption of reusable
compatibility across
of software
components.
diverse systems.
components can foster
Deliberately designing
a culture of reuse
within the organization.
Portability Considerations
Platform Independence
Designing software with a focus on platform independence, such as through the use of standardized APIs and crossplatform frameworks, can greatly enhance its portability across different hardware and software environments.
Abstraction Layers
Implementing well-defined abstraction layers in the software architecture can isolate platform-specific details and make it
easier to adapt the system to new platforms or environments.
Modular Design
A modular, component-based design approach that separates concerns and minimizes interdependencies can facilitate
the porting of individual components to different platforms, rather than requiring the entire system to be rewritten.
Reuse and Portability in Practice
Reuse Scenario
Portability Scenario
Developing a new mobile app by leveraging
Migrating a mission-critical enterprise software
existing UI components and APIs from a previous
system from an on-premises server to a cloud-
web application.
based platform, requiring modifications to the
underlying infrastructure and deployment
processes.
Creating a new data analysis tool by integrating
Adapting a proprietary software product to run on
statistical and visualization libraries from an
multiple operating systems, such as Windows,
existing software suite.
macOS, and Linux, to expand its target market.
Incorporating a commercial off-the-shelf (COTS)
Porting a game engine from one console platform
component, such as a payment processing
to another, ensuring that the game's functionality
module, into a custom-built e-commerce
and performance are maintained across different
application.
hardware specifications.
The Future of Reuse and Portability
Microservices and
Containerization
Cloud-based Ecosystems
Low-code and No-code
Platforms
The rise of microservices
The proliferation of cloud
The emergence of low-code and
architectures and
computing platforms and the
no-code development platforms
containerization technologies,
availability of a wide range of
is making it easier for non-
such as Docker, are expected to
software-as-a-service (SaaS)
technical users to create and
further enhance reusability and
offerings are creating new
customize applications by
portability by enabling the
opportunities for developers to
leveraging pre-built, reusable
deployment of self-contained,
discover, access, and integrate
components, further
modular software components
reusable components into their
democratizing software
across different environments.
applications, improving both
development and promoting
reuse and portability.
reuse.
Conclusion: Embracing Reuse and Portability
Improved Efficiency
By embracing reuse and portability, software development teams can significantly improve their
productivity, reduce development costs, and deliver higher-quality solutions to their users.
Fostering Innovation
With the time and resources saved through reuse and portability, developers can focus on more
innovative and creative aspects of software development, driving industry progress and creating
unique, differentiated products.
Adaptability and Longevity
Software systems that are designed with reuse and portability in mind are better equipped to
adapt to changing requirements, technological advancements, and evolving user needs,
ensuring their long-term viability and relevance in the market.
Software Design Reuse
Software design reuse is a crucial aspect of modern software development, enabling developers and architects to leverage
existing solutions and best practices to build more efficient and maintainable applications. This comprehensive overview
explores the various forms of design reuse, from individual components to complete architectural patterns, and examines
the strengths and weaknesses of these approaches in the context of the dynamic and ever-evolving World Wide Web.
Reusing Design Components
Design Reuse
Application Frameworks
Reusing design components
Design Patterns
Design patterns address
within specific domains is a
Application frameworks go a
common design problems
common practice in software
step further by incorporating
and provide proven solutions
development. Developers can
the design's control logic,
that can be customized for
leverage a repository of
enhancing design reuse and
specific projects. While
reusable design elements,
improving overall software
design patterns offer a
such as classes, modules, or
quality. These frameworks
valuable starting point, they
design patterns, to accelerate
provide a structured
often require careful
the development process and
foundation for building
customization to fit the unique
ensure consistency across
applications, allowing
requirements of a given
different projects.
developers to focus on the
application.
unique aspects of their project
rather than reinventing the
wheel.
Architectural Reuse
Modular Design
1
Modular software architecture
promotes reuse by breaking down
applications into loosely coupled,
2
Layered Design
interchangeable components. This
Layered architectural patterns, such as
allows developers to easily swap out
the Model-View-Controller (MVC) or
or upgrade individual modules without
the Microservices approach, provide a
affecting the entire system.
clear separation of concerns and
enable the reuse of individual layers or
Architectural Patterns
Well-established architectural patterns,
like the Singleton, Facade, or Adapter
patterns, offer reusable solutions for
common design challenges, helping to
streamline the development process
and improve the overall quality of the
software.
services across multiple applications.
3
Strengths and Weaknesses of
Design Patterns
1
Strengths
2
Weaknesses
Design patterns promote reuse,
Applying design patterns
provide clear documentation for the
systematically can be challenging,
design, and facilitate easier
and there may be limitations in how
maintenance of the software. By
they can be used. Additionally,
leveraging well-established
retrofitting design patterns to
solutions, developers can improve
existing systems can sometimes be
the overall quality and efficiency of
a complex and time-consuming
their projects.
process.
Reuse on the World Wide Web
Accessibility of Code and Designs
Quality Control Challenges
While the abundance of online resources is
The World Wide Web has made a vast array
a significant advantage, it also poses
of code, design patterns, and reusable
challenges in terms of quality control and
components readily available to developers.
tracking the reuse of code. Developers must
This accessibility has significantly increased
carefully evaluate the reliability and
the potential for software reuse, allowing
suitability of any external code or design
developers to leverage existing solutions to
they intend to incorporate into their projects.
accelerate the development process.
Maintaining Consistency
Effectively managing the reuse of online code and designs is crucial to maintaining consistency
and cohesion within a software system. Developers must establish clear guidelines and
processes for incorporating external components to ensure the overall integrity and maintainability
of their applications.
Reuse Across the Software Lifecycle
Requirements
Reuse can begin at the requirements stage, where developers can leverage existing use
cases, user stories, or domain models to accelerate the analysis and documentation
process.
Design
As discussed earlier, design reuse is a crucial aspect of software development, enabling
the efficient incorporation of proven design patterns, architectural frameworks, and
modular components.
Implementation
During the implementation phase, developers can further leverage reusable code
libraries, APIs, and open-source solutions to speed up the coding process and ensure
consistency across different parts of the system.
Testing
Reusable test cases, automation frameworks, and mock services can streamline the
testing process, helping to ensure the quality and reliability of the software.
Deployment
Reusable deployment scripts, containerization, and infrastructure-as-code solutions can
simplify and standardize the deployment process, making it easier to replicate and
maintain the software in different environments.
Reuse and Sustainability
Reducing Waste
Recycling
Solutions
Maintainability
reusable design
The ability to reuse
architectural patterns
The modular and
components and
existing solutions,
promote better
adaptable nature of
architectural patterns,
whether in the form of
maintainability, as the
reusable design
developers can
design patterns, code
software is built upon
components enables
significantly reduce
libraries, or
well-established and
software systems to
the amount of
deployment scripts,
documented
evolve and adapt to
redundant code and
allows developers to
solutions. This, in
changing
duplicate efforts,
"recycle" valuable
turn, contributes to
requirements over
leading to more
resources and reduce
the long-term
time, enhancing the
efficient and
the overall
sustainability of the
overall sustainability
sustainable software
environmental impact
software system.
of the application.
development.
of software
By leveraging
development.
Reusable design and
Evolutionary
Potential
Reuse and the Global Software
Ecosystem
Collaboration
The ability to reuse design and code across
distributed teams and organizations fosters
greater collaboration and knowledge-sharing
within the global software development
community.
Interoperability
Reusable architectural patterns and welldefined interfaces promote interoperability
between different software systems, enabling
seamless integration and data exchange.
Innovation
By building upon existing reusable
components, developers can focus more on
innovation and creating unique solutions,
rather than reinventing the wheel.
Scalability
Scalable and modular software architectures,
enabled by reuse, allow applications to grow
and adapt to meet the demands of an everevolving global market.
Reuse and the Future of Software
Development
Intelligent Reuse
Cloud-Based Reuse
Sustainable Reuse
As artificial intelligence and
The rise of cloud computing
As the software industry
machine learning
and cloud-based software
becomes more conscious of
technologies advance,
platforms will likely lead to the
its environmental impact, the
software development may
increased availability and
principles of reuse will play a
see the emergence of
accessibility of reusable
crucial role in promoting
intelligent reuse systems that
design components and code
sustainable software
can automatically identify,
libraries, allowing developers
development practices,
recommend, and integrate
to seamlessly access and
reducing waste, and
appropriate reusable
incorporate them into their
minimizing the carbon
components into new
applications.
footprint of software systems.
projects, further streamlining
the development process.
Conclusion: The Importance of Reuse
1
Increased Efficiency
2
Improved Quality
Software design reuse enables developers
By leveraging proven design patterns and
to work more efficiently, accelerating the
reusable components, developers can
development process and reducing the
enhance the overall quality and reliability of
time-to-market for new applications.
their software, reducing the risk of defects
and improving the user experience.
3
Sustainable Development
4
Adaptability and Growth
The principles of reuse are crucial for
Reusable and modular software
promoting sustainable software
architectures allow applications to evolve
development practices, reducing waste,
and adapt to changing requirements,
and minimizing the environmental impact
ensuring the long-term viability and
of software systems.
success of software solutions.
THANK YOU