An introduction to systems design process. We have a look at an in-depth overview of topics in architectural design patterns such as SOLID principles, hexagonal architecture etc. Then we proceed to software design patterns and explore topics such as creational patterns, structural patterns etc. We also have a look at hardware design patterns with examples such as Modularity, pipelining, redundancy etc. And finally, we go through project management methodologies, explaining methodologies such as waterfall, agile, lean etc. Further information was provided on sources to learn more about the presentation.

1. SYSTEM DESIGN
PROCESS
Nascomsoft Embedded
Najib Muhammad

2. ELABORATIONS
INTRODUCTION
CONCLUSION
APPROACH
CONTENTS
MISCONCEPTIONS

3. Definition
The system design process is the process of
defining the architecture, components, interfaces,
and data for a system to satisfy specified
requirements. It includes the following steps:
INTRODUCTION
PART 1

4. Contd.
Understand the
needs and
constraints of the
system by gathering
requirements from
stakeholders.
Identify the problem to
be solved, define the
objectives and
constraints of the
system, and analyze the
requirements to
determine the feasibility
of the system.
It is suitable to use after
the design phase, to
build the system
according to the design.
It is suitable to use after
the implementation
phase, to ensure that the
system meets the
requirements and
performs
correctly.Suitable
Requirements gathering Analysis Implementation
Testing
It is suitable to use after
the analysis phase, to
develop a detailed
design of the system,
including the
architecture and
components.Suitable
Design
It is suitable to use after
the testing phase, to
deploy the system to the
production environment.
It is suitable to use after the
deployment phase, to provide
ongoing maintenance and
support for the system.
Deployment Maintenance

5. Concepts of system design
• Architecture patterns
• Design patterns
• Project management methodologies
APPROACH
PART 2

6. Step-by-Step

7. ELABORATIONS
PART 3
We are going to go a little bit into detail of how these
system design approaches work.

8. Architecture Patterns:
Architecture patterns in system design refers to the common
structures and organizational principles that are used to design and
build software systems. These patterns are used to address
common design problems and to provide a common language for
discussing and communicating about software design.
Examples of architecture patterns include:
SOLID Principles: The SOLID principle was introduced by Robert C. Martin, it is an acronym of the five principles
which is given below:
1. Single Responsibility Principle (SRP): This principle states that “a class should have only one reason to change”
which means every class should have a single responsibility or single job or single purpose.
2. Open/Closed Principle: This principle states that “software entities (classes, modules, functions, etc.) should be
open for extension, but closed for modification” which means you should be able to extend a class behavior,
without modifying it.
3. Liskov’s Substitution Principle (LSP): The principle was introduced by Barbara Liskov in 1987 and according to this
principle “Derived or child classes must be substitutable for their base or parent classes“. This principle ensures
that any class that is the child of a parent class should be usable in place of its parent without any unexpected
behavior.

9. Contd.
4. Interface Segregation Principle (ISP): This principle is the first principle that applies to Interfaces instead of
classes in SOLID and it is similar to the single responsibility principle. It states that “do not force any client to
implement an interface which is irrelevant to them“.
5. Dependency Inversion Principle (DIP):
• High-level modules/classes should not depend on low-level modules/classes. Both should depend upon
abstractions.
• Abstractions should not depend upon details. Details should depend upon abstractions.
Separation of Concerns: is a design principle for separating a computer program into distinct sections. Each
section addresses a separate concern, a set of information that affects the code of a computer program. A
concern can be as general as "the details of the hardware for an application", or as specific as "the name of
which class to instantiate".
Hexagonal Architecture: The hexagonal architecture, or ports and adapters architecture, is an architectural
pattern used in software design. It aims at creating loosely coupled application components that can be easily
connected to their software environment by means of ports and adapters. This makes components
exchangeable at any level and facilitates test automation.

10. Contd.
Layering: It is also known as an n-tier architecture and describes an architectural pattern composed of several
separate horizontal layers that function together as a single unit of software.
In these frameworks, components that are related or that are similar are usually placed on the same layers.
However, each layer is different and contributes to a different part of the overall system.
Design Patterns: A design pattern is “a generalized solution to a commonly occurring problem.” To be a
pattern, the problem must recur often enough to be usefully generalizable and the solution must be general
enough to be applied in a wide set of application domains. If it only applies to a single application domain,
then it is probably an analysis pattern

11. Software desing patterns
Software design patterns are reusable solutions to common software design problems. They
provide a way to organize and structure code, making it more modular, maintainable, and
reusable.
• Creational patterns: Creational design patterns provide various object creation
mechanisms, which increase flexibility and reuse of existing code.
• Structural patterns: Structural design patterns define how each component or entity
should be structured so as to have very flexible interconnecting modules which can work
together in a larger system.
• Behavioral patterns: These patterns provide ways to manage communication and behavior
between objects and classes. Examples include the Observer pattern, which allows
objects to be notified of changes in other objects, and the State pattern, which allows an
object to change its behavior based on its internal state.

12. Contd.
• Concurrency patterns: In software engineering, concurrency patterns are those types of
design patterns that deal with the multi-threaded programming paradigm. Examples
include the Thread-Pool pattern, which creates a pool of worker threads, and the Future
pattern, which allows computation to be performed asynchronously. These patterns are
best used when dealing with complex concurrent systems, or when there is a need to
improve performance by parallelizing the execution of tasks.
• Architectural patterns: An architectural pattern is a concept that solves and delineates
some essential cohesive elements of a software architecture. Examples include the
Model-View-Controller (MVC) pattern, which separates the concerns of data
management, presentation, and user interaction, and the Microservices pattern, which
structures a software system as a set of loosely-coupled services. These patterns are best
used when creating large and complex software systems, or when there is a need to
improve scalability and maintainability.

13. Hardware desing patterns
• Modularity: This pattern involves breaking down a design into smaller, interchangeable
components that can be combined in different ways. This allows for easy replacement or
upgrade of individual components without affecting the overall design. Modularity is best
used in designs where components may need to be replaced or upgraded frequently or
where the design needs to be scalable.
• Hierarchy: This pattern involves organizing a design into a series of levels, with each level
representing a different level of abstraction. This allows for a clear separation of concerns
and makes it easier to understand and manage the design. Hierarchy is best used in designs
where there is a need to manage complexity and where a clear separation of concerns is
required.
• Pipelining: This pattern involves breaking down a design into a series of stages, with each
stage performing a specific function. Data is passed through these stages in a pipeline,
allowing for parallel processing and improved performance. Pipelining is best used in designs
where there is a need to improve performance and where data needs to be processed in a
specific order.
• Redundancy
• Interfacing
• Microcontroller-based design

14. • Redundancy: This pattern involves using multiple copies of a component to improve the
reliability of a design. If one component fails, the other component(s) can take over.
Redundancy is best used in designs where high availability and reliability is required and
where the cost of failure is high.
• Interfacing: This pattern involves creating a standardized interface between different
components of a design, allowing them to communicate and interact with each other. This
allows for easy integration of new components and improves the maintainability of the
design. Interfacing is best used in designs where there is a need to integrate different
components and where a clear separation of concerns is required.
• Microcontroller-based design: This pattern involves using a microcontroller as the core of the
design. Microcontroller is a small computer on a single integrated circuit that can control the
various peripherals and other components of the design. This pattern is best used when the
design needs a simple control over the peripherals and when the cost and size of the design
is a concern.
Contd.

15. Project management
methodologies
Project management methodologies are frameworks and processes that are used to
plan, organize, and control the various aspects of a project.
• Waterfall: This is a traditional, linear approach to project management where each
phase of the project is completed before moving on to the next. This methodology
is best used for projects with well-defined objectives, clear deliverables, and where
the scope of the project is not likely to change.
• Agile: Agile project management is an iterative and flexible approach that
prioritizes customer collaboration and rapid iteration. This methodology is best
used for projects with rapidly changing requirements, where the ability to adapt
and make adjustments quickly is important. Agile development methodologies such
as Scrum and Kanban are commonly used in software development, IT services and
product development.
• Lean: Lean project management is an approach that is based on the principles of
Lean manufacturing and is focused on reducing waste, increasing efficiency, and
delivering value to the customer. This methodology is best used for projects where
efficiency and cost-effectiveness are a priority.
• Six sigma:
• Prince2 (PRojects IN Controlled Environments):

16. Contd.
• Six sigma: Six Sigma is a data-driven approach to project management that is
focused on reducing defects and improving quality. This methodology is best used
for projects where quality and accuracy are of the utmost importance.
• Prince2 (PRojects IN Controlled Environments): Prince2 (PRojects IN Controlled
Environments) is a project management methodology that is widely used in the UK
government and private sector. This methodology is best used for projects that are
large and complex, and where a clear and structured approach to project
management is needed.
Ultimately, the best project management methodology to use will depend on the
specific goals and constraints of the project, as well as the preferences and
experiences of the project team. Some organizations may also use a hybrid approach,
combining elements of different methodologies to suit their needs.

17. It is important to note that there may be overlap between
the steps and that the system design process should be
flexible and adaptable to changes in requirements and
constraints.
CONCLUSION
PART 4

18. Pyramid Diagram
Product
Design patterns
Project management
Architecture

19. Where to go from here?
Before one begins their journey in studying system design patterns, they have to
ensure that they gain good mastery of atleast one programming language, understand
data structures and algorithms and then decide on a project they’ll build along while
learning.
Recommend Study Materials:
• Mastering Python Design Patterns A guide to creating smart, efficient, and reusable
software by Kamon Ayeva, Sakis Kasampalis
• Architecture Patterns with Python Enabling Test-Driven Development, Domain-
Driven Design, and Event-Driven Microservices by Bob Gregory Harry Percival
• Design Patterns Elements of Reusable Object-Oriented Software by Erich Gamma,
Richard Helm, Ralph Johnson, John M. Vlissides
• Design Patterns for Embedded Systems in C An Embedded Software Engineering
Toolkit by Bruce Powel Douglass
• Buy courses online (make sure you check the ratings and read the comments)
• YouTube

20. THANK
YOU

21. Reference
https://www.geeksforgeeks.org/solid-principle-in-programming-understand-with-real-life-examples/
https://en.wikipedia.org/Councurrency_pattern
https://en.wikipedia.org/wiki/Architectural_pattern
https://en.wikipedia.org/wiki/List_of_software_architecture_styles_and_patterns
https://refactoring.guru/design-patterns/creational-patterns
https://www.gofpatterns.com/design-patterns/module5/structural-design-pattern.php
https://www.baeldung.com/cs/layered-architecture
https://en.wikipedia.org/wiki/Separation_of_concerns
https://en.wikipedia.org/wiki/Hexagonal_architecture_(software)
https://learn.microsoft.com/en-us/dotnet/architecture/modern-web-apps-azure/architectural-principles
https://chat.openai.com
Design Patterns for Embedded Systems in C: An Embedded Software Engineering Toolkit by Bruce Powel Douglas