Distributed Object-Oriented Analysis and Design Workshop 
(5 days)

Overview

Our flagship course, the Distributed Object-Oriented Analysis and Design Workshop is a 5 day course that covers all aspects of analysis and design of distributed object systems. The course is presented in a workshop format; students spend about 40% of the actual course time developing a solution to an actual problem. This technique reinforces the concepts covered during the lecture portion of the course, and also permits in-depth examination, in the context of a real design, a number of issues that are not readily apparent from a lecture style presentation. Design issues are presented in an implementation-independent context, although some details are provided for selected inplementation environments (e.g., CORBA, Java, etc.). The course puts significant emphasis on behavior and collaboration of objects - something missing from a number of popular OO methodologies - as well as the techniques for building good, robust class hierarchies, utilizing proper inheritance.

While the course emphasizes distributed object systems, all of the concepts presented in this course are also applicable to non-distributed object systems as well.

This course is taught by Stephen McHenry. His background might be of interest to you. Check out some articles that he has written. Here are some other comments that might interest you. Also, if you don't think it matters who teaches your course, you might want to check out these former students had to say about him. We think it does matter. 

What you will Learn

Analysis Concepts The meaning of important object-oriented concepts such as abstraction encapsulation inheritance polymorphism overloading persistence The differences between  objects and classes links and associations methods and messages associations, aggregations and generalizations How to utilize use cases in system development  How to properly utilize aggregation to represent composite objects and what happens if you represent them improperly What makes an “improper” class that should be eliminated.  How to represent associations between classes  How to recognize missingunecessary classesand/or associations  To utilize dynamic modeling to represent time-dependent parts of your system  How to recognize state dependent behavior  Class Hierarchies When to create a subclass or a superclass  How to develop class hierarchies using generalization/specialization techniques  Which uses of inheritance actually make the system take longer and cost more How to avoid making your class hierarchies brittle because of improperly used inheritance What an abstract class is and when to use it  How to effectively use multiple inheritance What interface inheritance is and how to use it properly The difference between "interface" and "implementation"	Collaboration Why examining the collaboration between objects is so important  How to properly structure collaborations The different types of collaboration patterns and why they are effective (or not) Architecture The different types of architectures including: client/server 3-tier architecture How to properly structure a distributed object system How to breakdown monolithic servers Which architectural choices will lead to major performance problems later What proxies (stub) and adapters (skeletons) are The semantics of call-by-reference vs. call-by-value Concurrency What the benefits are to using concurrency  What hidden problems are “lurking” when concurrency is used improperly  How to identify concurrency within objects and when synchronization is important What the different messaging modes are How to utilize threading properly Strategies for partitioning and replication Benefits and disavantages of multi-threading vs. replication The difference between stateless and "stateful" servers The definition of "stateless" Stateful patterns of communication Stateless patterns of communication When stateless communication must be used How to ensure object safety How to ensure object liveness	Transactions What transactions are and how to use them properly Impacts of transactions on  architectural choices concurrency Extending transactional semantics to objects Event Mechanisms Active vs. Passive Objects Polling vs. Event driven communication When and how to use event mechanisms for notification  How to build a distributed event mechanism Utilizing event channels When not to use events  Why most first “object-oriented” projects fail and how to prevent this  Ways to increase the performance of your distributed systems Multicasting using events Source-side vs. destination-side filtering of event channels Persistence How to map an “object-oriented” system to a relational database management system (RDBMS)  How to accommodate database transactions in your system  What impacts caching of objects has on the system  Where to cache each type of object  How to map associations between objects into physical representations  When to use delegation to share implementation  How to adjust the object model during the design phase  How to select appropriate object representations
	How to develop an object model by actually developing one - in class!

 

Course Outline

• Introduction to Object-Oriented Methodology
• Object-Oriented Concepts and Terminology
• Problem Domain Analysis
  • Use Cases
  • Developing an Object Model
  • Class Hierarchies and Inheritance
  • Dynamic Modeling
  • Object Behavior and Collaboration
• Design
  • Introduction to Object Design
  • System Architecture
  • J2EE Architectures
  • Concurrency
  • Transactions
  • Events Mechanisms
  • Persistence Managers
  • Mapping Objects to Database Tables
  • Boundary Conditions
  • Advanced OO Design
• Problems You Might Encounter
• Conclusions

Cost - $1895 per person