Object-Oriented Software Engineering: An Agile Unified Methodology by David Kung
A design class diagram (DCD) is a UML class diagram derived from behavioral models and the domain model.
It serves as a blueprint for test-driven development, integration testing, and maintenance.
Package diagrams help organize and manage classes in large DCDs.
Requirements Acquisition
Business goals and needs.
Current situation and preliminary requirements.
Iterative Phase Activities
Actor-System Interaction Modeling.
Domain Modeling.
Outputs
Expanded use cases, UI design.
Behavior models and design class diagrams.
DCD is a structural diagram showing classes, attributes, operations, and their relationships.
May include design patterns.
Basis for implementation and testing; derived from domain model and sequence diagrams.
DCD is derived from:
Domain Model (DM): Provides classes, attributes, and relationships.
Sequence Diagrams: Determines classes, methods, and relationships.
Includes design classes (controller, command, GUI) and application classes.
Identify all classes from sequence diagrams:
Classes sending or receiving messages.
Classes passed as parameters or return types.
Example Classes: Checkout GUI
, DBMgr
, User
, Document
, Loan
, CheckoutController
Focus on how objects interact with messages.
List of Classes:
User
Document
Loan
CheckoutGUI
DBMgr
CheckoutController
Identify methods for each class from sequence diagrams:
Methods indicated by messages on incoming edges of objects.
Details about parameters and return types obtained from the sequence diagram.
Example Methods to Identify:
Checkout GUI
and DBMgr
example calls.
Methods example:
getUser(uid)
getDocument(callNo)
saveLoan(loan)
checkout(uid, cnList)
Identify and fill in attributes:
Attributes have scalar types, used to get objects.
Found in getX()
and setX(...)
methods or domain model.
Example Attributes for User
, Document
, etc.
Example Attributes Specification:
uid: String
callNum: String
isAvailable: boolean
Identify relationships:
An arrow indicates a call and a dependence relationship.
Parameters or return types indicate association or uses relationship.
Example relationships obtained from sequence diagrams.
Indicate relationships with classes in DCD, including dependencies.
Example of a Checkout GUI
implementation derived from sequence diagrams.
Value working software over comprehensive documentation.
Good enough is enough.
Title change to: Applying Responsibility Assignment Patterns.
Design patterns are proven solutions to design problems.
Patterns like controller, expert, and creator are widely applicable.
Emphasizing methodologies and requirements acquisition.
Improve communication and empower less experienced developers.
Improve maintenance of software systems.
Design Problem: Ensuring a single globally accessible instance.
public class Catalog { ... }
UML representation of the Singleton Pattern in design.
Specify benefits, liabilities, and trade-offs of a pattern.
Focus on improving software maintainability and efficiency.
GRASP and Gang of Four Patterns.
List: Expert, Creator, Controller, etc.
Types: Creational, Structural, and Behavioral Patterns.
Creational, Structural, and Behavioral patterns annotated.
Evaluate designs and apply GRASP patterns to improve design.
Importance of managing object responsibilities.
Tight coupling and unclear responsibility assignments.
Recommendations for reducing coupling and improving designs.
Importance of assigning responsibilities to controller classes.
Defines actor interactions in the business object layer.
Use Case, Role, and Facade Controllers defined.
Guidelines for choosing controller implementations based on context.
Each use case having a dedicated controller for clarity.
Separation of concerns, high cohesion, and reduced coupling.
Challenges related to bloated controllers and design complexities.
Symptoms and impacts of poorly designed controllers.
Strategies for rectifying bloated controller designs.
Complete the sequence diagram for the "Checkout Document" use case.
Processes that the controller should handle.
Common mistakes in assigning responsibilities.
Highlighting the flaws of a procedural programming mindset in design.
Responsibilities should align with the information expert.
Ensures request handling aligns with relevant object attributes.
Provides guidelines for assigning responsibilities during interactions.
Update on how it fits within object interaction design.
Advantages include low coupling and high cohesion.
Design a sequence diagram for user interactions in resetting a password.
Misassignments in object responsibilities.
Highlighting improper design methodologies.
Object attributes in context of requests being processed.
Introduction focused on responsibility for object creation.
Guidelines for choosing creators based on association.
Questions about who should create various objects.
Discussing the advantage of low coupling in design.
Overview of Object Interaction Modeling domain.
Helps develop understanding of business processes.
Steps from requirements gathering to design outputs.
Distinguishing between foreground and background processing.
Importance of object interaction modeling and scenario descriptions.
Collect information.
Describe scenarios. ...
Nontrivial steps and identifying scenarios.
Guidelines for distinguishing trivial vs nontrivial steps.
Analysis of user interactions in a library system.
Understanding structure and utility of scenario tables.
Steps detailed in message interaction flows.
Tips for effective scenario writing and diagramming.
Definitions for notations used in sequence diagrams.
Methodologies for translating scenarios.
How interactions are processed and represented.
Further elaboration on notation usage.
Distinct scenarios and their processing meanings.
Elaborates how to document similar subjects.
Clarifying boundaries in modeling and decision-making.
Real-world object interactions highlighted in the library system.
Example interactions showcasing analysis techniques.
Transitioning from analysis diagrams to design representations.
Detailed explanation of sequence execution flow.
Visualizing current operations within a library system.
Distinctions between analysis and design flow in sequence.
Guidelines for showing instances in design diagrams.
Bridging sequence diagrams and final code execution.
Importance of clarity and accessibility in coding.
Lessons learned from professional analysis.
Observations on execution and function calling in practices.
Clarifying the process order and event triggers.
Importance of structured reviews for model quality assurance.
Encouraging collaborative construction of scenarios and tables.