Object-Oriented Structure and Design Patterns for Agile Projects.
Agile programming projects have very specific needs (easily incorporating new business requirements, for example), and you need to write your code in a way that accommodates those needs. That is, unless your program is structured properly, it will be difficult or impossible for that program to evolve in an Agile way.
The best way to handle the requirements of Agile development is with good Object-Oriented structure, as epitomized by the "Gang of Four" Design Patterns and other techniques. This very-practical two-day seminar teaches you implementation side of Object-oriented systems, focusing on OO Architecture, design patterns, and at OO concerns specific to Agile development.
The seminar presents this material in a practical context, analyzing real-world code, not trivial examples. We'll look at the Game of Life and SQL interpreter in Allen's book (see below) as well as a server-side UI framework (that's not in the book). This approach shows you how design patterns, for example, actually appear in the real world, so gives you a real-world understanding that you can't get from the more typical catalog-of-patterns approach. You'll come out of this seminar understanding good OO architecture and knowing, not only what the patterns are, but how to apply them and other OO techniques and principles effectively.
This class is an ideal follow-on to the Agile OO-Design workshop, which covers the design-and-development process up to the implementation phase.
To be a competent object-oriented designer, you have to master both OO structure (like interface-based programming and implementation hiding) and architecture (such as the "Gang of Four" design patterns). This knowledge is particularly important in an Agile development environment, where poorly structured code can doom the entire development process to failure.
Most books and classes on these subjects are structured in such a way that you have no idea how to apply your knowledge, however. For example, they catalog the design patterns for you, but provide trivial examples that give you no real understanding of how the patterns work in the real world. The examples don't show you the complex interactions between patterns, or the myriad ways that a pattern can be realized.
This class showings you how to move your analysis-level design to an implemenentation-level design. We cover OO structure in depth, looking at topics ranging from class-hierarcy design and the proper use of interfaces to the "Gang of Four" design patterns, but we do this in the context of real code.
This class takes the radical approach of teaching design patterns and structure by in-depth analysis of two Java programs---a Game of Life implementation and a small embedded SQL interpreter--- in terms of the design patterns used to implement the programs.
Taken together, these programs show you all of the "Gang of Four" design patterns in context and also provide examples of good OO structure. You can see how the patterns work and how they interact. You can see how they're actually used in nontrivial applications.
We also discuss object-oriented-programming principles and how they apply to the patterns, so that you can understand why the patterns do what they do. Emphasis is placed on good design technique, and on common mistakes ("antipatterns").
You will come away from this class understanding...
- how to move from OO analysis into the design phase and how to turn analysis documents into something from which a program can be constructed.
- problems associated with OO/procedural hybrid systems: fragile base classes, overuse of the getter/setter idiom, etc.
- interface-based programming
- all the "Gang-of-Four" design patterns and how they are used in the real world.
- the real-world compromises and modifications needed to implement good OO design.
This course is for professional programmers and technical managers who have at least a "reading" knowledge of Java, C++, or C#. (The examples are in Java, but C++ and C# programmers should have no problem following along.)
A basic understanding of OO Design principles, the analysis process, and the UML notation is assumed. This material is presented in Agile OO-Design workshop, and can also be presented as a separate, 2-day lecture-only class.
- Building for Agility.
- What is an object?
- Characteristics of Object-Oriented systems.
- Identifying classes, objects, and behavior (messages).
- Class-Hierarchy Design
- Interface-based programming
- Implementation vs. Interface Inheritance.
- Fragile Base Classes
- Interface inheritance
- Implementation Hiding
- Eliminating get/set methods.
- Interface-based programming
- Agile Architecture
- Designing for an Agile environment.
- The Single-Responsibility Principle (SRP)
- The Open-Closed Principle (OCP)
- The Liskov-Substitution Principle (LSP)
- The Dependency-Inversion Principle (DIP)
- The Interface-Segregation Principle (ISP).
- The Game of Life
- Emergent behavior and the role emergence plays in OO
- The SQL Interpreter
- A lightning-fast introduction to SQL
- The "Gang of Four" Design Patterns
- Creation Patterns
- Abstract Factory
- Factory Method
- Structural Patterns
- Behavioral Patterns
- Active Object (time permitting)
- Chain of Responsibility
- Interpreter (time permitting)
- Memento (time permitting)
- Template Method
- Visitor (Mobile Agent)
- Creation Patterns
- Object-Oriented UI Architecture
- UI Architecture for distributed and web-based systems.
- Model/View/Controller, and Why It Doesn't Work
- Visual Proxy
The textbook for this class is Holub on Patterns: Learning Design patterns by Looking at Code (Berkeley: APress, 2004 [ISBN: 159059388X]). The book is required. We will provide you with an ebook version before class starts, but for convenience, you may want to purchase a paper copy.
AudienceThis class is for programmers who already know an object-oriented programming language, such as Java, C++, or C#. The examples presented in class are in Java, but you'll have no trouble following along if you know any of these three languages.
In-house PresentationWe are happy to present this class in house for groups of 6 or more. For smaller groups, we can arrange to teach the class at our offices in Berkeley, CA.
We offer several discounts for in-house presentation, depending on location and class size. Call or email us for for details.
Public-Class Locations, Time, Accommodations
We usually hold public sessions of the workshop in Berkeley, California, either at a local venue or or at our offices, depending on the class size. Classes run from 9:00 AM to 5:00 PM. If you're coming in from out of town, here's a list of accommodations that are close by.
Public sessions of this class cost $995.00/student. We offer a 10% discount if you attend both the workshop and the immediately-following Agile Architecture class. We offer an additional 10% discount if you enroll five or more students.
Cancellation: If you cancel 30 or more days before class starts, we will promptly refund your tuition, less a 10% processing fee. For cancellations less than 30 days in advance of class, we will credit your tuition towards a future class of your choice, but will not issue a refund.
We may cancel the class if enrollments are too small. We will notify you of a cancellation at least one week before the first day of class. If you're flying in from out of town, we recommend that you purchase a refundable ticket or get trip-cancellation insurance to handle this possibility.