Design

Question 1

What is clean code, and why is it important?

Answer 1

Clean code refers to:

1. well-structured,
2. readable,
3. and maintainable code
4. that follows best practices.

It:
1. enhances collaboration,
2. reduces bugs,
3. and facilitates easier future modifications and debugging.

Question 2

What does SOLID stand for?

Answer 2

S - Single Responsibility Principle
O - Open/Closed Principle
L - Liskov Substitution Principle
I - Interface Segregation Principle
D - Dependency Inversion Principle

Question 3

What are some techniques to improve code readability?

Answer 3

-Meaningful variable and function names
- Proper code indentation and formatting
- Keeping functions short and focused (Single Responsibility Principle)
- Writing descriptive comments only when necessary

Question 4

What is DRY?

Answer 4

It stands for Don’t Repeat Yourself and advocates for avoiding duplication in code by extracting common functionalities into reusable components, functions, or modules. It promotes code reusability and maintainability.

Question 5

Single Responsibility Principle (SRP)

Answer 5

The Single Responsibility Principle (SRP) states that a class should have only one reason to change.

If multiple responsibilities are included in a class and one of those responsibilities changes, it could lead to changes affecting unrelated functionalities, resulting in a less maintainable codebase.

Question 6

Open/Closed Principle (OCP)

Answer 6

The Open/Closed Principle (OCP) asserts that software entities (classes, modules, functions) should be open for extension but closed for modification. This means that the behavior of a module can be extended without altering its source code.

By using techniques like inheritance, interfaces, and polymorphism, new functionality can be added to an existing codebase without changing its core implementation, thereby minimizing the risk of introducing bugs.

You can also use the Decorator pattern to apply new functionality to an existing component such that the component’s source code does not need to be changed.

Question 7

Liskov Substitution Principle (LSP)

Answer 7

The Liskov Substitution Principle (LSP) states that objects of a superclass should be replaceable with objects of its subclasses without affecting the behavior of the program.

Examples:

• Square vs Rectangle (changing length and width results in different behavior for things like calculating area).
• Seagull vs Penguin (both birds but both don’t fly).

Solution: More granular interfaces (i.e. Interface Segregation Principle).

Question 8

Interface Segregation Principle (ISP)

Answer 8

The Interface Segregation Principle (ISP) advocates that it is better to have many smaller interfaces than a few large ones.

A component should never have to implement or extend something that requires it to implement functionality that is not needed by that component.

Question 9

Dependency Inversion Principle (DIP)

Answer 9

inverts the direction of dependencies away from implementation to abstractions.

1. high-level modules should not depend on low-level modules and thus both should depend on abstractions
2. and abstractions should not depend on details, details should depend on abstractions

Question 10

What are some common code smells?

Answer 10

-Duplicated code
- Long methods or functions
- Large classes or modules
- Inappropriate comments
- Switch statements or conditional complexity

Question 11

What is Cohesion?

Answer 11

Cohesion refers to the degree to which elements within a module or class belong together.

High cohesion means that elements within a module are related and work together towards a single purpose.

Low cohesion signifies that the elements are not closely related.

Single Responsibility Principle

Question 12

What is Coupling?

Answer 12

Coupling represents the level of dependency between different modules or classes.

Loose coupling is desirable as it reduces the dependency between modules, making them more independent.

Tight coupling implies a high level of dependency, which can make changes more challenging.

Open/Close Principle

Question 13

What is dependency injection?

Answer 13

It is a design pattern or technique where one object supplies the dependencies to another object, rather than the object creating its dependencies directly.

Question 14

What is polymorphism?

Answer 14

objects being treated uniformly through a common interface while exhibiting behavior specific to their actual types

Question 15

What is composition?

Answer 15

Represents a more tightly coupled has-a relationship between classes where one class contains objects of another class such that:

1. When the whole is destroyed so are it’s parts
2. The whole is responsible for the creation, management and destruction of the parts
3. Changes to the container will likely impact the parts

Question 16

What is aggregation?

Answer 16

Represents a looser coupled has-a relationship between classes where one class contains objects of another class such that:

1. When the whole is destroyed, the parts can still exist independently.
2. The whole contains references to it’s parts but doesn’t own or create them.
   Changes to the container might not necessarily affect the parts

Question 17

What is Inversion of Control?

Answer 17

An architecture principle that refers to the inversion of the flow of control within an application from internal components to an external entity like a framework.

Question 18

What is idempotency?

Answer 18

A function applied multiple times has the same effect such that the results are always the same.

Examples: HTTP GET, PUT & DETETE where as POST is not because it may result in a different outcome or change in the server state.

Question 19

What is true duplication?

Answer 19

every change in one instance necessitates the same change to every duplicate of that instance.

Question 20

What is false/accidental duplication?

Answer 20

When 2 apparently duplicate sections of code evolve along different paths and eventually become 2 completely different and non-duplicate things.

Question 21

What’s an example of falsely applying the DRY principle when considering true and false duplication?

Answer 21

Input forms that look similar. If you use the same code for the form they will not be able to evolve along different paths over time but this very well may be necessary as the application changes.

Question 22

What is the law of Demeter (aka the Principle of Least Knowledge)

Answer 22

Only couple to things that you use and avoid coupling to things used by something you use.

Said another way, a method is only allowed to call:
1. Methods within it’s object
2. Method’s passed to the object as a parameter
3. Methods on an object you’ve created yourself.
4. Methods on a component of this object (i.e. an instance variable).

Question 23

What is a potential thing to watch for when considering the law of Demeter?

Answer 23

It can lead to a potential violation of the Interface Segregation Principle because when a calls b and b calls c, the b code must be expanded to handle calls to c for a which could potentially bloat b.

Question 24

What is an abstract class?

Answer 24

It is a class that cannot be directly instantiated but instead must be extended in order to be instantiated.

It can have default implementations that become available in the classes that extended it.

Question 25

What is the difference between an abstract class and an interface?

Answer 25

Typically the methods of an interface must be defined in the class that implements it such that there is no default functionality provided by the interface.