ISD Lecture1 Presentation

Introduction to Design Principles
CSE325: Information System Design
Introduction to Design Principles 1 / 94

Contributors
Contributors
Saira Yeasmin - 1805037

Md. Mehedi Imam - 1805039
Md. Asif Shahriar - 1805040
Sanjana Binte Siraj - 1805041
Debojit Pandit - 1805042
Aroma Hoque - 1805058
Subsection: A2, Group: 04

Importance of OOP
Importance of Object Oriented

Programming

Importance of OOP
What is OOP?
In OOP, a software is organized as collection of discrete objects that

incorporate both data structure and behavior.

Importance of OOP
What is OOP?

Basic terminology and ideas of OOP are:

Importance of OOP
What is OOP?


Objects Classes

Importance of OOP
What is OOP?


Objects Classes
Abstraction and encapsulation

Importance of OOP
What is OOP?


Objects Classes
Inheritance

Importance of OOP
What is OOP?


Objects Classes
Inheritance
Polymorphism

Importance of OOP
Benefits of OOP
Here is a list of few benefits of OOP

Importance of OOP
Benefits of OOP

Abstraction

Importance of OOP
Benefits of OOP

Abstraction
Manageability

Importance of OOP
Benefits of OOP

Abstraction
Manageability
Reusability

Importance of OOP
Benefits of OOP

Abstraction
Manageability
Reusability
Readability

Importance of OOP
Benefits of OOP

Abstraction
Manageability
Reusability
Readability
Productivity

Importance of OOP
Benefits of OOP

Abstraction
Manageability
Reusability
Readability
Productivity
Maintainability

Importance of OOP
Abstraction
Objects in an OOP language provide an abstraction that hides the

internal implementation details.

Importance of OOP
Abstraction

It helps to just ignore the internal complexities and work with black
boxes that work great.

Importance of OOP
Abstraction

It helps to just ignore the internal complexities and work with black
boxes that work great.
By using encapsulation and defining classes with well-defined
interfaces, OOP provides a high degree of abstraction.

Importance of OOP
Example of Abstraction

Importance of OOP
A car is an object that has many features such as wheels, engine,

transmission, etc.

Importance of OOP

transmission, etc.
While using a car, we don’t need to know all the details of how it
works. We only need to know how to drive it such as how to start the
engine, how to accelerate, brake, and steer.

Importance of OOP

transmission, etc.
While using a car, we don’t need to know all the details of how it
works. We only need to know how to drive it such as how to start the
engine, how to accelerate, brake, and steer.
The details of how these methods work will be hidden from the user,
allowing them to focus only on the essential features of the car.

Importance of OOP
Manageability
OOP supports modularity which allows to break large,complex

program into smaller ,more manageable components.

Importance of OOP
Manageability

Each object in an OOP program is responsible for a specific task and
the objects interact with each other to accomplish larger tasks.

Importance of OOP
Manageability

Each object in an OOP program is responsible for a specific task and
the objects interact with each other to accomplish larger tasks.
Then we merge and integrate different components and manage the
whole process of combination of different modules,logics and codes in
an efficient way.

Importance of OOP
Example of Manageability
In building a software application for a car rental company,we create

an object for each component of the car rental process, such as
customer information, rental rates, rental contracts, vehicle inventory,
and billing.

Importance of OOP

and billing.
Each object would be responsible for its own specific task, and the
objects would interact with each other to complete the rental process.

Importance of OOP

and billing.
Each object would be responsible for its own specific task, and the
objects would interact with each other to complete the rental process.
This approach makes the code more manageable because each
object can be developed and tested independently.

Importance of OOP
Reusability
Reusabilty means using the same code again and again without
writing it twice.

Importance of OOP
Reusability
writing it twice.
It is a concept of OOP that is achieved via Inheritance.

Importance of OOP
Reusability
writing it twice.
It is a concept of OOP that is achieved via Inheritance.
Reuse enables faster development,less cost and high quality of
the software.

Importance of OOP
Example of Reusability

Importance of OOP
Example of Reusability
In the above code,by using OOP and inheritance, we have created a

hierarchy of classes that allows us to reuse the area() method of the
Rectangle class to calculate the area of both rectangles and squares.

Importance of OOP
Readability
OOP increases readability of the code by providing a clear and

organized structure for code.

Importance of OOP
Readability
OOP increases readability of the code by providing a clear and

organized structure for code.
By encapsulation, the internal workings of a class are hidden from
the rest of the program. This can make code more readable by
allowing developers to treat objects as black boxes and focus on the
public interface of the class, without having to understand every
detail of how it works internally.

Importance of OOP
Productivity
OOP promotes a structured, modular approach to programming

that can increase productivity by reducing code duplication,
facilitating maintenance and debugging, and improving the
organization of code.

Importance of OOP
Productivity
OOP promotes a structured, modular approach to programming

that can increase productivity by reducing code duplication,
facilitating maintenance and debugging, and improving the
organization of code.
Developers can produce high-quality code in a timely and efficient
manner.

Importance of OOP
Maintainability
It is easy to make minor changes,finds and fix errors in the code

without affecting any other part of a program.

Importance of OOP
Maintainability

Since the design is modular, part of the system can be updated in
case of issues without a need to make large-scale changes.

Importance of OOP
Maintainability

Since the design is modular, part of the system can be updated in
case of issues without a need to make large-scale changes.
OOP provides a well-defined interface for unit testing which helps
during software maintenance.

Importance of OOP
Example of Maintainability

Importance of OOP
Example of Maintainability
In this example,By encapsulating the properties and methods of an

employee within a single class, we can easily modify or extend the
functionality of an employee without affecting other parts of the program.
For example, if we wanted to add a new property to the Employee class,
such as department,we could do it without affecting others like the right
side code of the picture.

OOP Features
Features of Object Oriented

Programming

OOP Features
Why OOP?
There are three major features in object-oriented programming that makes

them different than non-OOP languages

OOP Features
Why OOP?

Encapsulation

OOP Features
Why OOP?

Encapsulation
Inheritance

OOP Features
Why OOP?

Encapsulation
Inheritance
Polymorphism

OOP Features
Encapsulation
Encapsulation refers to the bundling of fields and methods inside a

single class.

OOP Features
Encapsulation

single class.
Prevents outer classes from accessing and changing fields and
methods of a class

OOP Features
Encapsulation

single class.
Prevents outer classes from accessing and changing fields and
methods of a class
helps to achieve data hiding.

OOP Features
Encapsulation Example In Java

OOP Features
In the above example, we have a private field age. Since it is private, it

cannot be accessed from outside the class.

OOP Features
In the above example, we have a private field age. Since it is private, it

cannot be accessed from outside the class.
Making age private allowed us to restrict unauthorized access from outside

the class. This is data hiding.

OOP Features
Inheritance
Inheritance provides the way of achieving code re-usability

OOP Features
Inheritance

We don’t need to write the same code multiple times, again and
again,

OOP Features
Inheritance

We don’t need to write the same code multiple times, again and
again,
Rather we can use inherit a version of the given properties of one
class into the other just by extending it.

OOP Features
Inheritance Example In Java

OOP Features
Inheritance Example In Java
In this example, we have a base class Teacher and a subclass

BiologyTeacher. Since class BiologyTeacher extends the properties from
the base class, we need not declare these properties and method in the
subclass.

OOP Features
Polymorphism
Polymorphism allows a specific routine to use variables of different

types at different times

OOP Features
Polymorphism

Presents the same interface for several different underlying data types

OOP Features
Polymorphism

Presents the same interface for several different underlying data types
Makes different objects to respond in a unique way to the same
message

OOP Features
Polymorphism Example In Java

OOP Features
Polymorphism Example In Java
In this example a superclass called Animal that has a method called

animalSound(). Subclasses of Animals are Cow and Hen. They also have
their own implementation of an animal sound (the cow moooes, and the
hen chirps etc.)

SE Design Guidelines
Software Engineering Design Guidelines

Why Guidelines?
OOP features like encapsulation, inheritance and polymorphism alone

cannot ensure readable, reusable, easily maintainable code.

Why Guidelines?

How many classes?

Why Guidelines?

How many classes?

How many fields and methods in each class?

Why Guidelines?

How many classes?

if ... else if ... else if ... ... How many branches? Can you keep
track of them all?

Why Guidelines?

How many classes?

if ... else if ... else if ... ... How many branches? Can you keep
track of them all?
Guidelines help us write good, clean code.

Inheritance vs Composition

Inheritance: is a relationship

Composition: has a relationship

Which one to use?

Which one to use?
Design Guideline: Favour Composition over Inheritance

Inheritance

Composition

Let’s create two classes, Summer and Exp.
How to find whole-cube using these two classes?

Composition over Inheritance
To find whole-cube, we need both getSum() and getExp()


But multiple inheritance is not allowed!


Solution: Composition


Solution: Composition
Create another class, keep references to both Summer and Exp
classes


Why Composition over Inheritance

Classes and objects created through inheritance are tightly coupled

and changing the parent or superclass in an inheritance relationship
risks breaking the code. Whereas, classes and objects created through
composition are loosely coupled, meaning that we can more easily
change the component parts without breaking the code. Hence,
composition offers much more flexibility than inheritance


We can only inherit from one class (in Java and C#), whereas
composition allows us to use functionality from multiple classes


Inheritance cannot extend final class, whereas composition allows
code reuse even from final classes


Inheritance cannot extend final class, whereas composition allows
code reuse even from final classes
In inheritance we need parent class in order to test a child class but
composition allows us to test the implementation of the classes we
are using independent of parent or child classes

Interface vs Abstract Class

Interface

Interface
Can have abstract, default and static methods

Interface
Cannot have non-abstract non-static methods

Interface
Can have only static and final variables

Interface
Can have only static and final variables
Cannot be instantiated

Abstract Class

Abstract Class
Can have both abstract and non-abstract methods

Abstract Class
Can have final, non-final, static and non-static variables

Abstract Class
Can have final, non-final, static and non-static variables
Cannot be instantiated

When to use Which

When to use Which
If both abstract and non-abstract methods needed, use Abstract

class

When to use Which

class
Else, always use interfaces

When to use Which

class
Else, always use interfaces
Reminder: You cannot inherit multiple classes, but you can
implement multiple interfaces!

Example

Example
Consider an application which has a database accessor layer

Example

A ServiceClass which calls a DBClient class

Example

DBClient class is a concrete class, programmed to access Postgres
DB

Example

DB
What if we want to switch to a NoSQL database like MongoDB
instead?

Example

DB
What if we want to switch to a NoSQL database like MongoDB
instead?
Solution: Write an interface/abstract class AbstractDBClient, then
have concrete classes like PostgresDBClient and MySQLDBClient
implement the interface

Solution

Importance of Design Principles

In software development, the main challenge isn’t just generating

output. Rather the main challenge is to make one’s code readable for
others.


others.
Good design reduces the amount of code that needs to be written,
tested, and maintained, and also makes it easier to make changes to
the codebase without introducing bugs or inconsistencies.


others.
Good design reduces the amount of code that needs to be written,
tested, and maintained, and also makes it easier to make changes to
the codebase without introducing bugs or inconsistencies.
Always remember, it is easy to write a code computer can
understand, but it is difficult to write code humans can
understand.

Indicators for good code

Readability: Good code should be easy to read and understand.


Modularity: Good code should be modular, with each function or
class responsible for a specific task.


Scalability: Good code should be scalable, able to handle increasing
amounts of data or traffic without becoming slower or less reliable.


Scalability: Good code should be scalable, able to handle increasing
amounts of data or traffic without becoming slower or less reliable.
Testability: Good code should be testable, with a clear separation
between the code being tested and any external dependencies.

Some design principles that help coders achieve these are described in the
following slides.

DRY
DRY

DRY
DRY
DRY stands for Don’t Repeat Yourself.

DRY
DRY
DRY stands for Don’t Repeat Yourself.

It is a design principle stating that every piece of knowledge or
functionality in a software system should have a single representation
in the codebase, and that repetition should be eliminated whenever
possible.

DRY
Rule of 3

DRY
Rule of 3
Rule of 3 is a technique for upholding the DRY principle in one’s code.

DRY
Rule of 3
The rule of 3 goes as:

Whenever a developer copy-pastes any segment of code, he should
first opt for creating abstractions and reusable code

DRY
Rule of 3

If the code is still copy-pasted, he should pin the idea in his head that
he has done something wrong

DRY
Rule of 3

If the code is still copy-pasted, he should pin the idea in his head that
he has done something wrong
When he goes to copy that code for a third time, he should at once
change his code structure to avoid that copy-paste at all costs.

DRY
Cases where DRY principle is used

DRY
Copy-pasting: If the same code block is used in multiple places in a

software system. This code should be moved to a single function or
method.

DRY

method.
Hardcoded values: Hardcoding values such as file paths, URLs, or
database connection strings etc. These values should be stored in a
single location, such as a configuration file or database.

DRY

method.
Hardcoded values: Hardcoding values such as file paths, URLs, or
database connection strings etc. These values should be stored in a
single location, such as a configuration file or database.
Repetitive logic: If the same logic is repeated in multiple functions
or methods i.e, evil switch, if-else blocks etc.

DRY
Evil switch

DRY
Evil Switch
The Evil Switch is a case, where DRY design principle comes in handy.

DRY
Evil Switch
Let us consider the following piece of code:

DRY
Evil Switch
Now what if there was another function getBonus like:

DRY
Evil Switch
In both cases, we can see that the switch condition statements are same.

DRY
Evil Switch
Now what if there were 20 functions with the same switch conditions?
And what if there were a 100 switch conditions?

DRY
Evil Switch
Copy-pasting does seem like an easy solution at first glance, but how
can you guarantee that you have correctly copy-pasted all the switch
cases?

DRY
Evil Switch
Copy-pasting does seem like an easy solution at first glance, but how
can you guarantee that you have correctly copy-pasted all the switch
cases?
And imagine, you need to add a new switch case, how can you
guarantee you will not miss any of the 20 places you need to add the
new case in?

DRY
Evil Switch
This kind of switch functions which appear in multiple places in the

codebase are known as evil switch.

DRY
Evil Switch
This kind of switch functions which appear in multiple places in the

codebase are known as evil switch.
Evil switches break the DRY principle.

DRY
Resolving Evil Switch

DRY
Resolving Evil Switch
Evil switches can easily be resolved to uphold DRY design principle using
strategy design pattern.

KISS
KISS

KISS
KISS
KISS stands for Keep It Simple, Stupid

KISS
KISS
KISS stands for Keep It Simple, Stupid

Sometimes it is also called Keep It Stupid Simple to make the code
understandable to even stupids

KISS
KISS
Sometimes our compact and efficient code can be rejected by code

reviewers. Why?

KISS
KISS

reviewers. Why?
Using a single ternary operator is OK but using nested ternary is a
red flag.

KISS
KISS

reviewers. Why?
Using a single ternary operator is OK but using nested ternary is a
red flag.
Using pointers along with unary operators also makes the code
difficult to understand

KISS
Example
Let’s look at an example. Suppose we need a data structure to contain a

number of elements and find one of them when needed.

KISS
Example

We can use a 2D array of m*n elements. Here the time complexity to
find an element will be O(m*n).

KISS
Example

Or we can go with a Hashmap or Dictionary data structure which will
have m hashtables and each hashtable will contain n elements. Time
complexity here is O(m+n).

KISS
Example

So, which one should we use? Definitely the hashmap one because of it’s
lower time complexity. Right?

KISS
Example

So, which one should we use? Definitely the hashmap one because of it’s
lower time complexity. Right?
Here comes the KISS awakening. Arrays are easier to understand than
Hashmaps.

KISS
Example
Let’s see the KISS approach

KISS
Example

We have to understand the context here. If our data asks for a 10000
* 100 data structure, we have no other option than Hashmap

KISS
Example

But, if we only need a data strucuture of 500 * 4 elements, Array is
the better choice. It is simple and easy to consume.
So, we have to understand the situation and data behaviour, then go for
the implementation.

KISS
Example

But, if we only need a data strucuture of 500 * 4 elements, Array is
the better choice. It is simple and easy to consume.
So, we have to understand the situation and data behaviour, then go for
the implementation.
If the code is not simple, then we have to try to make it simple.

YAGNI
YAGNI

YAGNI
YAGNI
YAGNI stands for You Ain’t Gonna Need It

YAGNI
YAGNI
YAGNI stands for You Ain’t Gonna Need It
Basically we have make sure that we are not doing anything that is not a
must.

YAGNI
Example 1
We have learnt over time a good amount of design patterns, Creational

Design Pattern, Structural Design Pattern and Behavioral Design
Patterns.

YAGNI
Example 1

Patterns.
While coding, it is very obvious that we will try to implement these
patterns.

YAGNI
Example 1

Patterns.
patterns.
But we have to ask ourselves the YAGNI question. Do we actually need
the design pattern we are implementing?

YAGNI
Example 1

Patterns.
patterns.
But we have to ask ourselves the YAGNI question. Do we actually need
the design pattern we are implementing?
We do not want to overcommit anything that is not necessary.

YAGNI
Example 2
We can look at another scenario where we have to complete a project

which will be used for a limited amount of users for nearly 3-4 months.

YAGNI
Example 2

Now do we need to think about the future and make it expandable? Do
we need to go for microservice architecture?

YAGNI
Example 2

YAGNI tells us not to go for them because we don’t need all those
features for now. Microservice will be a waste of time as there will not be
a lot of services availble.

YAGNI
Example 2

YAGNI tells us not to go for them because we don’t need all those
features for now. Microservice will be a waste of time as there will not be
a lot of services availble.
YAGNI is all about doing what is obviously needed, no

preassumptions, no future thinking, no overcommit. We will write
only what we need right now.

Introduction to SOLID

What is SOLID?

What is SOLID?
Five principles of Object-Oriented Class Design

What is SOLID?
Five principles of Object-Oriented Class Design

Set of rules and best practices to follow while designing a class
structure

History

History
First introduced by the famous Computer Scientist Robert J. Martin

(a.k.a Uncle Bob) in his paper in 2000

History
First introduced by the famous Computer Scientist Robert J. Martin

(a.k.a Uncle Bob) in his paper in 2000
SOLID acronym was introduced later by Michael Feathers

SOLID means Supple
Does SOLID mean rock solid?

SOLID means Supple

NO

SOLID means Supple

NO
Then what?

SOLID means Supple

NO
Then what?
SOLID means Supple which ensures that the software can be changed
with minimum effort if needed

SOLID means Supple

NO
Then what?
Flexible

SOLID means Supple

NO
Then what?
Flexible
Modifiable

SOLID means Supple

NO
Then what?
Flexible
Modifiable
Extensible

What people confuse SOLID with?
SOLID is

SOLID is
Not a Library

SOLID is
Not a Library
Not a Framework

SOLID is
Not a Library
Not a Framework
Not a Pattern

SOLID is
Not a Library
Not a Framework
Not a Pattern
Not a Goal

Is Different
In any typical code there can be an entry point class A, which calls class
B, then B calls class C, C calls class D1. But when a change is required
that B should call class D2, then lots of code lines need to be changed
manually.
Figure: Breaks SOLID Principle

Is Different(continued)
Figure: Maintains SOLID Principle

Is Different(continued)
It is difficult to understand seeing the code that which class will be called
from C. It actually calls and Interface. Thus SOLID code is difficult from
any typical code.

An Example : Notification Handler Application

The class MSG calls different classes.

An Example : Notification Handler Application(continued)

The MSG calls an Interface.

SOLID helps to avoid:

Rigidity

Rigidity
Fragility

Rigidity
Fragility
Immobility

Rigidity
Fragility
Immobility
Viscosity

Rigidity
Fragility
Immobility
Viscosity
Needless Complexity

The five SOLID Principles

Single Responsibility Principle (SRP)


Open/Closed Principle (OCP)


Liskov Substitution Principle (LSP)


Interface Segregation Principle (ISP)


Interface Segregation Principle (ISP)
Dependency Inversion Principle (DIP)

SRP
Single Responsibility Principle:

SRP

A class should have only one reason to change.

SRP

A class should have only one responsibility.

SRP

A class should have only one responsibility.
This makes the code easier to understand, maintain, and test.

OCP
Open/Closed Principle:

OCP
A class should be open for extension but closed for modification.

OCP
One should be able to add new functionality to a class without
changing its existing code.

OCP
One should be able to add new functionality to a class without
changing its existing code.
This reduces the risk of introducing new bugs and makes the code
more reusable.

LSP
Liskov Substitution Principle:

LSP

Objects of a superclass should be replaceable with objects of a
subclass without affecting the correctness of the program.

LSP

A subclass should be able to be used in place of its parent class
without causing any unexpected behavior.

LSP

A subclass should be able to be used in place of its parent class
without causing any unexpected behavior.
This makes the code more flexible and extensible.

ISP
Interface Segregation Principle:

ISP

Clients should not be forced to depend on interfaces they do not use.

ISP

A class should have only the methods that are relevant to its behavior.

ISP

A class should have only the methods that are relevant to its behavior.
This makes the code easier to understand and reduces the coupling
between different parts of the system.

DIP
Dependency Inversion Principle:

DIP

High-level modules should not depend on low-level modules.

DIP

Instead, both should depend on abstractions.

DIP

The code should depend on interfaces rather than concrete
implementations.

DIP

The code should depend on interfaces rather than concrete
implementations.
This makes the code more modular and flexible.

THE END

ISD Lecture1 Presentation

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

ISD Lecture1 Presentation

Uploaded by

Copyright:

Available Formats

Introduction to Design Principles

CSE325: Information System Design

Introduction to Design Principles 1 / 94

Saira Yeasmin - 1805037

Subsection: A2, Group: 04

Introduction to Design Principles 2 / 94

Importance of Object Oriented

Introduction to Design Principles 3 / 94

In OOP, a software is organized as collection of discrete objects that

Introduction to Design Principles 4 / 94

In OOP, a software is organized as collection of discrete objects that

Basic terminology and ideas of OOP are:

Introduction to Design Principles 4 / 94

In OOP, a software is organized as collection of discrete objects that

Basic terminology and ideas of OOP are:

Introduction to Design Principles 4 / 94

In OOP, a software is organized as collection of discrete objects that

Basic terminology and ideas of OOP are:

Introduction to Design Principles 4 / 94

In OOP, a software is organized as collection of discrete objects that

Basic terminology and ideas of OOP are:

Introduction to Design Principles 4 / 94

In OOP, a software is organized as collection of discrete objects that

Basic terminology and ideas of OOP are:

Introduction to Design Principles 4 / 94

Here is a list of few benefits of OOP

Introduction to Design Principles 5 / 94

Here is a list of few benefits of OOP

Introduction to Design Principles 5 / 94

Here is a list of few benefits of OOP

Introduction to Design Principles 5 / 94

Here is a list of few benefits of OOP

Introduction to Design Principles 5 / 94

Here is a list of few benefits of OOP

Introduction to Design Principles 5 / 94

Here is a list of few benefits of OOP

Introduction to Design Principles 5 / 94

Here is a list of few benefits of OOP

Introduction to Design Principles 5 / 94

Objects in an OOP language provide an abstraction that hides the

Introduction to Design Principles 6 / 94

Objects in an OOP language provide an abstraction that hides the

Introduction to Design Principles 6 / 94

Objects in an OOP language provide an abstraction that hides the

Introduction to Design Principles 6 / 94

Introduction to Design Principles 7 / 94

A car is an object that has many features such as wheels, engine,

Introduction to Design Principles 8 / 94

A car is an object that has many features such as wheels, engine,

Introduction to Design Principles 8 / 94

A car is an object that has many features such as wheels, engine,

Introduction to Design Principles 8 / 94

OOP supports modularity which allows to break large,complex

Introduction to Design Principles 9 / 94

OOP supports modularity which allows to break large,complex

Introduction to Design Principles 9 / 94

OOP supports modularity which allows to break large,complex

Introduction to Design Principles 9 / 94

In building a software application for a car rental company,we create

Introduction to Design Principles 10 / 94

In building a software application for a car rental company,we create

Introduction to Design Principles 10 / 94