SOFTWARE

DESIGN
•Design Principles and Concepts

• Architectural Design

•Object-Oriented Design

•Design Patterns and Best Practices

BY
(Ezeala Ferdinand (MD/CEO)
Femish IT Systems And Solutions
WHAT IS SOFTWARE DESIGN

•Software Design creates a representation or model of the software,

i.e. the design model provides detail about software architecture,
data structures, interfaces, and components that are necessary to
implement the system.
•Software design is a process by which software developers create a
blueprint for a software solution. It involves defining the software
architecture, components, modules, interfaces, and data for a
system to satisfy specified requirements.
OBJECTIVE OF SOFTWARE DESIGN

• Correctness: A good design should be correct i.e., it should

correctly implement all the functionalities of the system.
• Efficiency: A good software design should address the resources,
time, and cost optimization issues.
• Flexibility: A good software design should have the ability to adapt
and accommodate changes easily. It includes designing the
software in a way, that allows for modifications, enhancements,
and scalability without requiring significant rework or causing
major disruptions to the existing functionality.
• Understandability: A good design should be easily understandable,
it should be modular, and all the modules are arranged in layers.
• Completeness: The design should have all the components like
data structures, modules, external interfaces, etc.
DESIGN PRINCIPLES
 DESIGN PRINCIPLES
• Should not suffer from “Tunnel Vision” –
While designing the process, it should not suffer from “tunnel
vision” which means that is should not only focus on completing or
achieving the aim but on other effects also.
• Traceable to analysis model
The design process should be traceable to the analysis model
which means it should satisfy all the requirements that software
requires to develop a high-quality product.
• Should not “Reinvent The Wheel” –
The design process should not reinvent the wheel that means it
should not waste time or effort in creating things that already
exist. Due to this, the overall development will get increased.
• Minimize Intellectual distance –
The design process should reduce the gap between real-world
problems and software solutions for that problem meaning it
should simply minimize intellectual distance.
• Exhibit uniformity and integration –
The design should display uniformity which means it should be
uniform throughout the process without any change. Integration
means it should mix or combine all parts of software i.e.
subsystems into one system.
 DESIGN PRINCIPLES
• Accommodate change –
The software should be designed in such a way that it
accommodates the change implying that the software should
adjust to the change that is required to be done as per the user’s
need.
• Degrade gently –
The software should be designed in such a way that it degrades
gracefully which means it should work properly even if an error
occurs during the execution.
• Assessed or quality –
The design should be assessed or evaluated for the quality
meaning that during the evaluation, the quality of the design
needs to be checked and focused on.
• Review to discover errors –
The design should be reviewed which means that the overall
evaluation should be done to check if there is any error present or
if it can be minimized.
• Design is not coding and coding is not design –
Design means describing the logic of the program to solve any
problem and coding is a type of language that is used for the
 DESIGN CONCEPT
• Concepts are defined as a principal idea or invention that comes
into our mind or in thought to understand something. The software
design concept simply means the idea or principle behind the
design. It describes how you plan to solve the problem of
designing software, and the logic, or thinking behind how you will
design software. It allows the software engineer to create the
model of the system software or product that is to be developed or
built. The software design concept provides a supporting and
essential structure or model for developing the right software.
There are many concepts of software design and some of them are
given below:
 DESIGN CONCEPT
• Abstraction (Hide Irrelevant Data)
• Hides details to reduce complexity and increase efficiency/quality.
• Different levels of abstraction are necessary throughout the design
process.
• High-level abstraction provides a broad overview, while low-level
abstraction offers detailed descriptions.
• Modularity (Subdivide the System)
• Divides the system or project into smaller, manageable parts.
• Facilitates independent development and reuse of components.
• Reduces complexity and cost compared to monolithic software
systems.
• Architecture (Design a Structure)
• Focuses on designing the structure of the software.
• Defines how various elements and data interact within the system.
• Refinement (Remove Impurities)
• Elaborates and develops the software in detail to enhance quality.
• Identifies and removes errors to improve the software solution.
 DESIGN CONCEPT
• Pattern (A Repeated Form)
• Uses recurring solutions to common problems in specific contexts.
• Applies established design patterns to enhance consistency and
efficiency.
• Information Hiding (Hide the Information)
• Conceals information within modules to prevent unauthorized access.
• Ensures that each module’s data is not accessible by other modules.
• Refactoring (Reconstruct Something)
• Reconstructs the design to reduce complexity without altering
behavior.
• Improves the internal structure and maintains functionality.
• Defined by Fowler as improving the internal structure without affecting
behavior.
 ARCHITECTURAL DESIGN
• Architectural design is a crucial phase in software design where
the structure and organization of a software system are defined. It
involves creating a blueprint that outlines the system's
components, their relationships, and how they interact to fulfill the
requirements.

• Definition
• Architectural design refers to the process of defining a
structured solution that meets all the technical and
operational requirements while optimizing common quality
attributes such as performance, security, and manageability .
 ARCHITECTURAL DESIGN
• Importance of Architectural Design
• Foundation: Provides a solid foundation for the entire
system, guiding development and evolution.
• Scalability: Ensures the system can handle growth in users,
data, and transactions.
• Maintainability: Makes the system easier to understand,
modify, and extend.
• Performance: Optimizes system performance by addressing
factors like load distribution and resource management.
• Security: Establishes security measures to protect data and
operations.
• Cost Efficiency: Helps in planning and managing
development costs effectively.
 KEY CONCEPTS IN ARCHITECTURAL DESIGN
• Architectural Styles
• Different architectural styles offer various ways to organize and
structure software systems:
• Monolithic Architecture: A single-tiered software application where
all components are interwoven.
• Pros: Simple to develop and deploy.
• Cons: Difficult to scale and maintain as the system grows.
• Microservices Architecture: A collection of loosely coupled services
that can be developed, deployed, and scaled independently.
• Pros: Highly scalable, flexible, and resilient.
• Cons: More complex to manage and deploy.
• Layered (N-Tier) Architecture: Divides the system into layers (e.g.,
presentation, business logic, data access).
• Pros: Improves separation of concerns and maintainability.
• Cons: Can introduce latency and overhead.
• Event-Driven Architecture: Systems that react to events, often
used in real-time applications.
• Pros: Highly responsive and scalable.
• Cons: Can be complex to implement and manage.
 KEY CONCEPTS IN ARCHITECTURAL
DESIGN
• Architectural Patterns
• Commonly used patterns to solve recurring architectural
problems:
• Model-View-Controller (MVC): Separates the application into three
interconnected components.
• Model: Manages data and business logic.
• View: Presents data to the user.
• Controller: Handles user input and updates the model.

• Client-Server: Divides the system into client and server, where

clients request services from the server.
• Service-Oriented Architecture (SOA): Uses services as the
fundamental unit of application logic.
• Key Architectural Considerations
• Scalability: Ensuring the system can grow to accommodate more
users, data, and transactions.
• Performance: Optimizing response times, throughput, and resource
utilization.
• Security: Protecting data and ensuring secure communication.
• Maintainability: Designing the system to be easy to understand,
modify, and extend.
• Reliability: Ensuring the system is fault-tolerant and highly available.
 OBJECT-ORIENTED DESIGN
• In the object-oriented design method, the system is viewed as a
collection of objects (i.e., entities). The state is distributed among
the objects, and each object handles its state data. For example,
in a Library Automation Software, each library representative may
be a separate object with its data and functions to operate on
these data. The tasks defined for one purpose cannot refer or
change data of other objects. Objects have their internal data
which represent their state. Similar objects create a class. In other
words, each object is a member of some class. Classes may inherit
features from the superclass.
 OBJECT-ORIENTED DESIGN
• The different terms related to object design are:
• Objects: All entities involved in the solution design are known as objects. For
example, person, banks, company, and users are considered as objects. Every
entity has some attributes associated with it and has some methods to perform
on the attributes.
• Classes: A class is a generalized description of an object. An object is an
instance of a class. A class defines all the attributes, which an object can have
and methods, which represents the functionality of the object.
• Messages: Objects communicate by message passing. Messages consist of
the integrity of the target object, the name of the requested operation, and any
other action needed to perform the function. Messages are often implemented
as procedure or function calls.
• Abstraction In object-oriented design, complexity is handled using
abstraction. Abstraction is the removal of the irrelevant and the amplification of
the essentials.
• Encapsulation: Encapsulation is also called an information hiding concept.
The data and operations are linked to a single unit. Encapsulation not only
bundles essential information of an object together but also restricts access to
the data and methods from the outside world.
• Inheritance: OOD allows similar classes to stack up in a hierarchical manner
where the lower or sub-classes can import, implement, and re-use allowed
variables and functions from their immediate superclasses.This property of OOD
is called an inheritance. This makes it easier to define a specific class and to
create generalized classes from specific ones.
• Polymorphism: OOD languages provide a mechanism where methods
performing similar tasks but vary in arguments, can be assigned the same
name. This is known as polymorphism, which allows a single interface is
performing functions for different types. Depending upon how the service is
invoked, the respective portion of the code gets executed.
 DESIGN PATTERNS
• Definition
• Design patterns are reusable solutions to common problems in
software design. They represent best practices used by
experienced object-oriented software developers.
• Importance
• Reusability: Promotes code reuse and avoids redundancy.
• Consistency: Ensures a consistent approach to solving similar
problems.
• Efficiency: Saves time by providing proven solutions.
• Communication: Provides a common language for developers
to discuss design solutions.
• Common Design Patterns
• Creational Patterns
• Singleton: Ensures a class has only one instance and provides a
global point of access to it.
• Example: Managing a single database connection instance.
• Factory Method: Defines an interface for creating an object but
lets subclasses alter the type of objects that will be created.
• Example: Creating objects in a GUI framework without specifying
their exact class.
• Abstract Factory: Provides an interface for creating families of
related or dependent objects without specifying their concrete
classes.
 DESIGN PATTERNS

• Structural Patterns
• Adapter: Allows incompatible interfaces to work
together.
• Composite: Composes objects into tree structures to
represent part-whole hierarchies.
• Decorator: Adds new functionality to an object
dynamically.
• Behavioral Patterns
• Observer: Defines a one-to-many dependency between
objects so that when one object changes state, all its
dependents are notified.
• Strategy: Defines a family of algorithms, encapsulates
each one, and makes them interchangeable.
• Command: Encapsulates a request as an object,
thereby allowing for parameterization of clients with
queues, requests, and operations.
 BEST PRACTICES

• Definition
• Best practices are a set of guidelines, ethics, and ideas that
represent the most efficient or prudent course of action in a
given business or software development situation.
• Importance
• Quality: Ensures high-quality software development.
• Efficiency: Improves development speed and reduces errors.
• Maintainability: Makes the code easier to maintain and
extend.
• Collaboration: Facilitates better collaboration among
developers.
• Common Best Practices
• Code Reviews
• Description: Regularly review code to identify bugs, improve
code quality, and share knowledge.
• Benefits: Enhances code quality and fosters knowledge sharing.
 BEST PRACTICES
• Refactoring
• Description: Reconstruct the code to improve its structure without
changing its behavior.
• Benefits: Simplifies the code, making it easier to read and maintain.
• Automated Testing
• Description: Write tests to automatically verify the correctness of the
code.
• Benefits: Ensures code reliability and helps catch bugs early.
• Continuous Integration/Continuous Deployment (CI/CD)
• Description: Integrate code changes frequently and automate the
deployment process.
• Benefits: Reduces integration issues and allows for faster delivery of
features.
• Documentation
• Description: Write clear and concise documentation for code, APIs,
and system design.
• Benefits: Helps new developers understand the system and facilitates
easier maintenance.
• Design for Change
• Description: Anticipate future changes and design the system to
accommodate them.
• Benefits: Makes the system more adaptable to evolving
requirements.
 CONCLUSION

• Understand the fundamental principles like abstraction,

modularity, and refinement to create efficient and maintainable
software.
• Learn the importance of structuring software systems with
architectural styles and patterns to ensure scalability,
performance, and security.
• Emphasize designing with objects, encapsulation, inheritance, and
polymorphism to promote reusability and flexibility.
• Utilize proven design patterns to solve common problems and
follow best practices for high-quality, reliable software
development.
QUESTION AND
ANSWER
THANK YOU
 CONTACT US

FEMISH IT SYSTEMS AND

SOLUTIONS:

 1 MAJEKODUNMI STREET OFF ALLEN AVENUE, IKEJA,

LAGOS

08128114584, 08128114540
[email protected]
www.femish.com.ng