Final

Question 1

This pattern allows an object to alter its behavior when its internal state changes, causing the object to appear as if it alter its class membership, i.e., changed subclasses.

Answer 1

State

Question 2

This pattern addresses situations where there are multiple ways of doing the same kind of thing, but with different kinds of input, output, or runtime characteristics and the choice of which way to do it has to be made at runtime

Answer 2

Strategy

Question 3

This pattern should not be used an excuse to violate the “no global variables” rule.

Answer 3

Singleton

Question 4

An application of this pattern defines a high-level interface that can make a subsystem easier to use.

Answer 4

Façade

Question 5

The solution for this pattern creates a multicast-style of communication (which may be method calls), where a sender object does not need to know about the specific receivers and there can be multiple receivers.

Answer 5

Observer

Question 6

This pattern is also called View-Model-Binder

Answer 6

MVVM

Question 7

This pattern is often used in conjuction with the Strategies pattern to leverage reuse amoung concrete strategies

Answer 7

Template Method

Question 8

Select a creational pattern with class scope, i.e. a pattern who primary purpose is to create objects and whose solution relies primarily on inheritance.

Answer 8

Factory Method. If you ignore the inheritence part, then also Factory Idiom.

Question 9

The pattern can address the problem of accessing remote object as if they were local and hide the true location of an object

Answer 9

Proxy

Question 10

This pattern is useful when an extension can result in an exponential explosion of subclasses.

Answer 10

Decorator

Question 11

This pattern has the negative consequence that adding new kinds of product (i.e., classes) may be difficult, i.e., result in lots of changes to existing code

Answer 11

Abstract Factory

Question 12

Select a compound pattern

Answer 12

MVC, MVP, MVVM

Question 13

With this pattern, it is easy to add new behaviors to a class of objects

Answer 13

State, Visitor, Decorator

Question 14

With this pattern, it is easy to extend a system with a new family of products that parallel existing families of product from a functional perspective.

Answer 14

Abstract Factory

Question 15

This pattern allows for the attachment of any combination of additional responsibilities to an object at run time.

Answer 15

Decorator

Question 16

By itself, the pattern does not enforce encapsulation of components in a subsystem, but makes it easier to work with them.

Answer 16

Façade

Question 17

The solution of this pattern has the developer define the skeleton of an algorithm in a method and defer the specifics of some steps of that algorithm to subclasses.

Answer 17

Template Method

Question 18

This pattern defines a readable and extensible way to perform operations over a collection of elements, without breaking the encapsulation of the collection or its elements.

Answer 18

Visitor, and to a lesser extent Iterator

Question 19

Select a pattern that can be implemented with either object (delegation) or class scope (inheritance).

Answer 19

Adapter

Question 20

This pattern ensures that a class has only one instance.

Answer 20

Singleton

Question 21

The solution proposed by this pattern is to extract from a class (i.e., the context) certain behaviors that represent different algorithms for the same basic kind of operation and then encapsulate them in a hierarchy of classes, where each of concrete classes represents a different algorithm.

Answer 21

Strategy

Question 22

Consider using this pattern in any system that includes a collection of objects and you need to traverse through that collection

Answer 22

Iterator

Question 23

This pattern allows algorithms to be selected at runtime, by defining a family of algorithms, encapsulating each algorithm, and making the algorithms interchangeable within that family.

Answer 23

Strategy

Question 24

If generics are not available, then adding a new concrete element types can be hard for the solution of this pattern

Answer 24

Visitor

Question 25

This idea involves defining a method (typically a static method) that encapsulates the logic for constructing the right kind of object (typically from specializations of a the class that holds the static method.)

Answer 25

Simply Factory Idiom

Question 26

With the solution of this pattern, each product family is implemented in its own hierarchy.

Answer 26

Abstract Factory

Question 27

This pattern is sometimes called the "Action" or "Transaction" pattern.

Answer 27

Command

Question 28

With this pattern, developers can effectively change an otherwise unchangeable interface.

Answer 28

Adapter

Question 29

With this pattern it is easy to add new operations that operate on a complex object structure

Answer 29

Visitor

Question 30

This pattern is also known as a Wrapper.

Answer 30

Adapter, Decorator

Question 31

This pattern combines the use of Strategy, Composite, and Observers to create three layers of software, but still results in some cyclic dependencies

Answer 31

MVC

Question 32

This pattern is useful in any system where one layer of software needs to perform a specific set of actions on objects in another layer of software, particularly if those actions need to be asynchronous, logged, or undone.

Answer 32

Command

Question 33

The solution of this pattern is used in the solution for the Decorator Pattern, but addresses a more generic problem.

Answer 33

Composite

Question 34

This pattern can be used in multiple possible contexts, but the most common is graphical user interfaces, where multiple displays need to show state information about the same object(s).

Answer 34

Observer

Question 35

A disadvantage of this pattern is that it might make the design overly general. Specifically, it might create a bloated interface for the base component and therefore, cause uncessary complexity in concrete components.

Answer 35

Composite

Question 36

This pattern provides a unified interface to a set of components in a subsystem that allows for easy and coordinated use of those components

Answer 36

Façade

Question 37

Select a pattern that is often used with Visitor

Answer 37

Iterator

Question 38

This pattern allows clients to treat aggregate objects and subpart objects uniformly.

Answer 38

Composite

Question 39

This pattern is sometimes also called the "Policy Pattern"

Answer 39

Strategy

Question 40

This is an architectural design pattern that prescribes three loosely coupled layers of software, connected via bindings

Answer 40

MVVM

Question 41

The pattern provides a surrogate placeholder for another objects for the purpose of controlling access to that object in some way.

Answer 41

Proxy

Question 42

This pattern localizes and encapsulates state-specific behavior for a class of objects

Answer 42

State

Question 43

This idea can be used when a component needs to create an object, but doesn't directly need to know the type of object, as long as it adhers to an interface abstraction.

Answer 43

Simply Factory Idiom

Question 44

This pattern requires designers to separate intrinsic from extrinsic state for a class of objects.

Answer 44

Flyweight

Question 45

This pattern is useful when developing a class library or framework and when developers of specific applications need to customize how certain kinds of objects are created

Answer 45

Factory Method

Question 46

This pattern describes how to support a large number of objects that have common state information

Answer 46

Flyweight

Question 47

This pattern may help designers reduce the space required to manage a large number of objects.

Answer 47

Flyweight

Question 48

A pattern, whose solution may result in a long delegation- chain at runtime

Answer 48

Decorator, Composite

Question 49

The solution to this pattern includes a base class or interface with methods for subscribing and unsubscribing

Answer 49

Observer

Question 50

This pattern focuses on the formation of complex, recursive object structures

Answer 50

Composite

Question 51

Use this pattern when you want to create a reusable class that coorperates with unrelated or unforeseen classes, that is, classes that don't necessarily have compatible interfaces.

Answer 51

Adapter

Question 52

Select one of the patterns or idioms that focus on creating an object

Answer 52

Simply Factory, Factory Method, Abstract Factory

Question 53

This pattern can simplified dependencies between objects when the notification of state changes are a primary concern

Answer 53

Observer

Question 54

This pattern addresses the problem of how to encapsulate state-specific behavior as objects in a way that increases the cohesion and extensibility of X, without creating undue coupling

Answer 54

State

Question 55

One of the participants in this pattern is a "leaf".

Answer 55

Composite

Question 56

This pattern can use defer the actual creation (or copying) of a complex object until it is needed.

Answer 56

Proxy

Question 57

Select one of two patterns that have similar structure diagrams and rely on a recursive data structure to organize an open-ended number of objects. They have distinct but complimentary intents, and are therefore often used in concert with each other.

Answer 57

Decorator, Composite

Question 58

This pattern defines an interface for creating an object, but lets subclasses decide which class to instantiate.

Answer 58

Factory Method

Question 59

This pattern helps developers implement "virtual constructors".

Answer 59

Factory Method

Question 60

This pattern's solution includes an Invoker.

Answer 60

Command

Question 61

One of the negative consequences of this pattern is that clients may experience unexpectedly long delays when changing the state of a target object.

Answer 61

Observer, Proxy, and possibly the Command if an Invoker is not used

Question 62

Select a pattern whose intend is to help with the development, testing, and maintenance of user interfaces.

Answer 62

MVC, MVP, MVVM

Question 63

This pattern is also known as "surrogate".

Answer 63

Proxy

Question 64

This pattern has two variations, one called Supervising Controller and another called Passive View.

Answer 64

MVP

Question 65

Select one pattern that can make unit testing simplier.

Answer 65

Any, except perhaps the singleton which can make automated testing harder in some frameworks

Question 66

Use this pattern when you want to use an existing class, but its interface does not match the one you need.

Answer 66

Adapter

Question 67

Select a pattern whose solution(s) rely only on inheritance.

Answer 67

Template Method, Factory Method

Question 68

This pattern lets subclasses redefine parts of an algorithm without changing the algorithm's structure.

Answer 68

Template Method

Question 69

This pattern provides an interface for creating objects from families of parallel class hierarchies, particularly in the context of cross-platform development.

Answer 69

Abstract Factory

Question 70

This pattern encapsulates actions, e.g., method calls, in objects, creating opportunities to perform them asynchronously and to make them “undoable” and repeatable

Answer 70

Command

Question 71

Select a pattern that relies on delegation via aggregation but should not, on its own, result in long chains of delegation

Answer 71

Flyweight, Adapter (Object), Proxy

Question 72

This patterns can be used to provide a global point of access to something like system-wide concrete factory.

Answer 72

Singleton

Question 73

This pattern is useful when the system needs to be independent of how its products are created, composed, and represented and the class to instantiate has to be determined at runtime.

Answer 73

Prototype

Question 74

Select a pattern that can help create layers or subsystems that can be easily replaced or swapped out for some other implementation

Answer 74

Proxy, Abstract Factory, Command, Adapter, and even Façade if there is no other couple to the layer or subsystem that doesn't go through the Façade

Question 75

Select a pattern used as part of MVC

Answer 75

Strategy, Composite, Observer

Question 76

This pattern may have the negative consequence of producing a lot of small objects that all represent one real- world or problem domain object.

Answer 76

Decorator

Question 77

This pattern provides a way to access the elements of a collection sequentially without exposing the collection’s underlying implementation

Answer 77

Iterator

Question 78

This pattern can be used to create "smart references"

Answer 78

Proxy

Question 79

Events in C# are an implementation of this pattern, at least at a conceptual level.

Answer 79

Observer

Question 80

Characterized by the statement "Every object is an unique entity in the university, distinguished by its properties"

Answer 80

Object Identity

Question 81

Grouping objects together into sets based on common properties helps manage complexity. We do this during analysis to better understand the problem and during design to help structure a solution.

Answer 81

Classification

Question 82

Identifying an individual design decision and then implementing that decision in one place.

Answer 82

Localization of Design Decisions

Question 83

The act of hiding or placing a decision decision inside appropriate software components.

Answer 83

Encapsulation

Question 84

The act of summarizing or generalizing something to focus on the ideas that are most relevant to a purpose, or view of a complex thing that leaves out unnecesary details

Answer 84

Abstraction

Question 85

The manner and degree of interdependence between software components. Less of this makes for more maintainable and reusable software.

Answer 85

Coupling

Question 86

The degree to which the elements of a component belong together. More of this reduce complexity and increases maintainabiltiy and reusability.

Answer 86

Cohesion

Question 87

Software components should be extensible, but not modifiable.

Answer 87

Open/Closed Principle

Question 88

Abstract components should not depend on detail components.

Answer 88

Dependency Inversion

Question 89

A process by which developers break up a system into cohesive and loosely coupled components.

Answer 89

Modularization

Question 90

The degree to which a software system can be kept correct, reliable, and secure as it operating environment changes

Answer 90

Maintainability

Question 91

The degree to which the functionality of a system can be changed or expanded

Answer 91

Extensibility

Question 92

The degree to which a component, library of components, or framework can be leveraged in other software systems

Answer 92

Reuse

Question 93

This practice is one way to achieve Localization of Design Decisions

Answer 93

Encapsulate What Varies

Question 94

This practice can help understand the problem and problem domain better, as well as help formulate a solution, create a plan for developing the solution, and communicate with all stake holders

Answer 94

Conceptual Modeling

Question 95

This practice can help developers modularize software into loosing coupled layers of abstractions

Answer 95

Organize Software into Loosely Coupled Layers, Conceptual Modeling

Question 96

Both aggregation and inheritance can be used to achieve reuse. This practice recommends one over the over, when other considerations don't dictate one.

Answer 96

Prefer Aggregation Over Inheritance

Question 97

This practice can help developers reduce coupling by using interfaces and abstraction effectively

Answer 97

Program to an Interface or Abstraction

Question 98

The practice helps developers avoid the Uncommunitive Identifiers pitfall

Answer 98

Use Identifiers that Improve Readability and Maintainability

Question 99

This practice is critical to any software development effort and can help all stakeholders gain confidence in correctness of the software

Answer 99

Testing with Executable Unit Test Cases

Question 100

Exists in a software, where design or implementation uses identifiers that don't accurately communicate what the component represent

Answer 100

Uncommunitive Names

Question 101

Exists when the identifiers in the design or implementation do not follow any logical naming method or standard set of terminology

Answer 101

Inconsistent Names

Question 102

This pitfall exists when there are identifiers like "firstNameString" or "ageLabel" where String and Label are data types.

Answer 102

Types Embedded in Names

Question 103

Lack of cohesion in a method is a likely consequence of this pitfall

Answer 103

Long Methods

Question 104

Developers can slip into this pitfall if they don't localize design decisions

Answer 104

Duplicate Code

Question 105

Inappropriate use of the decorator pattern may lead to this pitfall

Answer 105

Long Message Chains

Question 106

The decorate pattern an help avoid this pitfall

Answer 106

Class Explosion

Question 107

This pitfall exists when a class tries to do too much

Answer 107

Large Classes

Question 108

Applying the decorator, strategy, template method or state pattern can often help extrication from this pitfall by reducing complex switch statement or if-then-else statement

Answer 108

Conditional Complexity

Question 109

This pitfall may exist when there is similar block of code, but the blocks are not exactly the same

Answer 109

Oddball Solution

Question 110

This pitfall reduces the readability and maintainability of the code, but does not have a direct impact on the functionality or performance

Answer 110

Redundant or Meaningless Comments, Dead Code

Question 111

This pitfall exists where there is an unused variable or a statement that is never executed

Answer 111

Dead Code

Question 112

When developers over design or implement feature that are not needed, they are succumbing to this pitfall.

Answer 112

Speculative Generality

Question 113

This pitfall exists when a field (data member) is only set and used in a specific situation or context.

Answer 113

Temporary Field

Question 114

This pitfall exists when a derived class is really not a specialization (subset) of a base class

Answer 114

Refused Bequest

Question 115

This pitfall exists when certain bad forms of coupling are present, namely when one class uses the internal fields or methods of another

Answer 115

Inappropriate Intimacy

Question 116

This pitfall exists when most of the logic of a method uses methods of another class.

Answer 116

Feature Envy

Question 117

Ensure the system is in a known state, or at least the component you are testing is in a known state, e.g. create a triangle object with specific sides

Answer 117

Setup

Question 118

Execute the thing you are testing, e.g., the ComputeArea() method

Answer 118

Simulate

Question 119

Compare actual the results with the expected results. The results may be the return value of a method, or more generally, the system’s new state

Answer 119

Observe