Final Part A

Question 1

First 6 components of well-documented design pattern

Answer 1

• pattern name
• intent
• other names
• motivation
• applicability
• structure

Question 2

Second 7 components of well-documented design pattern

Answer 2

• participants
• collaboration
• consequences
• implementation
• sample code
• known uses
• related patterns

Question 3

definition of design pattern

Answer 3

a design pattern is a general reusable solution to a commonly occurring problem within a given context in software design. A design pattern is not a finished design that can be transformed directly into source or machine code. It is a description or template for how to solve a problem that can be used in many different situations. Patterns are formalized best practices that the programmer can use to solve common problems when designing an application or system. Object-oriented design patterns typically show relationships and interactions between classes or objects, without specifying the final application classes or objects that are involved.

Question 4

What are creational design patterns?

Answer 4

pattern that deal with object creation mechanisms

Question 5

What are structural design patterns?

Answer 5

patterns that ease design by identifying ways to realize relationships among entities

Question 6

What is a behavioral design patterns?

Answer 6

design patterns that identify common communication patterns among objects

Question 7

what are data clumps

Answer 7

when different parts of the code contain identical groups of variables

Question 8

what is primitive obsession

Answer 8

use of primitives instead of objects

Question 9

bad smell: switch statements

Answer 9

overly complex switch statements

Question 10

bad smell: temporary field

Answer 10

a field that gets its values only under circumstances and is otherwise empty

Question 11

bad smell: refused bequest

Answer 11

a subclass only uses some of the methods from its parent

Question 12

bad smell: alternative classes with different interfaces

Answer 12

two classes perform identical functions but have different method names

Question 13

bad smell: divergent change

Answer 13

when you change a class you have to make changes to many unrelated methods

Question 14

bad smell: shotgun surgery

Answer 14

making any modifications requires that you make many small changes to many different classes

Question 15

bad smell: parallel inheritance hierarchies

Answer 15

whenever you create a subclass for a class, you find yourself needing to create a subclass for another class

Question 16

bad smell: lazy class

Answer 16

doesn’t do enough to merit its existence

Question 17

bad smell: feature envy

Answer 17

a method access the data of another object more than its own data

Question 18

bad smell: inappropriate intimacy

Answer 18

one class uses internal fields and methods of another class

Question 19

bad smell: message chains

Answer 19

a() calls b() which calls c() which calls d()

Question 20

bad smell: middle man

Answer 20

the only action one performs is delegating work to another class

Question 21

definition of refactoring

Answer 21

a change to the system that leaves its behavior unchanged but enhances some non-functional quality

Question 22

7 reasons for refactor

Answer 22

• prevent design decay
• clean up messes in the code
• simplify the code
• increase readability and understandability
• find bugs
• reduce debugging time
• build in learning we do about application

Question 23

How to refactor (5)

Answer 23

• make sure tests fail in a deterministic way
• find code smells
• determine how to simply code
• make simplifications
• ensure tests fail in the same fashion

Question 24

Requirements for refactoring (4)

Answer 24

• collective code ownership
• coding standards
• tests
• continuous integration

Question 25

when to refactor (3)

Answer 25

• all of the time
• rule of 3 (if you have to touch a piece of code because of bug 3 or more times then it needs to be refactored)
• anytime you touch the code and find a bad smell

Question 26

biggest problem with refactoring

Answer 26

refactoring presents a good chance of introducing a new bad smell

Question 27

why developers don’t refactor (4)

Answer 27

• lack of understanding
• short-term focus by management (always wants new functionality)
• not gonna get paid for it
• fear of breaking current program

Question 28

when to use containment vs. inheritance

Answer 28

if Liskov’s substitution principle can be applied favor inheritance, otherwise favor containment