Applying UML and patterns : an introduction to object-oriented analysis and design and iterative...

foreword

preface.

part i. introduction

1. object-oriented analysis and design

what will you learn? is it useful?

the most important learning goal?

what is analysis and design?

what is object-oriented analysis and design?

a short example

what is the uml?

visual modeling is a good thing

history

recommended resources

2. iterative, evolutionary, and agile

what is the up? are other methods complementary?

what is iterative and evolutionary development?

what about the waterfall lifecycle?

how to do iterative and evolutionary analysis and design?

what is risk-driven and client-driven iterative planning?

what are agile methods and attitudes?

.what is agile modeling?

what is an agile up?

are there other critical up practices?

what are the up phases?

whatare the up disciplines?

how to customize the process? the up development case

you know you didn't understand iterative development or the up when

history

recommended resources

3. case studies

what is and isn't covered in the case studies?

case study strategy: iterative development + iterative learning

case one: the nextgen pos system

case two: the monopoly game system

part ii. inception

4. inception is not the requirements phase

what is inception?

how long is inception?

what artifacts may start in inception?

you know you didn't understand inception when...

how much uml during inception?

5. evolutionary requirements

definition: requirements

evolutionary vs. waterfall requirements

what are skillful means to find requirements?

what are the types and categories of requirements?

how are requirements organized in up artifacts?

does the book contain examples of these artifacts?

recommended resources

6. use cases

example

definition: what are actors, scenarios, and use cases?

use cases and the use-case model

motivation: why use cases?

definition: are use cases functional requirements?

definition: what are three kinds of actors?

notation: what are three common use case formats?

example: process sale, fully dressed style

what do the sections mean?

notation: are there other formats? a two-column variation

guideline: write in an essential ui-free style

guideline: write terse use cases

guideline: write black-box use cases

guideline: take an actor and actor-goal perspective

guideline: how to find use cases

guideline: what tests can help find useful use cases?

applying uml: use case diagrams

applying uml: activity diagrams

motivation: other benefits of use cases? requirements in context

example: monopoly game

process: how to work with use cases in iterative methods?

history

recommended resources

7. other requirements

how complete are these examples?

guideline: should we analyze these thoroughly during inception?

guideline: should these artifacts be at the project website?

nextgen example: (partial) supplementary specification

commentary: supplementary specification

nextgen example: (partial) vision

commentary: vision

nextgen example: a (partial) glossary

commentary: glossary (data dictionary)

nextgen example: business rules (domain rules)

commentary: domain rules

process: evolutionary requirements in iterative methods

recommended resources

part iii. elaboration iteration 1-basics

8. iteration 1-basics

iteration 1 requirements and emphasis: core ooa/d skills

process: inception and elaboration

process: planning the next iteration

9. domain models

example

what is a domain model?

motivation: why create a domain model?

guideline: how to create a domain model?

guideline: how to find conceptual classes?

example: find and draw conceptual classes

guideline: agile modeling-sketching a class diagram

guideline: agile modeling-maintain the model in a tool?

guideline: report objects-include 'receipt' in the model?

guideline: think like a mapmaker; use domain terms

guideline: how to model the unreal world?

guideline: a common mistake with attributes vs. classes

guideline: when to model with 'description' classes?

associations

example: associations in the domain models

attributes

example: attributes in the domain models

conclusion: is the domain model correct?

process: iterative and evolutionary domain modeling

recommended resources

10. system sequence diagrams

example: nextgen ssd

what are system sequence diagrams?

motivation: why draw an ssd?

applying uml: sequence diagrams

what is the relationship between ssds and use cases?

how to name system events and operations?

how to model ssds involving other external systems?

what ssd information to place in the glossary?

example: monopoly ssd

process: iterative and evolutionary ssds

history and recommended resources

11. operation contracts

example

definition: what are the sections of a contract?

definition: what is a system operation?

definition: postconditions

example: enteritem postconditions

guideline: should we update the domain model?

guideline: when are contracts useful?

guideline: how to create and write contracts

example: nextgen pos contracts

example: monopoly contracts

applying uml: operations, contracts, and the ocl

process: operation contracts within the up

history

recommended resources

12. requirements to design-iteratively

iteratively do the right thing, do the thing right

provoking early change

didn't all that analysis and modeling take weeks to do?

13. logical architecture and uml package diagrams

example

what is the logical architecture? and layers?

what layers are the focus in the case studies?

what is software architecture?

applying uml: package diagrams

guideline: design with layers

guideline: the model-view separation principle

what's the connection between ssds, system operations, and layers?

example: nextgen logical architecture and package diagram

example: monopoly logical architecture?

recommended resources

14. on to object design

agile modeling and lightweight uml drawing

uml case tools

how much time spent drawing uml before coding?

designing objects: what are static and dynamic modeling?

the importance of object design skill over uml notation skill

other object design techniques: crc cards

15. uml interaction diagrams

sequence and communication diagrams

novice uml modelers don't pay enough attention to interaction diagrams!

common uml interaction diagram notation

basic sequence diagram notation

basic communication diagram notation

16. uml class diagrams

applying uml: common class diagram notation

definition: design class diagram

definition: classifier

ways to show uml attributes: attribute text and association lines

note symbols: notes, comments, constraints, and method bodies

operations and methods

keywords

stereotypes, profiles, and tags

uml properties and property strings

generalization, abstract classes, abstract operations

dependency

interfaces

composition over aggregation

constraints

qualified association

association class

singleton classes

template classes and interfaces

user-defined compartments

active class

what's the relationship between interaction and class diagrams?

17. grasp: designing objects with responsibilities

uml versus design pinciples..

object design: example inputs, activities, and outputs

responsibilities and responsibility-driven design

grasp: a methodical approach to basic oo design

what's the connection between responsibilities, grasp, and uml diagrams?

what are patterns?

where are we now?

a short example of object design with grasp

applying grasp to object design

creator

information expert (or expert)

low coupling

controller

high cohesion

recommended resources

18. object design exaples with grasp

what is a use case realization?

artifact comments

what's next?

use case realizations for the nextgen iteration

use case realizations for the monopoly iteration

process: iterative and evolutionary object design

summary

19. designing for visibility

visibility between objects

what is visibility?

20. mapping designs to code

programming and iterative, evolutionary development

mapping designs to code

creating class definitions from dcds

creating methods from interaction diagrams

collection classes in code

exceptions and error handling

defining the sale.makelineitem method

order of implementation

test-driven or test-first development

summary of mapping designs to code

introduction to the nextgen pos program solution

introduction to the monopoly program solution

21. test-driven development and refactoring

test-driven development

refactoring

recommended resources

22. uml tools and uml as blueprint

forward, reverse, and round-trip engineering

what is a common repot of valuable features?

what to look for in a tool?

if sketching uml, how to update the diagrams after coding?

recommended resources

part iv. elaboration iteration 2-more patterns

23. iteration 2-more patterns

from iteration 1 to 2

iteration-2 requirements and emphasis: object design and patterns

24. quick analysis update

case study: nextgen pos

case study: monopoly

25. grasp: more objects with responsibilities

polymorphism

pure fabrication

indirection

protected variations

26. applying gof design patterns

adapter (gof)

some grasp principles as a generalization of other patterns

"analysis" discoveries during design: domain model

factory

singleton (gof)

conclusion of the external services with varying interfaces problem

strategy (gof)

composite (gof) and other design principles

facade (gof)

observer/publish-subscribe/delegation event model (gof)

conclusion

recommended resources

part v. elaboration iteration 3-intermediate topics

27. iteration 3-intermediate topics

nextgen pos

monopoly

28. uml activity diagrams and modeling

example

how to apply activity diagrams?

more uml activity diagram notation

guidelines

example: nextgen activity diagram

process: activity diagrams in the up

background

29. uml state machine diagrams and modeling

example

definitions: events, states, and transitions

how to apply state machine diagrams?

more uml state machine diagram notation

example: ui navigation modeling with state machines

example: nextgen use case state machine diagram

process: state machine diagrams in the up

recommended resources

30. relating use cases

the include relationship

terminology: concrete, abstract, base, and addition use cases

the extend relationship

the generalize relationship

use case diagrams

31. domain model refinement

new concepts for the nextgen domain model

generalization

defining conceptual superclasses and subclasses

when to define a conceptual subclass?

when to define a conceptual superclass?

nextgen pos conceptual class hierarchies

abstract conceptual classes

modeling changing states

class hierarchies and inheritance in software

association classes

aggregation and composition

time intervals and product prices-fixing an iteration 1 "error"

association role names

roles as concepts versus roles in associations

derived elements

qualified associations

reflexive associations

using packages to organize the domain model

example: monopoly domain model refinements

32. more ssds and contracts

nextgen pos

33. architectural analysis

process: when do we start architectural analysis?

definition: variation and evolution points

architectural analysis

common steps in architectural analysis

the science: identification and analysis of architectural factors

example: partial nextgen pos architectural factor table

the art: resolution of architectural factors

summary of themes in architectural analysis

process: iterative architecture in the up

recommended resources

34. logical architecture refinement

example: nextgen logical architecture

collaborations with the layers pattern

other layer pattern issues

model-view separation and "upward" communication

recommended resources

35. package design

package organization guidelines

recommended resources

36. more object design with gof patterns

example: nextgen pos

failover to local services; performance with local caching

handling failure

failover to local services with a proxy (gof)

designing for non-functional or quality requirements

accessing external physical devices with adapters

abstract factory (gof) for families of related objects

handling payments with polymorphism and do it myself

example: monopoly

conclusion

37. designing a persistence framework with patterns

the problem: persistent objects

the solution: a persistence service from a persistence framework

frameworks

requirements for the persistence service and framework

key ideas

pattern: representing objects as tables

uml data modeling profile

pattern: object identifier

accessing a persistence service with a facade

mapping objects: database mapper or database broker pattern

framework design with the template method pattern

materialization with the template method pattern

configuring mappers with a mapperfactory

pattern: cache management

consolidating and hiding sql statements in one class

transactional states and the state pattern

designing a transaction with the command pattern

lazy materialization with a virtual proxy

how to represent relationships in tables

persistentobject superclass and separation of concerns

unresolved issues

38. uml deployment and component diagrams

deployment diagrams

component diagrams

39. documenting architecture: uml & the n+1 view model

the sad and its architectural views

notation: the structure of a sad

example: a nextgen pos sad

example: a jakarta struts sad

process: iterative architectural documentation

recommended resources

part vi. special topics

40. more on iterative development and agile project management

how to plan an iteration?

adaptive versus predictive planning

phase and iteration plans

how to plan iterations with use cases and scenarios?

the (in)validity of early estimates

organizing project artifacts

you know you didn't understand iterative planning when...

recommended resources.

bibliography

glossary

index...