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

1.  
   1. What’s the Model? (long narrative)
   2. Model Based Validation with the Notification Pattern
2. 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)
3. Complex Screens
   1. Composite Controller (pattern)
   2. Layout (pattern)
4. 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
5. Event Coordination
   1. Coordination between Screens
   2. Latch (pattern)
   3. Event Aggregator (pattern)
   4. Command (pattern)
6. Crafting a Domain Specific Language (not well defined yet, but could be a great chapter)
7. Modularity
   1. Using an Inversion of Control Tool
   2. Bootstrapper (pattern)
   3. Registry (pattern)
   4. Presentation Chooser (pattern)
      
8. Communicating with the Server
   1. Message Bus
      
   2. Command Executor (pattern)
9. 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.