in Search

Do you Twitter? Follow us @CodeBetter

Jeremy D. Miller -- The Shade Tree Developer

Under the hood and working with .Net, TDD, Software Design, and Agile Stuff

Choose your own adventure! Where does "Build your own CAB" go next?

Everyone,

The "Build your own CAB" series has enjoyed a very warm reception and I thank you all for the compliments I've received over the last couple weeks. Before I go on much farther with the series, I want to open the "story" prioritization up to you all to make sure we talk about the things you care most about before I run out of steam on this one. I'm finishing up the Passive View pattern right after this, but after that I'll leave it up to you.

Here are the topics I have in mind:

Assigning responsibilities to the Model View Presenter triad
Patterns of View/Controller communication
Presentation Model - a different take on Humble View's
Synchronization issues with the backend
What are the options for the Model? (short)
Using the Notification Pattern. Performing input validation in the Domain Model and connecting these errors to the screen elements
Pluggability -- tricks and examples for wiring together UI components with StructureMap
Event Aggregator -- coordinating events to disparate screen elements in a loosely coupled manner
Subcutaneous Testing
MicroController, a recipe for better screen element synchronization. I've written a partial replacement for data binding that bakes in declarative screen element behavior and testability
Building an Application Shell -- I've got 3-4 different examples of building an ApplicationShell/ApplicationController to handle navigation and screen coordination
Driving WinForms through Fitnesse/StoryTeller tests. What's worked for me, and what's bombed.
Applying NUnitForms (I'm an admin on NUnitForms, and it never gets the attention it deserves)

If you've got a preference, just let me know.

Thanks,

Jeremy

Published May 30 2007, 09:32 PM by Jeremy D. Miller

Comments

Afif said:

A very hard list to choose from nevertheless, here are my preferences (in the given order)

1. Using the Notification Pattern. Performing input validation in the Domain Model and connecting these errors to the screen elements

2. Pluggability -- tricks and examples for wiring together UI components with StructureMap.

3. Synchronization issues with the backend

4. Applying NUnitForms (I'm an admin on NUnitForms, and it never gets the attention it deserves).

5. Driving WinForms through Fitnesse/StoryTeller tests. What's worked for me, and what's bombed.

6. Assigning responsibilities to the Model View Presenter triad.

BTW, fantastic series, keep em coming.

- Afif

# May 30, 2007 10:09 PM

Mark said:

Here are my preferences

1. Pluggability -- tricks and examples for wiring together UI components with StructureMap

2. Event Aggregator -- coordinating events to disparate screen elements in a loosely coupled manner

3. MicroController, a recipe for better screen element synchronization. I've written a partial replacement for data binding that bakes in declarative screen element behavior and testability

4. Driving WinForms through Fitnesse/StoryTeller tests. What's worked for me, and what's bombed.

5. Applying NUnitForms (I'm an admin on NUnitForms, and it never gets the attention it deserves)

# May 30, 2007 10:40 PM

Johan said:

Hi Jeremy,

My preferences: Just show them all :-)

# May 31, 2007 3:14 AM

Ross Neilson said:

Jeremy,

My preferred running list would be

Synchronization issues with the backend

Using the Notification Pattern

Building an Application Shell

Driving WinForms through Fitnesse/StoryTeller tests

Applying NUnitForms

Thanks very much for an excellent series of posts. It good to see readers being given practical advice and examples on how to improve the structure of their applications.

# May 31, 2007 4:16 AM

Emanuele said:

Here's mine:

1) Building an Application Shell -- I've got 3-4 different examples of building an ApplicationShell/ApplicationController to handle navigation and screen coordination

2) Assigning responsibilities to the Model View Presenter triad

3) Synchronization issues with the backend

4) Using the Notification Pattern. Performing input validation in the Domain Model and connecting these errors to the screen elements

5) MicroController, a recipe for better screen element synchronization. I've written a partial replacement for data binding that bakes in declarative screen element behavior and testability

Others...

Thanks!!!!

# May 31, 2007 7:01 AM

Jeremy said:

They all sound good but I would specifically like to see:

1) Driving WinForms through Fitnesse/StoryTeller tests. What's worked for me, and what's bombed.

2) Applying NUnitForms.

I work primarily in WinForms and often result to striving for a passive view as I've all but given up on unit testing them. So any help on how to do that would be a benefit.

# May 31, 2007 8:47 AM

Dustin said:

Here are my top 4. But I'd like to see some of the other ones, too. Put them all in a book and I'd totally buy it.

1. Building an Application Shell

2. Pluggability

3. MicroController

4. Applying NUnitForms

The first three I would really like to see, and for the last one I agree that NUnitForms deserves some more attention.

# May 31, 2007 10:29 AM

James Maul said:

My top preferences would be:

1 - Presentation Model - a different take on Humble View's

2 - Building an Application Shell -- I've got 3-4 different examples of building an ApplicationShell/ApplicationController to handle navigation and screen coordination

3 - Assigning responsibilities to the Model View Presenter triad

4 - Driving WinForms through Fitnesse/StoryTeller tests. What's worked for me, and what's bombed.

5 - MicroController, a recipe for better screen element synchronization. I've written a partial replacement for data binding that bakes in declarative screen element behavior and testability

6 - Subcutaneous Testing

And congrats for this excellent series!I can't wait for the next episodes!

# May 31, 2007 11:10 AM

Dan said:

1. Patterns of View/Controller communication

2. Assigning responsibilities to the Model View Presenter triad

3. Synchronization issues with the backend

4. Using the Notification Pattern.

# May 31, 2007 11:45 AM

Oliver said:

1. Application Shell

2. Notification Pattern

3. Pluggability

i wouldn't mind if you would also show off the rest of the things.

your blog is super interesting, keep it up.

# June 1, 2007 5:25 AM

Tobi said:

1. Pluggability -- tricks and examples for wiring together UI components with StructureMap

2. Presentation Model - a different take on Humble View's

3. Using the Notification Pattern. Performing input validation in the Domain Model and connecting these errors to the screen elements

4. Building an Application Shell -- I've got 3-4 different examples of building an ApplicationShell/ApplicationController to handle navigation and screen coordination

5. Patterns of View/Controller communication

6. What are the options for the Model? (short)

7. MicroController, a recipe for better screen element synchronization. I've written a partial replacement for data binding that bakes in declarative screen element behavior and testability

8. Event Aggregator -- coordinating events to disparate screen elements in a loosely coupled manner

9. Driving WinForms through Fitnesse/StoryTeller tests. What's worked for me, and what's bombed.

10. Synchronization issues with the backend

# June 1, 2007 6:54 AM

todd said:

please, please, please

* Driving WinForms through Fitnesse/StoryTeller tests. What's worked for me, and what's bombed.

* Applying NUnitForms (I'm an admin on NUnitForms, and it never gets the attention it deserves)

# June 11, 2007 3:46 AM

Name (required)

Your URL (optional)

Comments (required)

Remember Me?

Enter the numbers above:

Add

About Jeremy D. Miller

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 previously worked as a systems architect building mission critical supply chain software for a Fortune 100 company and learned agile development practices as a .Net consultant at ThoughtWorks, one of the pioneers of agile development. Jeremy is the author of the open source StructureMap (http://structuremap.sourceforge.net) tool for Dependency Injection with .Net and the forthcoming StoryTeller (http://storyteller.tigris.org) tool for supercharged FIT testing in .Net. Jeremy's thoughts on just about everything software related can be found on his weblog "The Shade Tree Developer" at http://codebetter.com/blogs/jeremy.miller, part of the popular CodeBetter site. Jeremy is a Microsoft MVP for C#.

This Blog

Home
Contact

Syndication

News

All opinions expressed here constitute my (Jeremy D. Miller's) personal opinion, and do not necessarily represent the opinion of any other organization or person, including (but not limited to) my fellow employees, my employer, its clients or their agents.

About Me

"Best Of" Compendium

StructureMap (Dependency Injection for .Net)

StoryTeller (Supercharged Fit)

Build your own Cab