the solid principles

Question 1

why do we use the solid principles

Answer 1

they tell us how to arrange our functions and data structures into classes and how they should interact with eachother

Question 2

source code dependency

Answer 2

high level units are dependant on what happens in the lower level units creating a hierarchy and making it harder to identify where a problem originated

Question 3

what do we need in principles of good design

Answer 3

reduce coupling and increase cohesion

Question 4

cohesion

Answer 4

each unit should be focused on one thing

Question 5

what 3 things should we avoid in good design

Answer 5

rigid design
fragile design
immobile design

Question 6

rigid design

Answer 6

every change may cause changes in other parts of the system

Question 7

fragile design

Answer 7

the system breaks when a single change is made (due to high coupling)

Question 8

immobile design

Answer 8

when code cant be reused
the design contains functionality that could be used in another system but the effect and risk of extracting it would be too big

Question 9

srp

Answer 9

solid responsibility principle; a module should be responsible for only one actor

Question 10

why is srp a problem (solid responsibility principle)

Answer 10

you may need to change the needs for one actor which would then change something for all other actors

Question 11

what is the solution to solid responsibility principle

Answer 11

decouple; separate the code for different actors into separate code units

Question 12

ocp

Answer 12

open-closed principle; classes should be open for extension but closed for modification

Question 13

what is the benefit of open-closed principle

Answer 13

you reduce making errors when you have to make changes

Question 14

what is the solution for open-closed principle

Answer 14

the class is changed to an interface and the old methods are turned into concrete classes

Question 15

lsp

Answer 15

liskov substitution principle; the child class should inherit all features of the parent class

Question 16

isp

Answer 16

interface segregation principle; a client shouldn’t depend/have access to methods that they don’t use

Question 17

what is the issue with not using isp (interface segregation principle)

Answer 17

a client may have to be recompiled as a method they weren’t using had to be modified when it shouldn’t have effected them in the first place

Question 18

how do we solve isp (interface segregation principle)

Answer 18

polluted interfaces should be split
there should be interfaces between the client and the main class containing only the methods that the client can use

Question 19

dip

Answer 19

dependency inversion principle; allows you to have flexible systems where the source code is only dependent on abstractions not concrete implementations

Question 20

why do we use dip (dependency inversion principle)

Answer 20

we dont want to be dependent on things that might change

Question 21

what is the solution for dip (dependency inversion principle)

Answer 21

create an interface and instead of referring to the concrete name you refer to the interface