SOLID New

Question 1

What does the Single Responsibility Principle state?

Answer 1

A class, module, or method should have only one reason to change and should focus on a single functionality.

Question 2

What are common signs of a Single Responsibility Principle (SRP) violation?

Answer 2

A class serves more than one actor, has responsibilities for multiple functionalities, or contains entangled methods that serve different purposes.

Question 3

What are the problems caused by SRP violations?

Answer 3

Classes become tightly coupled, changes in one part can affect the entire system, and they can lead to ‘God classes’ that know or do too much.

Question 4

What is an example of SRP violation?

Answer 4

A class like DLModel that includes preprocess, train, and evaluate methods serving three different functionalities.

Question 5

How can you improve SRP violations in the DLModel example?

Answer 5

Separate the functionalities into individual classes: Preprocessor for preprocess, DLModel for train, and Evaluator for evaluate.

Question 6

What does the Open/Closed Principle state?

Answer 6

Software entities (classes, modules, methods, etc.) should be open for extension but closed for modification.

Question 7

What is a common sign of an Open/Closed Principle violation?

Answer 7

Classes containing switch or if statements that require modification when adding new functionality.

Question 8

What is the benefit of adhering to the Open/Closed Principle?

Answer 8

You can extend functionality without altering existing code, making the codebase more stable and maintainable.

Question 9

What does the Liskov Substitution Principle (LSP) state?

Answer 9

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

Question 10

What is an example of an LSP violation?

Answer 10

A Square class inherits from a Rectangle class but violates the ‘is-a’ relationship due to differences in how they calculate area (e.g., width × height vs. side × side).

Question 11

How can LSP violations be fixed in the Rectangle-Square example?

Answer 11

Create a Shape abstract class with a calculate_area method and let Rectangle and Square extend this class, implementing their specific logic.

Question 12

What does the Interface Segregation Principle state?

Answer 12

Clients (classes and subclasses) should not depend on methods they do not use. It’s better to have many specific interfaces than a single general one.

Question 13

What is an example of an Interface Segregation Principle violation?

Answer 13

An OldPrinter class inherits from a Printer interface with methods like print, scan, and fax, but OldPrinter does not need scan and fax.

Question 14

How can ISP violations be fixed in the Printer example?

Answer 14

Create smaller interfaces like Print, Scan, and Fax, and let OldPrinter implement only the Print interface while NewPrinter implements all three as needed.

Question 15

What does the Dependency Inversion Principle (DIP) state?

Answer 15

Abstractions should not depend upon details; details should depend upon abstractions.

Question 16

What is a common sign of a Dependency Inversion Principle violation?

Answer 16

A class depends on a concrete class (e.g., instantiating it in its constructor), rather than depending on an abstraction or interface.

Question 17

What is the main benefit of adhering to the Dependency Inversion Principle?

Answer 17

Code becomes loosely coupled, easier to test, and more robust to changes in concrete implementations.

Question 18

How can DIP violations be resolved in the MLPipeline example?

Answer 18

Create an Evaluator interface and let MLPipeline depend on this interface. Concrete implementations like PyTorchEvaluator or TensorFlowEvaluator can implement the interface.

Question 19

What technique is commonly used to follow the Dependency Inversion Principle?

Answer 19

Dependency injection is commonly used to inject abstractions into classes instead of directly instantiating concrete objects.