Agile OO Design Workshop

3-days, hands on

This class shows you how to do Object-Oriented Design in an Agile environment, where constantly changing requirements is the norm. We look at Agile processes in general (Scrum and XP), and then go through the entire design process from story creation (problem-statement definition and use-case analysis) through to a UML diagram from which you can code. The emphasis is on how to use Agile techniques to build and maintain an effective object model that's optimized for programming in an Agile environment.

Since the best way to learn OO is by actually doing it, the centerpiece of this 3-day workshop is an extensive hands-on exercise in which you actually design a real-world OO system from scratch under expert guidance.

The workshop is as much a mentoring opportunity as it is a "class." No courseware or online alternative guides you through the entire design process in this depth under the supervision of an acknowledged expert in the field—Allen Holub himself.

Read comments by past participants.

Background

When it comes to OO, many people just don't "get" it. Procedural ways of thinking and Object-Oriented ways of thinking are at odds, and many people strongly resist OO architectures when presented with them. Some of the worst (poorly structured, hard-to-maintain) "OO" systems have been built by experienced C++ and Java programmers who don't understand OO.

Moreover, the design process itself influences the quality of the design, and many of the techniques that worked in the past are just not applicable in a modern "Agile" development shop, which focuses on handling constantly changing requirement (or more accurately, new requirements that are discovered as the system evolves under a very short development/deployment cycle).

This workshop shows you how to do it "right." You will come away from this workshop with a sound grounding in what Agile-development is (and how to do it), in OO concepts, process, and techniques, and in how to conceive OO systems that will accommodate Agile development. You'll be well able to proceed with a real design effort on your own.

The extensive hand-on exercise at the center of the workshop gives you the experience you need to master the "inside-out" thinking characteristic of OO systems. It is a proven method for coming up to speed on the concepts quickly and effectively.

The problem.

• Computer programs don't often meet the needs of their users.
• They are larger and more complex then necessary.
• They take longer to build and have more bugs than they should.
• That inordinate build time makes it impossible to get the feedback you need to fix significant design flaws early, when fixing them does the most good.
• These systems are often poorly structured, and cannot accommodate new business requirements as they emerge.
• The programs are delicate and difficult to maintain.

Agile development processes and OO Design, when taken together, addresses all these problems. The process and design methodology are, in fact, tightly coupled. If your program is not designed and constructed using good OO principles, then it will be very difficult, perhaps impossible, for the program to be easily refactored or to evolve to accommodate new requirements, two central issues in any Agile shop.

Unfortunately, both Agile techniques and Object Orientation are poorly understood by many programmers, even those who use OO languages like C++, Java, or C#. Improperly done Agile processes simply don't work. (To paraphrase Kent Beck: you loose 80% of the benefit if you omit even 20% of the techniques.) Many systems that purport to be object oriented aren't, so don't benefit from the flexibility and ease of maintenance inherent in well-done OO systems. More to the point, many programmers learn by mimicking existing systems, and many such systems (including some extremely popular open-source libraries) are not particularly well structured.

The problem is not limited to programmers. Managers who don't understand the Agile/OO process can't manage effectively. Consequently, this class is just as valuable to managers as it is to programmers.

The solution.

To learn Agile and OO thinking, you must experience the entire OO development process in a supportive hands-on environment. That's exactly what we do in the workshop, teach you the concepts and process by actually doing it.

• You will learn why OO seems to do things in a backwards way.
• You will learn how to approach programming so that these seemingly backwards concepts seem natural.
• You will learn how to approach the solution in an OO way from the very beginning, avoiding most of the traps and pitfalls that snag procedural programmers.

The workshop is taught in an informal style that encourages lots of interaction. Discuss issues intelligently in a structured environment, isolated from the religious wars that occur in online discussion groups and in the work place.

The class is small, so you have the luxury of "chewing" on a concept until it's fully digested, with a lot of one-on-one interaction with the instructor.

The Details

We start with a lecture that introduces Agile techniques and goes through the entire OO/Agile design process, so that you can get a wholistic picture of the essential concepts.

We then actually solve a real-world problem (supplied by you!—this is not a pedagogic exercise) from beginning to end. We start with story development (use-case analysis), and take the process through the static and dynamic modeling to to a design sufficiently detailed enough that you can code from it.

We also work hard on learning the "inside-out" thinking that characterizes OO systems. You will learn how to break out of the procedural mold.

In actually pursuing the design, we perform many activities, often in parallel. Most of the material that you would normally learn in lecture is taught in the context of the hands-on exercise. That is, we learn a process or notation, and immediately put it into practice.

We will cover the following material:

Tools and Techniques

The development envorinment
Development tools

The Agile Development Processes

Scrum
"Extreme Programming" (XP)

The System Metaphor

Working in the Problem Domain
Developing the Problem Statement
The UI as a design tool

Story Development (Use-Case Analysis)

Developing use cases and Scenarios
Use-case templates
Use-case-based UI development
UML activity diagrams
UML use-case diagrams

Dynamic Modeling (Object Interaction At Runtime)

Objects and message structure
Implementation hiding
Eliminating unnecessary complexity and coupling
UML sequence diagrams
UML collaboration diagrams

Static Modeling (Class Structure)

Identifying classes and messages
Interfaces and polymorphism
Class organization, structure, and hierarchy
Building associations based on dynamics behavior
The role of the database
UML class diagrams

Audience

Though this class is fundamentally about creating computer programs, it is not a programming class. Programmers, technical mangers, and business analysts have all completed this class successfully. In fact, we strongly recommend that all three (or at least both programmers and their managers) attend.

Following Up

Programmers should follow up this workshop with the Agile Architecture class, which covers the nuts-and-bolds implementation-level architecture required to actually build a system that will succeed in an Agile/OO environment.

In-house Presentation

The Agile OO-Design workshop is one of our most popular classes for presenting in house. In addition to the three-day version, we also provide an extended 4-day version that let's us spend more time on the exercise.

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 present public sessions of the OO Workshop periodically. 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:30 AM to 4:30 PM. If you're coming in from out of town, here's a list of accommodations that are close by.

Cost, Etc.

Public sessions of the 3-day workshop cost $1495.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.

Sign Up

Click one one of the following scheduled public sessions to sign up: