SOLID Principles

Question 1

What does the S stand for in SOLID?

Answer 1

Single Responsibility Principle

Classes and objects should only have one job

Question 2

What does the O stand for in SOLID?

Answer 2

The Open/Closed Principle

Objects should be open to extension, but closed to modification

Question 3

What does the L stand for in SOLID?

Answer 3

Liskov Substitution principle

Objects of the same type should be interchangeable

Question 4

What does the I stand for in SOLID?

Answer 4

Interface Segregation

Small compact interfaces are preferable to ‘God Objects’.

Question 5

What does the D stand for in SOLID?

Answer 5

Dependency Inversion

Applications should depend on Abstractions not concrete instances of an object.

Question 6

Would connecting to a database in order to post a tweet be considered two responsibilities in a PostTweet object?

Answer 6

Yes - the database connection task should be abstracted.

Question 7

Would the following code be a correct way to remove the responsibility of connecting to a database?

protected function getConnection()
{
return DatabaseLayer::getConnection();
}

Answer 7

Yes - but it could be improved even further by using dependency injection. This at least abstracts away the act of connecting - and allows for mocks and testing.

Question 8

What is one of the most important tools in the PHP object model for implementing the ‘O’ part of solid (Open / Closed principle)?

Answer 8

Interfaces - these allow the creation of solidified and defined interfaces for creating objects when those objects have similar behaviours but different internals.

Question 9

What does the Liskov substitution principle state?

Answer 9

That we should be able to swap objects of the same type without changing the correctness of the program.

Question 10

Interfaces allow us to enforce inputs in PHP, what can we use to enforce outputs?

Answer 10

There are no features built into PHP that enforce outputs - this is why the Liskov principle is important (i.e. we must enforce this ourselves in the design).

Question 11

What PHP features should we use to help enforce the Liskov principle?

Answer 11

Effective comments and type hinting.

Question 12

If an object has more than 5-7 methods, what could this indicate?

Answer 12

It has too many responsibilities, and therefore could do with a refactor.

Question 13

If you find yourself building an interface that not all objects can honor (i.e. you have to implement a stub for that method, but it is empty) what does this indicate?

Answer 13

That you should break your interfaces down into multiple interfaces.

Question 14

How do you implement multiple interfaces?

Answer 14

class MyClass implements IMyInterface1, IMyInterface2
{
}

Question 15

If it doesn’t make sense to use multiple interfaces (to deal with objects that may have an additional method that others don’t), what is another way of implementing this without violating the Interface Segregation principle?

Answer 15

Use traits - this allows those objects that need to use an extra method to have the method - but doesn’t require the interface to expose a method that not all objects will use.

Question 16

Why can we simply use a method of an injected object without being concerned whether it exists?

Answer 16

Because if we have followed the O and the I principle, we should be using type hinting and interfaces to inject a dependency. This means the interface is consistent and guaranteed, and we can rely on the abstraction.

Question 17

What is one of the most important benefits of dependency injection?

Answer 17

Testability

Question 18

What should you do with extra responsibilities that don’t fit with the ‘Single Reponsibility’ paradigm?

Answer 18

Delegate to other objects

Question 19

What does Meyers’ Open / Closed principle state?

Answer 19

That once an object has been completed, it may only be modified to fix bugs, and cannot be modified to add new features.

Question 20

In Meyers’ description of the Open / Closed principle, how would new features be added to an object?

Answer 20

Through inheritance (Open for extension).

Question 21

What does the Polymorphic interpretation of Open / Closed state?

Answer 21

Once solidified, the API of a class is set, but classes inheriting from that class may implement that API in anyway they choose.

Question 22

Which is the more common interpretation of Open / Closed principle, Meyer or Polymorphic.

Answer 22

The polymorphic interpretation - i.e. that once the API is set, classes that inherit from that class may implement that API in anyway they choose.

Question 23

Objects B and C inherit from A. Swapping B and C with A does not affect the way the program runs in anyway - what principle of Solid does this conform to?

Answer 23

The Liskov principle - that any object of the same type should be interchangeable without affecting the correctness of the program.

Question 24

Given the need to develop a database class, why would the Interface Segregation principle suggest that it be pertinent to add transactions to a second interface?

Answer 24

Because not all databases are transaction based, and if it were added to the main base class - then databases that don’t support transactions would have to implement that interface.

Question 25

Does dependency injection satisfy the requirements of Dependency Inversion?

Answer 25

No - only partially. Because of the way PHP typehinting works - type hinting on an interface or concrete object (class name) will both work if the object implements the interface. But only typehinting on the interface is correct.

Question 26

When considering the ‘Single Responsibility’ concept - is creating an object it’s own responsibility (and therefore deserving of its own class?)?

Answer 26

Yes it is.

Question 27

What design patterns could be used to create objects?

Answer 27

Abstract Factory, Factory Methods or Singleton.

Question 28

If you see objects created inside other objects, this indicates you are violating what principle?

Answer 28

Dependency Inversion.

Question 29

What is a Factory Method?

Answer 29

A method that is a part of an object, used to create new objects.

Question 30

A factory method is usually a part of which design pattern?

Answer 30

Abstract Factory.

Question 31

Why is the following method frowned up in creating factory methods?

Object::factoryMethod();

Answer 31

Using a static factory method creates tight coupling between the method and the class name (exactly what you are trying to avoid by using factory methods). It also makes mocking very difficult.

Question 32

If you have multiple similar types of objects (for example a caching system, but you want to support multiple engines) - what pattern is the best for this?

Answer 32

Abstract Factory

Question 33

In an Abstract Factory, the object that receives the generated object is called…

Answer 33

The client

Question 34

What is the name of the object that is generated from the Abstract Factory?

Answer 34

The product

Question 35

Why does the Factory Method exist at all, given that the Abstract Factory pattern is probably more ‘correct’ in terms of OO programming?

Answer 35

Because it can be a unnecessarily complicated for creating simple objects.

Question 36

What situations are Abstract Factory patterns not suitable for?

Answer 36

Creating large / complicated objects that require multiple steps for configurations.

Question 37

What is ‘Duck Typing’?

Answer 37

In polymorphism, passing an object of a specific type into a function will work, as long as the object is of the same type as expected by the parameter.

In PHP however, you do not have to specify the type (through type hinting) - so how does PHP handle a user passing an object that may not be of the intended type? As long as it has the correct method (i.e. called later) - it will work. It’s called duck typing because PHP says, if the object looks like a duck, walks like a duck - it must be a duck (so call the method).

Question 38

When would you use the term ‘Duck Typing’?

Answer 38

When you see non-inheritance based polymorphism.

Question 39

What is the Null object pattern?

Answer 39

Given a class that requires another object, it is often best to provide this object through dependency injection. If you were to do this through a setter - it is possible the object is created without that dependency. The null object pattern allows the object to continue working - without doing any conditional statements to see if the object exists or not.

class NullObject {
  public function log($message) { }
}

class ClassNeedsLogging
{
   public function usesLogger() 
   {
      $this->logger->log('If logger hasn't been set - this wont cause an error');
   }

   public function setLogger($logger)
   {
      $this->logger = $logger;
   }
}

Question 40

What are some of the pitfalls of using the Null Object pattern?

Answer 40

It can make errors or bugs appear as though things are executing normally.