book

Aspect-Oriented Software Development with Use Cases

Name: Aspect-Oriented Software Development with Use Cases
ISBN: 0321268881

by Ivar Jacobson, Pan-Wei Ng

December 2004

Intermediate to advanced

464 pages

9h 39m

English

Addison-Wesley Professional

Read now

Unlock full access

Copyright
Praise for Aspect-Oriented Software Development with Use Cases
The Addison-Wesley Object Technology SeriesThe Component Software Series
Preface
What Is Aspect-Oriented Programming?What Is Aspect-Oriented Software Development?AOSD with Use CasesWhat This Book IsWhat This Book Is NotWhat You Need Before Reading This BookHow to Read This BookPart I, The Case for Use Cases and AspectsPart II, Modeling and Capturing Concerns with Use CasesPart III, Keeping Concerns Separate with Use Case ModulesPart IV, Establishing an Architecture Based on Use Cases and AspectsPart V, Applying Use Cases and Aspects in a ProjectHow This Book Came AboutIn the Beginning By IvarWorking Together By Pan-Wei
Acknowledgments
I. The Case for Use Cases and Aspects
1. Problem to Attack
1.1. The Use of Components Today1.1.1. Building a System with Components1.1.2. Benefits of Components1.2. Limitation of Components1.2.1. Inability to Keep Peers SeparateTanglingScattering1.2.2. Inability to Keep Extensions Separate1.3. Approaching a SolutionConcern Separation TechniqueConcern Composition Mechanism1.3.1. Early Support for Extensions1.3.2. Support for Extensions in UML1.4. Keeping Concerns Separate
2. Attacking the Problem with Aspects
2.1. Approaching a Solution with Aspects2.2. Keeping Peers Separate with Aspects2.3. Keeping Extensions Separate with AspectsHandle Waiting ListCheck Authorization2.4. Need for Methodological Guidance
3. Today with Use Cases
3.1. Use Cases in Brief3.2. Use-Case-Driven Development3.3. Roles and Benefits of Use Cases3.4. Gaps in the Use-Case Technique3.5. Bridging the Gaps with Aspects
4. Tomorrow with Use-Case Modules
4.1. Building Systems in Overlays with Use-Case Slices4.2. Keeping Peer Use Cases Separate4.3. Keeping Extension Use Cases SeparateExtension Points in UMLJoin Points and Pointcuts in AOP4.4. Developing with Use-Case ModulesParallel Development with Use-Case ModulesDevelop Incrementally with Use-Case ModulesArchitecture Unifies Use-Case Modules
II. Modeling and Capturing Concerns with Use Cases

5. Modeling Concerns with Use Cases
5.1. Use-Case Modeling5.2. Use-Case Instances and Flows of Events5.3. Describing Use CasesMultiple Basic FlowsReferencing Subflows5.4. Visualizing Use-Case Flows5.5. Summary and Highlights
6. Structuring Use Cases
6.1. Use-Case Relationships6.2. Use-Case Extend RelationshipExtension PointsExtension PointcutsExtension Flow DeclarationExtension Pointcut6.3. Use-Case Include RelationshipInclusions and Extensions6.4. Use-Case GeneralizationGeneralization and ExtensionsGeneralizations and Inclusions6.5. Utility Use Cases6.6. Summary and Highlights
7. Capturing Concerns with Use Cases
7.1. Understanding Stakeholder Concerns7.1.1. Understanding the Problem Domain7.1.2. Eliciting System Features7.1.3. Dealing with Functional and Nonfunctional Requirements7.2. Capturing Application Use Cases7.2.1. Identifying Use-Case Variability7.2.2. Handling Use-Case Variability7.2.3. Dealing with Extension Use Cases7.3. Capturing Infrastructure Use Cases7.3.1. The Perform Transaction Use Case7.3.2. Structuring Infrastructure Use Cases7.3.3. Describing Infrastructure Use Cases7.3.4. Dealing with Systemwide Concerns7.4. Summary and Highlights
III. Keeping Concerns Separate with Use-Case Modules
8. Keeping Peer Use-Case Realizations Separate with Aspects
8.1. Realizing Peer Use Cases8.1.1. Collaborations8.1.2. Realizing a Use Case8.1.3. Overlap between Peer Use-Case Realizations8.2. Keeping Use-Case Specifics Separate8.2.1. Composing Use-Case-Specific Classes8.2.2. Composing Use-Case-Specific Class Extensions8.2.3. Collaborations in Use-Case Slices8.3. Dealing with Overlap8.3.1. Included Use-Case SliceCollaborationsClassesExtensions8.3.2. Generalized Use-Case SliceCollaborationClassesFeatures8.3.3. Non-Use-Case-Specific Slice8.4. Summary and Highlights
9. Keeping Extensions Separate with Pointcuts
9.1. Realizing Extension Use Cases9.2. Keeping Modularity of Extension Use-Case Realizations9.2.1. Operation ExtensionsStructural and Behavioral ContextOperation Extension Declaration9.2.2. Pointcuts9.3. Parameterizing Pointcuts9.3.1. Identifying Parameters9.3.2. Defining Parameters9.3.3. Parameterizing Pointcuts in AOP9.4. Generalizing Extension Use-Case Realizations9.5. Templating Use-Case Slices9.6. Summary and Highlights
10. Building Systems with Use-Case Modules
10.1. A System Comprises Models10.2. Use-Case Model10.3. Analysis Model10.3.1. Language of AnalysisBoundaryControlEntity10.3.2. Conducting Analysis10.4. Design and Implementation Models10.4.1. Language of Design and Implementation10.4.2. Conducting Design and Implementation10.5. Use-Case Modules Cut Across Models10.5.1. Preserving the Structure of the Use-Case Model10.5.2. A Use-Case Module Contains Use-Case Slices10.5.3. Use-Case Module Relationships10.6. Composing and Configuring Use-Case Modules10.7. Summary and Highlights
IV. Establishing an Architecture Based on Use Cases and Aspects
11. Road to a Resilient Architecture
11.1. What Is Architecture?11.2. What Is a Good Architecture?Separating Functional RequirementsSeparating Nonfunctional from Functional RequirementsSeparating Platform SpecificsSeparating Tests from the Units Being Tested11.3. Steps to Establish an Architecture BaselineArchitecture BaselineUse Cases Drive the Architecture BaselineEstablish the Architecture Baseline Iteratively11.4. Begin with a Platform-Independent Structure11.4.1. Element StructureLayersApplication LayerDomain layer11.4.2. Use-Case Structure11.5. Overlay Platform Specifics on Top11.5.1. Choosing the Platform11.5.2. Keeping Platform Specifics Separate11.6. Summary and Highlights
12. Separating Functional Requirements with Application Peer Use Cases
12.1. Analyzing Application Use Cases12.1.1. Identifying Classes12.1.2. Allocating Use-Case Behavior to ClassesUsing a Communication DiagramInteraction DiagramClass DiagramsAnalyzing Multiple Use Cases12.2. Keeping Application Use Cases Separate12.2.1. Element Structure12.2.2. Use-Case StructureNon-Use-Case-Specific SlicesUse-Case Slices12.3. Designing Application Use Cases12.3.1. Identifying Design ElementsIdentifying Design Elements from Analysis ElementsNew Design Elements12.3.2. Identifying Components and Interfaces12.4. Refining Design Elements12.4.1. Keeping Class Extensions SeparateIgnoreAspectControl ClassAdapter Class12.4.2. Keeping Operation Extensions SeparateSummationSelection12.4.3. Keeping State Transitions Separate12.5. Summary and Highlights
13. Separating Functional Requirements with Application-Extension Use Cases
13.1. Analyzing Application-Extension Use Cases13.1.1. Identifying Classes13.1.2. Identifying PointcutsIdentifying the Structural ContextRoom.updateAvailabilityOperations in Reserve Room Handler and Reserve Room Form13.1.3. Allocating Use-Case Behavior to ClassesBehavioral ContextDescribe Class Responsibilities13.2. Keeping Application-Extension Use Cases Separate13.2.1. Structuring Alternate Flows13.2.2. Keeping Alternate Flows Separate13.3. Designing Application-Extension Use Cases13.3.1. Designing Operation Extensions13.3.2. Identifying Component Interfaces from Use-Case Extensions13.3.3. Dealing with Multiple Extensions to a Use Case13.3.4. Extending Multiple Use Cases13.4. Dealing with Changes in the Base13.4.1. Applying Reflection13.4.2. Applying Design Patterns13.4.3. Applying Adaptive Programming13.5. Summary and Highlights
14. Separating Nonfunctional Requirements with Infrastructure Use Cases
14.1. Analyzing an Infrastructure Use Case14.1.1. Identifying Classes14.1.2. Identifying PointcutsOperation ExtensionStructural ContextBehavioral Context14.1.3. Allocating Use-Case Behavior to ClassesDescribing Class Responsibilities14.2. Keeping Infrastructure Use Cases SeparateRefining the Element StructureKeeping Infrastructure Separate in Use-Case Slices14.3. Designing Infrastructure Use Cases14.3.1. Applying the Infrastructure Use-Case Slice with Aspects14.3.2. Applying the Infrastructure Use-Case Slice with Filters14.3.3. Identifying Components in the Infrastructure Layer14.4. Dealing with Multiple Infrastructure Use CasesMultiple Extensions at a Single Execution PointExtension of ExtensionSeparate ExtensionsHandling Variations in the Application Use Cases14.5. Summary and Highlights
15. Separating Platform Specifics with Platform-Specific Use-Case Slices
15.1. Keeping Platform Specifics Separate15.1.1. Three-Tier SystemsPresentation TierBusiness TierIntegration Tier15.1.2. Tier Packages15.1.3. Modeling Tiers with Infrastructure Use Cases15.2. Overlaying User Interfaces15.2.1. Minimal Use-Case Design without Presentation Specifics15.2.2. A Web Presentation Mechanism in J2EE15.2.3. Designing the Presentation MechanismMinimal Use-Case Design SlicePresentation SliceUse-Case Presentation Slice15.2.4. Applying the Presentation Mechanism15.3. Overlaying Distribution15.3.1. Minimal Use-Case Design without Distribution15.3.2. An EJB Distribution MechanismCreating an Instance of 〈BusinessService〉Making a Call to a 〈BusinessService〉 Instance15.3.3. Designing the Distribution MechanismMinimal Use-Case Design SliceDistribution SliceUse-case Distribution Slice15.3.4. Applying the Distribution Mechanism15.4. Overlaying Persistency15.4.1. Minimal Use-Case Design without Persistence15.4.2. A Relational Persistency Mechanism in J2EE15.4.3. Designing Persistency MechanismMinimal Use-Case Design SliceEntity-Persistence SlicePersistence SliceUse-Case Persistence Slice15.4.4. Applying the Persistency Mechanism15.5. Preserving the Use-Case Structure15.6. Summary and Highlights
16. Separating Tests with Use-Case Test Slices
16.1. Test-First Approach16.2. Identifying Test Cases from Use Cases16.2.1. Identifying Test Cases from Use-Case Flows16.2.2. Identifying Test Cases from Use-Case Variables16.2.3. Identifying Test Cases across Multiple Application Use Cases16.2.4. Identifying Test Cases for the Infrastructure and the Platform Specifics16.2.5. Identifying Performance Test Cases16.3. Identifying Elements to Be Tested16.4. Designing and Implementing TestsControlInstrumentation16.4.1. Designing a Test InfrastructureUse-Case Design SliceTest Infrastructure SliceTest-Case Slice16.4.2. Designing a Test Case16.5. Summary and Highlights
17. Evaluating the Architecture
17.1. Putting It TogetherApplication Peer Use Cases (Chapter 12, “Separating Functional Requirements with Application Peer Use Cases”)Application-Extension Use Cases (Chapter 13, “Separating Functional Requirements with Application-Extension Use Cases”)Infrastructure Use Cases (Chapter 14, “Separating Nonfunctional Requirements with Infrastructure Use Cases”)Platform-Specific Extension Use Case (Chapter 15, “Separating Platform Specifics with Platform-Specific Use-Case Slices”)Test Cases (Chapter 16, “Separating Tests with Use-Case Test Slices”)17.2. Evaluating Separation of Concerns17.2.1. Evaluating Design Elements17.2.2. Evaluating Design Packages17.2.3. Evaluating Use-Case Structures17.2.4. Automating the Evaluation17.2.5. Enforcing the Separation of Concerns17.3. Evaluating and Achieving Systemwide Concerns17.3.1. Evaluating and Achieving Maintainability17.3.2. Evaluating and Achieving Extensibility17.3.3. Evaluating and Achieving Portability17.3.4. Evaluating and Achieving Reusability17.3.5. Evaluating and Achieving Performance and Reliability17.4. Summary and Highlights
18. Describing the Architecture
18.1. Architecture Description Comprises Architectural Views18.2. Architectural View of the Use-Case Model18.3. Architectural View of the Analysis Model18.3.1. Architecturally Significant Analysis Elements18.3.2. Architecturally Significant Use-Case Analysis Slices18.4. Architectural View of the Design Model18.4.1. Architecturally Significant Deployment Elements18.4.2. Architecturally Significant Process Elements18.4.3. Architecturally Significant Design Elements18.4.4. Architecturally Significant Use-Case Design Slices18.5. Summary and Highlights
V. Applying Use Cases and Aspects in a Project
19. Running a Project
19.1. Iterative Development19.1.1. Phases in a Project19.1.2. Activities in an Iteration19.2. Estimating Development Effort19.2.1. Estimation at the Beginning of a Project19.2.2. Refining the Estimates19.3. Planning and Controlling the Project19.3.1. Estimating Project Delays19.3.2. Keeping the Project on Track19.4. Productivity Gains by Keeping Concerns Separate19.5. Summary and Highlights
20. Tailoring the Approach
20.1. Achieving the Right Balance20.2. Selecting Disciplines to ApplyUse-Case Modeling and AnalysisDesign and ImplementationTesting20.3. Adopting at Different Phases of a Project20.4. Summary and Highlights
21. Aspects and Beyond
21.1. Building a System in Extensions21.2. Balancing Best PracticesUse-Case-DrivenArchitecture-CentricTailoring the ApproachDevelop Iteratively21.3. The Road Ahead
A. Modeling Aspects and Use-Case Slices in UML
A.1. Modeling Intertype Declarations with Class ExtensionsOverlay SemanticsAspectJ MappingA.2. Modeling Advices with Operation ExtensionsOverlay SemanticsAspectJ MappingA.2.1. Semantics of Before and AfterA.2.2. Semantics of AroundA.3. Modeling PointcutsOverlay SemanticsAspectJ MappingA.4. Modeling Use-Case Slices
B. Notation Guide
B.1. PackageNotationUsageLayersTier PackagesModelRelationships Between PackagesB.2. Actors and Use CasesNotationUsageRelationships Between Use CasesB.3. Classes and InstancesNotationUsageRelationships Between ClassesB.4. Components and InterfacesNotationUsageB.5 Processes and NodesNotationUsage
References
Glossary

Content preview from Aspect-Oriented Software Development with Use Cases

Chapter 10. Building Systems with Use-Case Modules

Software development is about building models. You begin with the use-case model to capture stakeholder concerns; you refine the use-case model into an analysis model, which also formulates a high-level overview of the system; you strategize how the system will run on the execution platform with the design model, and in the implementation model, you have the actual codes and binaries. However, you do not build a system model by model. Instead, you do so use case by use case. You take each use case and refine and realize it progressively through the various models. When you complete the work on a use case, you deliver all artifacts associated with the use case in a single package—we call this a ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Eclipse AspectJ: Aspect-Oriented Programming with AspectJ and the Eclipse AspectJ Development Tools

Publisher Resources

ISBN: 0321268881Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Aspect-Oriented Software Development with Use Cases

by Ivar Jacobson, Pan-Wei Ng

Chapter 10. Building Systems with Use-Case Modules

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.