| Day |
Chapters & Strategies |
Topics |
| 1 |
Overview
|
- Fundamental OO Design Principles
- Fundamental Design Patterns
- GoF Patterns
- Creational Patterns
- Structural Patterns
- Behavioral Patterns
|
| 1 |
Business Concept Modeling (BCM)
The most powerful way to describe an organization's business concepts, rules and policies
This chapter presents how to model any business domain using the
Unified Modeling Language (UML). BCM is a crucial topic for students
to master the various Domain Models and Pattern Class Diagrams
presented in the Design and Implementation chapters of this course.
|
- Overview
- Examples
- Model Elements: Theory, Syntax
- Examples and Exercises for:
- Business Concepts
- Business Concept Relationships
- Inheritance
- Composition
- Association
- Association Role
- Association Class
- BCM Decision Tree
- BCM Practice: an entire Business Domain
- The Composite Pattern
|
| 1-2 |
Object Design Fundamentals
The basis of all advanced OO principles, techniques, and patterns
This chapter explains the fundamental principles of object design
and the best strategies to implement them.
We first cover the best basic OO Design techniques that implement
Encapsulation & Specialization as well as Inheritance &
Polymorphism.
Then we explore the different polymorphism strategies.
The chapter finishes with the Role Pattern, which is used to
implement flexible and powerful dynamic types and roles. Roles are
essential parts of problem domains that require solutions ranging
from static, non-changing roles to flexible, changing roles,
assuming multiple roles and providing polymorphism across all roles.
All these topics will later be studied within the context of real
applications.
|
- OO Principles
- Encapsulation
- Specialization
- Self-Sufficiency
- Interface
- Instantiation
- Abstraction
- Inheritance
- Polymorphism
- Encapsulation & Specialization
- Inheritance & Polymorphism
- Polymorphism Strategies:
- Replacement Method Pattern
- Extension Method Pattern
- Template Method Pattern
- Strategy Pattern
- The Role Pattern
- Inheritance Roles
- Association Roles
- Role Classes
- Role Class Generalization
- Association Class Roles
- Association Class Roles with Role Type
|
| 2 |
Link Management
The complete coverage of all relationship implementation issues and strategies
Implementing a domain model typically includes writing elaborate
code for instantiating and managing the different types of object
relationships at runtime.
We cover all the details about relationship implementation and show
how they can be managed efficiently with minimum coding overhead.
All these topics will later be studied within the context of real
applications.
|
- Association Implementation
- Implementing Association Ends
- Link Management Strategies:
- Client-Managed Associations
- Object-Managed Associations
- Link Factory Pattern
- Introspective Link Factory
- Composition Implementation
- Association Class Implementation
- Ternary Association Implementation
- Reflexive Associations
|
| 2-3 |
Domain Model Implementation
Proper OO design and patterns for implementing business logic in a domain model
We explore how objects can collaborate and use each other based upon
Specialization and Delegation to implement specific functional
requirements.
These techniques quickly lead us towards the Propagation Pattern,
the most powerful approach to implement elaborate Business Logic.
This topic is then complemented by the Visitor Pattern that
shows how Domain functionality can be encapsulated outside the
Business Classes, keeping the Domain lean and easy to manage.
|
- Object Collaboration
- The Propagation Pattern
- The Visitor Pattern (Advanced)
|
| 3 |
Application Architecture
Structuring an application's architecture around its domain model
Before we start the design of our sample application and all the
implementation details, we must look at the big picture. This
chapter shows the architecture of a typical enterprise application
and where the domain model fits in.
|
- Layering of an Enterprise Application
- Enterprise Architecture
- Domain Persistence
- The Importance of Domain
- Domain Persistence Strategies
- Object-Oriented Persistence
- Relational-Dependent Persistence
- Using All Options
- Relationship between OO and Relational Models
|
| 3-4 |
Object Construction I
Key strategies for managing complex object construction logic
In object-oriented languages we use constructors to create objects.
Using constructors directly has certain limitations that can
convolute the application code and make it hard to reuse and
understand.
In this chapter we discuss powerful patterns for properly
encapsulating object creation logic. These solutions maximize reuse
and keep client code simple and free of detailed instantiation code.
|
- Constructors & Their Limitations
- Encapsulating Construction Logic
- The Creation Method Pattern
- The Object Factory Pattern
- The Singleton Pattern
- The Prototype Pattern
- Object Cloning
- Object Identity & Equality
|
| 4 |
Real-World Application Example
Applying Advanced OO Design on a Real-World Case Study
All object design principles and patterns are best understood in a
real-life situation. In this chapter we introduce the artifacts of
a real-world problem domain: the scheduling and registration for
Public Training Classes. We will use this domain throughout the
remainder of the course to exercise many important design principles
and patterns.
This hands-on approach helps students to see clearly the need for
patterns and to appreciate the design solutions they offer. It will
then be very easy to apply these solutions at work.
|
- The "Public Training Administration" domain example
- Business Synopsis
- Domain Model
- Business Functions
- Prerequisites
- Domain Models
- Scenarios
- Sequence Diagrams
- Implementation Steps
|
| 4 |
Domain Model Design Example
From analysis model to detailed design
The analysis domain model that was introduced earlier as well as all
other analysis artifacts lay the foundation for the detailed design.
This chapter covers the considerations and refinements necessary to
prepare the domain model for successful implementation.
|
- Add a Layer Supertype
- Design Attribute Type Classes
- Decide on Attribute Accessibility
- Decide on Association Navigability
- Design Roles according to the required flexibility
- Choose Object and Link construction & management strategies
- Provide client developer interface(s)
|
| 4 |
Comprehensive Project
Integrating the OO Design Principles and Advanced Design Patterns in a real-world application
At this point it is important for students to experience what issues
may arise while implementing a real application. This chapter uses
the analysis and design artifacts discussed earlier and many of the
OO design techniques learned so far to build the application at hand.
|
- Domain Design Model
- Layers and Packages
- Application Architecture
- Use Case Implementation
- Class Implementation
- Object Construction
- Association Implementation
- Association Management
- Business Logic
- Client Access
|
| 5 |
The Rules Engine Framework (Advanced)
Offering Dynamic Behavior to End-users or Business Experts
Business rules change more frequently than any other aspect of your
enterprise applications. Historically, business rules have been
hard-coded as part of the business logic. To provide greater
flexibility and control it is a far better approach to encapsulate
the rules separately from the domain model, make them dynamic and
manage them with a Rules Engine. In this chapter we go over the
entire OO analysis and design of a simple but powerful Rules Engine.
We analyze what rules are, build a UML model, design a Rules Engine,
explore its code and finally extend the engine with additional
features during a lab. This is a great opportunity to not only
understand Rules Engines but also apply many of the OO Development
techniques studied in this course.
Furthermore, this chapter introduces additional Design Patterns
like "Command", "Composite", and "Façade". Students
appreciate how these patterns solve the Rules Engine specific
problems. This is the most effective way to learn Design Patterns.
|
- Definition
- Class-based / object-based rules
- Object rules challenges and solutions
- Rules Engine features
- Commonly used Rules Engines
- Rules Engine architecture
- Rule instance examples and analysis
- Rule UML model essentials
- Rules narrative, UI and "soft" coding
- Elaborated model
- Rules Structure
- "Composite" rule
- "If" structure
- "Comparison" model
- "Test", "Value", and "Method"
- Design Patterns used
- Composite
- Command
- Façade
- Interpreter
- Summary and conclusions
- Rules Engine Lab
- Creating your own rules
- Extending the Rules Engine
- Deciding if/when you need a Rules Engine
|
