An edition of Aspect-Oriented Software Development with Use Cases (The Addison-Wesley Object Technology Series)
(2004)
Aspect-Oriented Software Development with Use Cases (The Addison-Wesley Object Technology Series)
by Ivar Jacobson
- 0 Ratings
- 1 Want to read
- 0 Currently reading
- 0 Have read
Share
×Close
Last edited by IdentifierBot
August 12, 2010 | History
Gregor Kiczales said that aspect-oriented programming was wasted on programming languages, and was better used during system design. This book shows how to add aspect-oriented thinking to UML based software design by using aspect-oriented use cases.
Check nearby libraries
Buy this book
Showing 1 featured edition. View all 1 editions?
| Edition | Availability |
|---|---|
1
Aspect-Oriented Software Development with Use Cases (The Addison-Wesley Object Technology Series)
December 30, 2004, Addison-Wesley Professional
Paperback
in English
0321268881 9780321268884
|
aaaa
Libraries near you:
WorldCat
|
Book Details
First Sentence
"In Part I, we build the case for use cases and aspects—why we need use cases, why we need aspects, and how the two compliment each other."
Table of Contents
Preface
Page xvii
Acknowledgements
Page xxxi
I.
The Case for Use Cases and Aspects
Page 1
1.
Problem to Attack
Page 3
1.1.
The Use of Components Today
Page 3
1.1.1.
Building a System with Components
Page 4
1.1.2.
Benefits of Components
Page 6
1.2.
Limitation of Components
Page 6
1.2.1.
Inability to Keep Peers Separate
Page 8
1.2.2.
Inability to Keep Extensions Separate
Page 9
1.3.
Approaching a Solution
Page 11
1.3.1.
Early Support for Extensions
Page 12
1.3.2.
Support for Extensions in UML
Page 15
1.4.
Keeping Concerns Separate
Page 16
2.
Attacking the Problem with Aspects
Page 17
2.1.
Aproaching a Solution with Aspects
Page 17
2.2.
Keeping Peers Separate with Aspects
Page 19
2.3.
Keeping Extensions Separate with Aspects
Page 21
2.4.
Need for Methodological Guidance
Page 26
3.
Today with Use Cases
Page 29
3.1.
Use Cases in Brief
Page 29
3.2.
Use-Case-Driven Development
Page 32
3.3.
Roles and Benefits of Use Cases
Page 34
3.4.
Gaps in the Use-Case Technique
Page 34
3.5.
Bridging the Gaps with Aspects
Page 35
4.
Tomorrow with Use-Case Modules
Page 37
4.1.
Buliding Systems in Overlays with Use-Case Slices
Page 38
4.2.
Keeping Peer Use Cases Separate
Page 40
4.3.
Keeping Extension Use Cases Separate
Page 42
4.4.
Developing with Use-Case Modules
Page 45
II.
Modeling and Capturing Concerns with Use Cases
Page 49
5.
Modeling Concerns with Use Cases
Page 51
5.1.
Use-Case Modeling
Page 51
5.2.
Use-Case Instances and Flows of Events
Page 53
5.3.
Describing Use Cases
Page 54
5.4.
Visualizing Use-Case Flows
Page 57
5.5.
Summary and Highlights
Page 60
6.
Structuring Use Cases
Page 61
6.1.
Use-Case Relationships
Page 61
6.2.
Use-Case Extend Relationship
Page 63
6.3.
Use-Case Include Relationship
Page 70
6.4.
Use-Case Generalization
Page 73
6.5.
Utility Use Cases
Page 77
6.6.
Summary and Highlights
Page 79
7.
Capturing Concerns with Use Cases
Page 81
7.1.
Understanding Stakeholder Concerns
Page 81
7.1.1.
Understanding the Problem Doain
Page 82
7.1.2.
Eliciting System Features
Page 83
7.1.3.
Dealing with Functional and Nonfunctional Requirements
Page 84
7.2.
Capturing Application Use Cases
Page 86
7.2.1.
Identifying Use-Case Variability
Page 87
7.2.2.
Handling Use-Case Variability
Page 88
7.2.3.
Dealing with Extension Use Cases
Page 91
7.3.
Capturing Infrastructure Use Cases
Page 93
7.3.1.
The Perform Transaction Use Case
Page 94
7.3.2.
Structuring Infrastructure Uses Cases
Page 96
7.3.3.
Describing Infrastructure Use Cases
Page 98
7.3.4.
Dealing with Systemwide Concerns
Page 100
7.4.
Summary and Highlights
Page 101
III.
Keeping Concerns Separate with Use-Case Modules
Page 103
8.
Keeping Peer Use-Case Realizations Separate with Aspects
Page 105
8.1.
Realizing Peer Use Cases
Page 106
8.1.1.
Collaborations
Page 106
8.1.2.
Realizing a Use Case
Page 108
8.1.3.
Overlap between Peer Use-Case Realizations
Page 110
8.2.
Keeping Use-Case Specifics Separate
Page 111
8.2.1.
Composing Use-Case-Specific Classes
Page 113
8.2.2.
Composing Use-Case-Specific Class Extension
Page 115
8.2.3.
Collaborations in Use-Case Slices
Page 117
8.3.
Dealing with Overlap
Page 118
8.3.1.
Included Use-Case Slice
Page 119
8.3.2.
Generalized Use-Case Slice
Page 121
8.3.3.
Non-Use-Case-Specific Slice
Page 123
8.4.
Summary and Highlights
Page 125
9.
Keeping Extensions Separate with Pointcuts
Page 127
9.1.
Realizing Extension Use Cases
Page 128
9.2.
Keeping Modularity of Extension Use-Case Realizations
Page 129
9.2.1.
Operation Extensions
Page 130
9.2.2.
Pointcuts
Page 133
9.3.
Parameterizing Pointcuts
Page 135
9.3.1.
Identifying Parameters
Page 136
9.3.2.
Defining Parameters
Page 137
9.3.3.
Parameterizing Pointcuts in AOP
Page 138
9.4.
Generalizing Extension Use-Case Realizations
Page 139
9.5.
Templating Use-Case Slices
Page 142
9.6.
Summary and Highlights
Page 144
10.
Building Systems with Use-Case Modules
Page 145
10.1.
A System Comprises Models
Page 146
10.2.
Use-Case Model
Page 147
10.3.
Analysis Model
Page 148
10.3.1.
Language of Analysis
Page 149
10.3.2.
Conducting Analysis
Page 150
10.4.
Design and Implementation Models
Page 152
10.4.1.
Language of Design and Implementation
Page 152
10.4.2.
Conducting Design and Implementation
Page 154
10.5.
Use-Case Modules Cut Across Models
Page 154
10.5.1.
Preserving the Structure of the Use-Case Model
Page 155
10.5.2.
A Use-Case Module Contains Use-Case Slices
Page 157
10.5.3.
Use-Case Module Relationships
Page 158
10.6.
Composing and Configuring Use-Case Modules
Page 159
10.7.
Summary and Highlights
Page 161
IV.
Establishing an Architecture Based on Use Cases and Aspects
Page 163
11.
Road to a Resilient Architecture
Page 167
11.1.
What Is Architecture?
Page 168
11.2.
What Is a Good Architecture?
Page 168
11.3.
Steps to Establish an Architecture Baseline
Page 170
11.4.
Begin with a Platform-Independent Structure
Page 174
11.4.1.
Element Structure
Page 174
11.4.2.
Use-Case Structure
Page 177
11.5.
Overlay Platform Specifics on Top
Page 179
11.5.1.
Choosing the Platform
Page 179
11.5.2.
Keeping Platform Specifics Separate
Page 181
11.6.
Summary and Highlights
Page 184
12.
Separating Functional Requirements with Application Peer Use Cases
Page 187
12.1.
Analyzing Application Use Cases
Page 188
12.1.1.
Identifyinhg Classes
Page 189
12.1.2.
Allocating Use-Case Behavior to Classes
Page 190
12.2.
Keeping Application Use Cases Separate
Page 195
12.2.1.
Element Structure
Page 195
12.2.2.
Use-Case Structure
Page 196
12.3.
Designing Application Use Cases
Page 199
12.3.1.
Identifying Design Elements
Page 200
12.3.2.
Identifying Components and Interfaces
Page 203
12.4.
Refining Design Elements
Page 205
12.4.1.
Keeping Class Extensions Separate
Page 205
12.4.2.
Keeping Operation Extensions Separate
Page 207
12.4.3.
Keeping StateTransitions Separate
Page 209
12.5.
Summary and Highlights
Page 211
13.
Separating Functional Requirements with Application-Extension Use Cases
Page 213
13.1.
Analyzing Application-Extension Use Cases
Page 214
13.1.1.
Identifying Classes
Page 215
13.1.2.
Identifying Pointcuts
Page 216
13.1.3.
Allocating Use-Case Behavior to Classes
Page 218
13.2.
Keeping Application-Extension Use Cases Separate
Page 220
13.2.1.
Structuring Alternate Flows
Page 221
13.2.2.
Keeping Alternate Flows Separate
Page 222
13.3.
Designing Application-Extension Use Cases
Page 224
13.3.1.
Designing Operation Extensions
Page 224
13.3.2.
Identifying Component Interfaces from Use-Case Extensions
Page 225
13.3.3.
Dealing with Multiple Extensions to a Use Case
Page 226
13.3.4.
Extending Multiple Use Cases
Page 229
13.4.
Dealing with Changes in the Base
Page 230
13.4.1.
Applying Reflection
Page 232
13.4.2.
Applying Design Patterns
Page 232
13.4.3.
Applying Adaptive Programming
Page 235
13.5.
Summary and Highlights
Page 236
14.
Separating Nonfunctional Requirements with Infrastructure Use Cases
Page 239
14.1.
Analyzin an Infrastructure Use Case
Page 240
14.1.1.
Identifying Classes
Page 241
14.1.2.
Identifying Pointcuts
Page 242
14.1.3.
Allocating Use-Case Behavior to Classes
Page 245
14.2.
Keeping Infrastructure Use Cases Separate
Page 247
14.3.
Designing Infrastructure Use Cases
Page 250
14.3.1.
Applying the Infrastrucure Use-Case Slice with Aspects
Page 251
14.3.2.
Applying the Infrastructure Use-Case Slice with Filters
Page 252
14.3.3.
Identifying Components in the Infrastructure Layer
Page 255
14.4.
Dealing with Multiple Infrastructure Use Cases
Page 256
14.5.
Summary and Highlights
Page 261
15.
Separating Platform Specifics with Platform-Specific Use-Case Slices
Page 263
15.1.
Keeping Platform Specifics Separate
Page 264
15.1.1.
Three-Tier Systems
Page 264
15.1.2.
Tier Packages
Page 266
15.1.3.
Modeling Tiers with Infrastructure Use Cases
Page 268
15.2.
Overlaying User Interfaces
Page 269
15.2.1.
Minimal Use-Case Design without Presentation Specifics
Page 270
15.2.2.
A Web Presentation Mechanism in J2EE
Page 271
15.2.3.
Designing the Presentatioh Mechanism
Page 273
15.2.4.
Applying the Presentation Mechanism
Page 275
15.3.
Overlaying Persistency
Page 276
15.3.1.
Minimal Use-Case Design without Distribution
Page 277
15.3.2.
An EJB Distribution Mechanism
Page 278
15.3.3.
Designing the Distribution Mechanism
Page 281
15.3.4.
Applying the Persistency Mechanism
Page 297
15.4.
Preserving the Use-Case Structure
Page 290
15.4.1.
Minimal Use-Case Design without Persistence
Page 291
15.4.2.
A Relational Persistency Mechanism in J2EE
Page 292
15.4.3.
Designing Persistency Mechanism
Page 293
15.4.4.
Applying the Persistency Mechanism
Page 297
15.5.
Preserving the Use-Case Structure
Page 298
15.6.
Summary and Highlights
Page 299
16.
SSeparating Tests with Use-Case Test Slices
Page 301
16.1.
Test-First Approach
Page 301
16.2.
Identifying Test Cases from Use Cases
Page 303
16.2.1.
Identifying Test Cases from Use-Case Flows
Page 204
16.2.2.
Identifying Test Cases from Use-Case Variables
Page 305
16.2.3.
Identifying Test Cases across Multiple Application Use Cases
Page 306
16.2.4.
Identifying Test Cases for the Infrastructure and the Platform Specifics
Page 306
16.2.5.
Identifying Performance Test Cases
Page 307
16.3.
Identifying Elements to Be Tested
Page 308
16.4.
Designing and Implementing Tests
Page 310
16.4.1.
Designing a Test Infrastructure
Page 312
16.4.2.
Designing a Test Case
Page 316
16.5.
Summary and Highlights
Page 317
17.
Evaluating the Architecture
Page 319
17.1.
Putting It Together
Page 319
17.2.
Evaluating Separation of Concerns
Page 324
17.2.1.
Evaluating Design Elemnts
Page 325
17.2.2.
Evaluating Design Packages
Page 325
17.2.3.
Evaluating Use-Case Structures
Page 327
17.2.4.
Automating the Evaluation
Page 329
17.2.5.
Enforcing the Separation of Concerns
Page 330
17.3.
Evaluating and Achieving Systemwide Concerns
Page 332
17.3.1.
Evaluating and Achieving Maintainability
Page 332
17.3.2.
Evaluating and Achieving Extensibility
Page 332
17.3.3.
Evaluating and Achieving Portability
Page 333
17.3.4.
Evaluating and Achieving Reusability
Page 334
17.3.5.
Evaluating and Achieving Performance and Reliability
Page 334
17.4.
Summary and Highlights
Page 336
18.
Describing the Architecture
Page 339
18.1.
Architecture Description Comprises Architectural Views
Page 340
18.2.
Architectural View of the Use-Case Model
Page 342
18.3.
Architectural View of the Analysis Model
Page 344
18.3.1.
Arcitecturally Significant Analysis Elements
Page 344
18.3.2.
Architecturally Significant Use-Case Analysis Slices
Page 346
18.4.
Architectural View of the Design Model
Page 347
18.4.1.
Architecturally Significant Deployment Elements
Page 348
18.4.2.
Architecturally Significant Process Elements
Page 348
18.4.3.
Architecturally Significant Design Elements
Page 349
18.4.4.
Architecturally Significant Use-Case Design Slices
Page 351
18.5.
Summary and Highlights
Page 352
V.
Applying Use Cases and Aspects in a Project
Page 355
19.
Running a Project
Page 357
19.1.
Iterative Development
Page 357
19.1.1.
Phases in a Project
Page 358
19.1.2.
Activities in an Iteration
Page 359
19.2.
Estimating Development Effort
Page 395
19.2.1.
Estimation at the Beginning of a Project
Page 360
19.2.2.
Refining the Estimates
Page 362
19.3.
Planning and Controlling the Project
Page 363
19.3.1.
Estimating Project Delays
Page 363
19.3.2.
Keeping the Project on Track
Page 364
19.4.
Productivity Gains by Keeping Concerns Separate
Page 365
19.5.
Summary and Highlights
Page 367
20.
Tailoring the Approach
Page 369
20.1.
Achieving the Right Balance
Page 369
20.2.
Selecting Disciplines to Apply
Page 370
20.3.
Adopting at Different Phases of a Project
Page 373
20.4.
Summary and Highlights
Page 374
21.
Aspects and Beyond
Page 375
21.1.
Building a System in Extensions
Page 375
21.2.
Balancing Best Practices
Page 376
21.3.
The Road Ahead
Page 377
A.
Modeling Aspects and Use-Case Slices in UML
Page 379
A.1.
Modeling Intertype Declarations with Class Extensions
Page 380
A.2.
Modeling Advices with Operation Extensions
Page 381
A.3.
Modeling Pointcuts
Page 383
A.4.
Modeling Use-Case Slices
Page 384
B.
Notation Guide
Page 387
B.1.
Package
Page 387
B.2.
Actors and Use Cases
Page 388
B.3.
Classes and Instances
Page 389
B.4.
Components and Interfaces
Page 391
B.5.
Processes and Nodes
Page 392
References
Page 395
Glossary
Page 399
Index
Page 407
The Physical Object
ID Numbers
Community Reviews (0)
Feedback?
History
- Created April 30, 2008
- 32 revisions
Wikipedia citation
×CloseCopy and paste this code into your Wikipedia page. Need help?
| August 12, 2010 | Edited by IdentifierBot | added LibraryThing ID |
| April 24, 2010 | Edited by Open Library Bot | Fixed duplicate goodreads IDs. |
| April 16, 2010 | Edited by bgimpertBot | Added goodreads ID. |
| April 14, 2010 | Edited by Open Library Bot | Linked existing covers to the edition. |
| April 30, 2008 | Created by an anonymous user | Imported from amazon.com record. |