Yes, I’m going to finish "Build Your Own CAB" (sorta)

Over the past couple years I’ve received quite a bit of positive feedback on my “Build Your Own CAB” series on design patterns for building desktop applications. Unfortunately, a lot of the feedback is “it’d be really nice if you’d get around to finishing the series.”  After all, I didn’t really publish anything that actually related to building composite applications.  I am wrapping up this series plus quite a bit more (+ incorporating the work that Martin Fowler already did on these topics but didn’t publish), but as part of a book for Addison Wesley tentatively entitled “Presentation Patterns.”  I’ll try to blog a lot more about the book next month as I shift to working on it a lot more.  I’m strictly focusing on design patterns rather than any particular technology.  At a guess, I’d say that half of the samples will be C#/WPF and the rest will be Java, WinForms, and even a couple JavaScript samples.

Here’s the rough outline at the moment.  If there’s something you’d particularly like to see more or less of, feel free to comment on this (please).

1. What’s so hard about
   building a User Interface?
   1. Look at everything
      that’s going on here
   2. How do I test this?
   3. How do I connect
      all this together?
2. Separated
   Presentation
   1. The travails of
      using Active View
   2. The Humble Dialog
      Box (narrative)
   3. Separated
      Presentation (narrative)
   4. GUI Architectures
      (pattern)
   5. Passive View  (pattern)
   6. Supervising
      Controller (pattern)
   7. Presentation Model
      (Model-View-ViewModel) (pattern)
   8. Communication
      between the View and Presenter (narrative)

                                                   
i.     By events

                                                  
ii.     Direct communication

2.  
   9. What’s the Model?
      (long narrative)
   10. Model Based
       Validation with the Notification Pattern
3. The Mechanics of the
   View
   1. Managing Screen State (narrative)
   2. Flow
      Synchronization (pattern)
   3. Observer Synchronization
      (pattern)
   4. Flattener (pattern)
   5. MicroControllers
      (pattern)
   6. Embedded Controller
      (pattern)
   7. Screen State (pattern)
4. Complex Screens
   1. Composite
      Controller (pattern)
   2. Layout (pattern)
5. The Application Shell
   1. Coordination
      between Screens (narrative)
   2. Screen Activation
      Lifecycle (narrative)
   3. Presenter First (narrative)
   4. Application Shell
   5. Application
      Controller
   6. Screen Collection
   7. Screen Subject
   8. Layer SuperType
6. Event Coordination
   1. Coordination
      between Screens
   2. Latch (pattern)
   3. Event Aggregator
      (pattern)
   4. Command (pattern)
7. Crafting a Domain
   Specific Language (not well defined yet, but could be a great chapter)
8. Modularity
   1. Using an Inversion
      of Control Tool
   2. Bootstrapper
      (pattern)
   3. Registry (pattern)
   4. Presentation Chooser (pattern)
      
9. Communicating with
   the Server
   1. Message Bus
      
   2. Command Executor
      (pattern)
10. Automated Testing
    1. Unit testing the
       Presenter layer
    2. Unit testing the
       View
    3. Subcutaneous
       Testing
    4. Strategies for User
       Interface Testing
    5. Screen Driver
       (pattern)

Oh, and my take on “is M-V-VM the same thing as Presentation
Model?”  I say yes.  I think it’s the exact same pattern just described
differently by Fowler and the Microsoft guys.  Think Leipzig and Sir
Isaac Newton discovering Calculus at the same time.