(特价书)UML和模式应用（英文影印版）（第三版）

.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...