Exam

Question 1

AOP

Answer 1

Aspect-Oriented Programming (AOP) complements OO programming by allowing the developer to dynamically modify the static OO model to deal with cross cutting concerns

Question 2

Cross-cutting concerns

Answer 2

Concerns which “cross-cut” the class structure, lowering cohesion and increasing coupling.

Question 3

CCC Consequences

Answer 3

> Code Tangling

> Code Scattering

Question 4

Code Tangling

Answer 4

1) Code for CC is mixed with the business logic.

2) Reduces cohesion

Question 5

Code Scattering

Answer 5

1) Code is duplicated because it is needed in multiple places
2) Reduces coupling

Question 6

Lock handling Problem

Answer 6

1) Business logic code (put and get) is mixed with concurrency control code resulting in code tangling and poor cohesion
2) Have to add locking code correctly to every business logic code resulting in code scattering
3) Failure to do so would lead to hard to find bugs
4) Need a single, global lock resulting in extra coupling

Question 7

Lock handling Pros

Answer 7

1) Avoids code scattering and tangling
2) Lock is localised as a private instance variable
3) Reusable simply by writing a new concrete aspect

Question 8

AOP and Design Patterns Pros

Answer 8

1) Greater modularisation of concerns
2) Avoid code tangling and scattering
3) Easier software evolution
4) Greater code reuse
5) Easier management (easier to split tasks)
6) Cheaper implementation of new features

Question 9

AOP and Design Patterns Cons

Answer 9

1) Program flow is hard to follow
2) Tendency to use CCC everywhere, leading to poor designs
3) Everybody on the team needs to be up to speed with AOP
4) Tools limited to those which support AOP language in use

Question 10

AspectJ

Answer 10

1) Java AOP framework
2) Classes and aspects are written separately
3) “woven” together at bytecode generation time
4) Nothing in class code referes to the aspects

Question 11

AspectJ advice kinds

Answer 11

> before - code to be executed before the join point
after - code to be executed after join point
around - replaces the code
pointcut - shows where the CC should be applied

Question 12

AOP and Design Patterns

Answer 12

1) Observer and Singleton are the only ones who have any benefits
2) Pure fabrications have no sensible inheritance relationships outside the pattern
3) Combing patters will make AOP solutions more problematic

Question 13

Advice

Answer 13

Additional code that you want to apply to your existing model

Question 14

Join point

Answer 14

Place where CCC crosscuts the code

Question 15

Point cut

Answer 15

Point of execution in the application at which cross-cutting concern needs to be applied

Question 16

Aspect

Answer 16

The combination of the point-cut and the advice

Question 17

Iterative process

Answer 17

> Assumes you can’t get all requirements right at the start.
Progresses in a set of timeboxed iterations
Phases
Disciplines
Artifacts

Question 18

Timeboxed Iteration

Answer 18

Means if you don’t get it done you don’t extend the iteration, you change the plan

Question 19

Agile UP Phases

Answer 19

1. Inception
2. Elaboration
3. Construction
4. Transition

Question 20

UP Phases [Inception]

Answer 20

Initial feasibility study and project go-ahead

Question 21

UP Phases [Elaboration]

Answer 21

More detailed study, production of high-risk parts of the system. Iterative except for very small projects.

Question 22

UP Phases [Construction]

Answer 22

The bulk of the work. Iterative.

Question 23

UP Phases [Transition]

Answer 23

Acceptance testing, “maintenance” etc.; moving on to the next project.

Question 24

Disciplines

Answer 24

Done through process, not phases

Question 25

Disciplines Examples

Answer 25

> Requirements > Domain Modeling > Class Design > Coding

Question 26

Artifacts

Answer 26

> The things you make as part of the process | > The amount of “ceremony” in a project should be appropriate to the scale and nature of the project.

Question 27

Artifacts Agile approach

Answer 27

> Don’t produce more artifacts than you need to | > Don’t make them look pretty unless you have to.

Question 28

Ceremony

Answer 28

Artifacts other than code

Question 29

Use Cases

Answer 29

A description of a set of interactions between a system and and one or more actors

Question 30

Use Cases Formats

Answer 30

> Brief > Casual > Fully dressed

Question 31

Use Case [Brief]

Answer 31

A short paragraph describing the MSS.

Question 32

Use Case [Casual]

Answer 32

The MSS plus short descriptions of the main alternatives

Question 33

Use Case [Fully dressed]

Answer 33

Everything spelt out in full detail

Question 34

MSS

Answer 34

Main success scenario

Question 35

Agile Principles

Answer 35

1. Minimum ceremony – concentrate on producing working code 2. Embrace change (especially in requirements) 3. Constant contact with the customer 4. Self-organising teams rather than hierarchical management 5. Physicality, e.g. use physical cards to record requirements 6. Honesty between developers

Question 36

Agile Manifesto

Answer 36

1. Individuals and interactions over processes and tools 2. Working software over comprehensive documentation 3. Customer collaboration over contract negotiation 4. Responding to change over following a plan

Question 37

Agile Practices

Answer 37

1. Iterative development 2. User stories to capture users’ business needs. 3. Test-driven development 4. Short code-commit-build cycle 5. Programming in pairs 6. Short stand-up meetings 7. Frequent review of team performance

Question 38

User Stories

Answer 38

A short description of something that your customer will do when use software, focused on the value or result they get from doing this thing 1. Written on physical cards, notes on the reverse 2. Customer and developers agree on priorities 3. Broken up into “story points” to generate development tasks (described in developers’ language)

Question 39

GRASP

Answer 39

General Responsibility Assignment Software Patterns | > Basic guidelines/principles for assigning responsibilities to classes – the basic skill of OOD

Question 40

GRASP Patterns

Answer 40

> (Information) Expert | > Creator

Question 41

GRASP Patterns [Expert]

Answer 41

Assign a responsibility to the class that has the information necessary to fulfil the responsibility

Question 42

GRASP Patterns [Creator]

Answer 42

Lists likely candidate classes for creating instances of other classes. (special case of expert)

Question 43

High Cohesion

Answer 43

A class should represent one well-defined entity

Question 44

Low Coupling

Answer 44

A class should not be directly associated with many other classes (but some coupling is necessary).

Question 45

Indirection

Answer 45

> Provides means for a class to use another class indirectly > Ability to reference something using a name, reference, or container instead of the value itself > Used to improve coupling and cohesion (occurs in many GoF patterns).

Question 46

Pure Fabrication

Answer 46

A class which has no counterpart in the domain > Database connectors > Controllers > Underlying data structures

Question 47

Protected variation

Answer 47

Abstract something, so when it varies, it doesn’t affect everything else in a bad way

Question 48

Polymorphism

Answer 48

Ability to process objects differently depending on their data type or class

Question 49

Controller

Answer 49

A pure fabrication placed between the GUI and the internal logic of the system to decouple them

Question 50

Use Case Controller

Answer 50

Controls the actions required in a single use case

Question 51

Façade controller

Answer 51

Represents the whole system, e.g. a hardware device.

Question 52

Singleton

Answer 52

``` > Ensure that only one instance of a class is created > Provide a global access point to the object ```

Question 53

Factory

Answer 53

> Simplified version of Factory Method > Creates objects without exposing the instantiation logic to the client > Refers to the newly created object through a common interface. > Pure Fabrication

Question 54

Factory Method

Answer 54

``` > Defines an interface for creating objects, but lets subclasses decide which class to instantiate > Refers to the newly created object through a common interface ```

Question 55

Abstract Factory

Answer 55

Offers the interface for creating a family of related objects, without explicitly specifying their classes

Question 56

Builder

Answer 56

``` > Defines an instance for creating an object but letting subclasses decide which class to instantiate > Allows a finer control over the construction process ```

Question 57

Prototype

Answer 57

Specify the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype

Question 58

Object Pool

Answer 58

Reuses and shares objects that are expensive to create..

Question 59

Chain of Responsibility

Answer 59

> It avoids attaching the sender of a request to its receiver, giving this way other objects the possibility of handling the request too. > The objects become parts of a chain and the request is sent from one object to another across the chain until one of the objects will handle it.

Question 60

Command

Answer 60

> Encapsulate a request in an object > Allows the parameterization of clients with different requests > Allows saving the requests in a queue.

Question 61

Interpreter

Answer 61

> Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language > Map a domain to a language, the language to a grammar, and the grammar to a hierarchical object-oriented design

Question 62

Iterator

Answer 62

Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation

Question 63

Mediator

Answer 63

> Define an object that encapsulates how a set of objects interact. > Mediator promotes loose coupling by keeping objects from referring to each other explicitly, and it lets you vary their interaction independently

Question 64

Observer

Answer 64

Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.

Question 65

Strategy

Answer 65

> Define a family of algorithms, encapsulate each one, and make them interchangeable. > Strategy lets the algorithm vary independently from clients that use it

Question 66

Template Method

Answer 66

> Define the skeleton of an algorithm in an operation, deferring some steps to subclasses > Lets subclasses redefine certain steps of an algorithm without letting them change the algorithm's structure

Question 67

Visitor

Answer 67

> Represents an operation to be performed on the elements of an object structure > Lets you define a new operation without changing the classes of the elements on which it operates

Question 68

Null Object

Answer 68

> Provide an object as a surrogate for the lack of an object of a given type. > Provides intelligent do nothing behavior, hiding the details from its collaborators

Question 69

Adapter

Answer 69

``` > Convert the interface of a class into another interface clients expect. > Lets classes work together, that could not otherwise because of incompatible interfaces ```

Question 70

Bridge

Answer 70

> Decouple an abstraction from its implementation so that the two can vary independently > Publish interface in an inheritance hierarchy, and bury implementation in its own inheritance hierarchy.

Question 71

Composite

Answer 71

> Compose objects into tree structures to represent part-whole hierarchies. > Lets clients treat individual objects and compositions of objects uniformly.

Question 72

Decorator

Answer 72

Add additional responsibilities dynamically to an object.

Question 73

Flyweight

Answer 73

Use sharing to support a large number of objects that have part of their internal state in common where the other part of state can vary.

Question 74

Memento

Answer 74

Capture the internal state of an object without violating encapsulation and thus providing a mean for restoring the object into initial state when needed.

Question 75

Proxy

Answer 75

> Provide a surrogate or placeholder for another object to control access to it

Question 76

Coupling Types

Answer 76

> Internal coupling | > External coupling

Question 77

Internal Coupling

Answer 77

Coupling within a subsystem - the amount of relationships between classes in the system

Question 78

External coupling

Answer 78

Coupling between subsystems

Question 79

Design Pattern

Answer 79

Template best practice solution for a particular situation

Question 80

Why design patterns are important?

Answer 80

1) Encourages best practice 2) Learning tool for new software developers 3) Communication tool between developers, making developing faster and easier

Question 81

Unified Process

Answer 81

An approach to developing business application software using agile techniques and concepts yet still being linear and having somewhat waterfall model timeline.