Core Design Principles

Question 1

The Single Responsibility Principle (SRP)

Answer 1

• Design classes in such a way that there is ideally only a single reason to change a class
  
  • Leads to smaller and more cohesive classes
  • Leads to less complex classes
  → Classes that are easier to understand and change

Question 2

Functional cohesion

Answer 2

• Group entities* that change for the same reasons
• Separate entities that change for different reasons

Question 3

encapsulation

Answer 3

The act of keeping both the data and the computation
together to limit the number of contact points between different parts of your system
often violated through references that escape

Question 4

advanatages of encapsulation

Answer 4

• Understanding a piece of code in isolation is easier
• Using a piece of code becomes less error-prone
• Changing a piece of code less likely breaks something else

Question 5

3 ways in which references can escape (slides)

Answer 5

1. Returning a reference to an external object
2. Storing an external reference internally
3. Leaking a reference through a shared structure

Question 6

+/- of immutability

Answer 6

+ You can share information without breaking encapsulation
+ You avoid temporal method dependencies (invocation order)
+It leads to thread safety
+ It allows the caching of objects

• You tend to create more objects
• Decreased performance efficiency (more garbage collection)

Question 7

How to make objects immutable

Answer 7

• Ensure that all the fields of your class are:
  
  • Either private and not changed by any instance method
  • Or immutable by default
    
    • Primitive types or enumerations
    • final
• Expose internal data consciously
  
  • Extended interface
  • Return copies
  • Via dedicated design patterns

Question 8

Inherent complexity

Answer 8

Unavoidable domain complexity

Question 9

Accidental complexity

Answer 9

Avoidable technical complexity introduced through suboptimal design

Question 10

types of complexity

Answer 10

Structural complexity (coupling): The number and strength of relationship between the structures in your program (packages, classes, methods)
reading complexity
data complexity
decision complexity