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
    1. The travails of
      using Active View
    2. The Humble Dialog
    3. Separated
      Presentation (narrative)
    4. GUI Architectures
    5. Passive View  (pattern)
    6. Supervising
      Controller (pattern)
    7. Presentation Model
      (Model-View-ViewModel) (pattern)
    8. Communication
      between the View and Presenter (narrative)

By events

Direct communication

    1. What’s the Model?
      (long narrative)
    2. Model Based
      Validation with the Notification Pattern
  2. The Mechanics of the
    1. Managing Screen State (narrative)
    2. Flow
      Synchronization (pattern)
    3. Observer Synchronization
    4. Flattener (pattern)
    5. MicroControllers
    6. Embedded Controller
    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
    6. Screen Collection
    7. Screen Subject
    8. Layer SuperType
  5. Event Coordination
    1. Coordination
      between Screens
    2. Latch (pattern)
    3. Event Aggregator
    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
    3. Registry (pattern)
    4. Presentation Chooser (pattern)
  8. Communicating with
    the Server
    1. Message Bus
    2. Command Executor
  9. Automated Testing
    1. Unit testing the
      Presenter layer
    2. Unit testing the
    3. Subcutaneous
    4. Strategies for User
      Interface Testing
    5. Screen Driver

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.


About Jeremy Miller

Jeremy is the Chief Software Architect at Dovetail Software, the coolest ISV in Austin. Jeremy began his IT career writing "Shadow IT" applications to automate his engineering documentation, then wandered into software development because it looked like more fun. Jeremy is the author of the open source StructureMap tool for Dependency Injection with .Net, StoryTeller for supercharged acceptance testing in .Net, and one of the principal developers behind FubuMVC. Jeremy's thoughts on all things software can be found at The Shade Tree Developer at
This entry was posted in Uncategorized. Bookmark the permalink. Follow any comments here with the RSS feed for this post.
  • Adam L.

    I can’t wait. I am really looking forward to reading your take on Application Shell.

  • Claudio Lassala

    I think you’ve got it all covered, man! Is it ready to ship yet?! :)

  • cs

    This is really needed. Can’t wait!

  • Mikael

    Excellent! In the mean time, when waiting for your book, can you recommend some material for these patterns:

    Composite controller
    Presentation chooser

    Google didn’t give any answers.

  • Borek

    I am excited to hear that this series will be finished – and in the best possible form. I’m sure the book will be classic!

    One suggestion though: please give Supervising Controller a proper name (it is a Presenter, not a Controller). It may be the last chance to make the correction before the term is too settled.

    Looking forward to your book, I will be one of the first people who will preorder it.

  • Ike Casteleyn

    Looking forward to see this series continued.
    I would also like more codesamples (or complete ones, perhaps as a download to explain things better).

  • Gagan

    It would be awesome when the BYOC series is completed, even if its in the form of a book. What is the expected release date/time-frame for the Presentation Patterns book?

  • samnang

    Great done! Hopefully, you will include sample code for each post to download. Thanks

  • Yorgos Pagles

    I have found that Build your own CAB is the most hands on presentation of patterns on building desktop application and was looking forward to its completion. I am excited that it going to be a book and can’t wait until it gets out.
    My wish list now will only contain someone getting on this material and adds a C++ flavor (Qt 😉 )

  • Rod Cerrada

    Thats is great! Build your own CAB is one of the best article I read.

    I think you also include Cloud Computing patterns and best practices.. The .NET Services of Azure is a hybrid of SOA or MVP – Unity combo.

  • Maggie Longshore

    Looking forward to the book. I would be interested in reading about control-flow patterns and any patterns that deal with command patterns and interaction with users.

  • Ryan Riley

    I’m looking forward to the book. I think you should certainly include the DSL chapter if for no other reason than you have FubuMVC under your belt, and we would all greatly benefit from the lessons learned. I’d also be interested in which technologies seem to match up better with which patterns.

  • Chris

    The other mathematician was Leibniz (who also is the documenter of our current binary system).

    Nevertheless, your BYOC series is a regular read for me and I pull something new out of it every time through.

    I have a feeling your Presentation Patterns book will eventually make its way on the shelf next to Pragmatic Programmer, PEI, and the blue DDD.

  • Colin Jack

    Really great, looking forward to reading this stuff.

  • José Filipe

    Hi Jeremy,

    I probably can say that the “Build your own cab series” is the oldest item that I have in my favorites list.

    I’ve seen it last year while searching for a composite framework (thus looking for Jacada, CCF, CAB, etc.), but the stakeholders decided for Java and I gave up of it (I’m kind of focused on .NET right now).

    The serie, anyway, remained there because I consider it that kind of mandatory item in a “to read list”.

    Good to know that you’re still thinking on it (and even writing about :-)). The Complex Screens sounds really interesting to me, but the book as a whole looks pretty interesting right now..

    Hope to hear about it soon..