Aaron Feng

Closed

2006-06-11T23:56:00.000-04:00

I have been having a lot of problems with blogger, so I decided to move my blog. My new home can be found here.

Agile Transition

2006-06-08T00:52:00.000-04:00

One of the reasons my current job is so pleasant to work for is that everyone on the team has made the Agile transition seamlessly. Making the Agile transition requires change of mind set, and sometimes that is not the easiest thing to do. Michael Puleio described the changes he has made in his post since he joind Microsoft patterns & practices. A lot of the changes he made I am sure a lot of us on the team have also experienced, so I will not try to duplicate here. Just read his posts :)

Random Thoughts

2006-06-03T12:37:00.000-04:00

Nowadays people think Agile development is a substitute for success. As Alistair Cockburn found out during his researching years at IBM, a team can succeed when there is no process at all. A process will not change the team or make them super developers. The purpose of Agile development is to minimize the risks for the business people and developers. In the Agile world we put down our psychic prediction hat and react to changes. After all, no two pieces of software are alike. With that said, there is no guarantee a project will not fail. People usually associate failed projects with projects that are cancelled. A project can still be considered some what of a success if it gets cancelled before all the money gets drained away. A win for the business.

Managers tend to jump on the process ban wagon before looking at the team. Ultimately a well defined process will not write the software, your developers will. Team chemistry is very important, in my opinion, because you could have all-star players, but if no one can work together, it is very hard to ship a product. I think it is very important to have a variable skill level team. In that type of environment, people will tend to explorer other possibilities. Modern software is too complicated to make text book assumptions. On top of that, as the saying goes, a team does not need too many chefs in the kitchen.

Many companies are obsessed with assembling the ultimate dream team based on skill set, but having great skills does not equal a great team player. A very important ingredient in the recipe to create a dream team is to find people who love doing what they do, but this tends to be over looked. When everyone on the team is working as one, the variable skill levels tends to disappear.

Indigo Security with AzMan

2006-05-28T22:52:00.000-04:00

In the previous post, I mentioned how client side security can be accomplished by using .NET attributes with AzMan. Here are a couple of good posts on server side security using Indigo with AzMan:

Declarative Security with AzMan and CAB

2006-05-27T09:02:00.000-04:00

In a previous post, I mentioned Controls can be dynamically disabled based on users' permission by using .NET attribute with AzMan and CAB. This week is our security iteration, so we are able to test the concept described in this MSDN article. The article suggested modifying the RootWorkItemInitializationStrategy.cs, so when each objects are built up, it will be disabled based on the attribute declared on the Controls and users' permission. I personally do not like the idea of modifying 3rd party code when it can be avoided. There is another way to accomplish the same thing by creating a custom BuilderStrategy then overiding AddBuilderStrategies method in the shell, so you can add the strategy during run time. It will look something like this:

public class YourShell : FormShellApplication {
 protected override void AddBuilderStrategies(Builder builder) {
 base.AddBuilderStrategies(builder);
 builder.Strategies.AddNew(BuilderStage.Initialization);
 }
}

Here are some pitch falls we ran across when we tried to implement security with attributes.

Dynamically created controls cannot be applied.
Literal strings are used in the declaration of attributes, so if anything changes with the security or Control, it will result in runtime rather than compile time.
The declaration of Controls cannot be in the designer file because the designer file will get overwritten.
Performance penalty during startup of the application.
Explicit logic already exists to enable or disable the UI based on the state of the system will override the attribute.

In that article, XML file is used on the client side to map the AzMan operations. The configuration file can be completely removed if the list of valid operations is retrieved from a service layer based on the user's identity. This is recommended so all the operations can be retrieved from a central location. The article mentioned the source code is "demo" quality, and he really means it. Overall, it was pretty painless to implement the concept described in the article.

Client side security is for eye candy, but the real security comes when you secure your service layer. Service layer can be secured using declarative approach too, but that is for another time.

Invisible Leadership

2006-05-26T15:35:00.000-04:00

I have been trying to write this article for weeks now, and I cannot seem to fix the article to the point where I would like. I am going to post it anyways, just as a caution some thoughts might not be well formulated.

For the past week we have been talking a lot about leadership at work. We bounced around ideas on what leadership means to us. We decided that in order for leadership to exist, there must be a leader. So the next natural question for us is what is a leader?

Fundamentally there are two types of leaders: institutionally defined or defined by your peers. Often this can be the same person, but it does not have to be. In this post I will talk more about non-institutionally defined leaders because it seems more interesting and unconventional. From this point on, I will just refer to a non-institutionally defined leader just as leader.

This type of leader can exist in any profession where people have to work together, not exclusively in software development. What are some characteristics of this type of leader? Since he or she is pretty much invisible from the corporate point of view, below I list some common attributes of a leader:

Enjoys and cares about the type of work being produced.
Strong problem solver.
Approachable personality.
Shares ideas with others.
Assumes good faith of others.
Shares a common goal with other members on the team.
Exhibits patience with others.
Works well with others.
Strong Communication skills.

In order for one to be a leader, he or she must have followers right? How can an "invisible" person lead? I believe this person is only invisible to outsiders, but in reality, other members of the team know who this person is. This person leads by examples, and will set the bar high (I know this is a cliche, but it is true).

So far I have been talking about this magical person called the leader in a singular form. I believe there could be multiple leaders on a team, and a leader usuahlly emerges when he is able to provide insights to the problem.

So far I have described what a leader is, but why would anyone want to follow a leader instead of leading themselves? I think the most important attribute of a leader is the ability to solve a problem and convey the idea to the team. It is unlikely that everyone on the team can solve all the problems, assuming the problem is non-trivial. The person that is able to solve the problem with the best solution would be the leader in this case. Others would want to follow because we are all working towards a common goal, and would like to learn how the problem is being solved.

Having a leader is important to any team situation. Sometimes leaders inspire their team members to work harder so that they may too lead in some areas. Ultimately, this is beneficial to the entire team.

CoolCommands

2006-05-16T20:59:00.000-04:00

Yesterday I found a really cool Visual Studio 2005 Addin. It adds many useful commands to the context menu. I will just list some of the features I like, but I will let you be the judge.

Open Explorer browser by right clicking on a file.
Automatically resolves missing references.
Locate item in Solution Explorer on demand when active tracking is turned off.
Copy and paste references from one project to another.
Add multiple projects at once.
Collapse all projects.
Visual Studio Command prompt here.

Since we use Subversion it is very useful to be able to open the selected file in Explorer from Visual Studio. However, on my machine it was a little bit slow (my machine is known to be slow at times). I have the Solution Explorer active tracking turned off because it gets annoying when you are jumping from one file to another. With the addin, I can tell Visual Studio when to do the active tracking. Try it, let me know what you think.

The latest version can be found here.

Refactoring from Active Record to Repository

2006-05-14T19:46:00.000-04:00

In the begining of our project, we started with a Repository like pattern for retrieving our entity objects. Our repositories were muddled, and at times, contained a lot of our business logic. We followed the basic pattern to create a repository for each entity object. It produced a lot of duplication because many repositories shared many very similar operations. The result was a confusing system, and made retrieving entity objects harder than it has to be. We decided to refactor to Active Record because we thought that will solve all our problems.

Active Record pattern made testing harder because static methods can not be polymorphic. Recently, we are leaning more towards repository pattern again, but we want to design it right this time. Repository will definitely alleviate testing. On top that, it will also allow us to cache data in a simple and centralized manner.

One thing that is not clear to us is which entity object receives a repository. Ideally, we do not want to create a repository for every entity in our system. In Domain-Driven Design by Eric Evan, he talks about using Aggregate to eliminate the need for creating a repository for each entity object. Aggregate is a group of associated objects that will be treated as a single unit. The root aggregate is an object that will encapsulate all associated objects. The client will have to retrieve the root in order to communicate with any objects inside of the root. Only entity objects will receive a repository is the root.

I think we are on the right path, but more disscusion is required to fully understand the implication of moving toward a full blown repository pattern.

Popup Advertisement

2006-05-14T19:40:00.000-04:00

Recently someone mentioned that there was a popup advertisement on my blog. I was unaware of it at the time, and it should be removed by now. I believe the popup was caused by some JavaScript I added for traffic statistics. If the popup is still occurring, please let me know.

Dynamically Disable Controls on the Fly

2006-05-06T23:28:00.000-04:00

In an earlier post, I mentioned we are starting to look at how to implement role based security in our Smart Client application. Since we are using CAB, it allows us to dynamically load modules on the fly without much effort. We need more control of the UI than just preventing users to see certain parts of the software. Ideally we would want to be able to restrict the UI at a more granular level, the control level. Traditionally, people accomplished this by adding if/else statements to the UI. This method can get messy very fast, and it is very hard to maintain. Before I go on, I would like to thank Chris Holmes (the guy who wrote the first version of the Outlook Explorer bar before Matias Woloski) on sending me so many userful links and ideas regarding this issue.

Irena Kennedy has a great article on how role based security can be accomplished at the control level using attributes. The article can be found here. The article assumes that you are using CAB and AzMan, but the concept is not exclusive to these technologies (It is worth to note that AzMan requires COM interop, so the performance hit has to be considered). It works by decorating the control you want to behavor differently based on user's role. For example, if you want only the manager to have the ability to delete users, you would declare the following attribute on the button:

[Authorization("DeleteUser", "Enabled", False)]

DeleteUser is the operation that is defined in AzMan, and in this case the operation will be associted with the manager role. If the user is not in the role, the button will appear disabled. The code that is acutally doing all the work lives inside of CAB in the RootWorkItemInitializationStrategy.cs. The good thing about this is the logic is isolated in one place, but the down side is we will have to remember to modify CAB code whenever a new version is released.

Databinding is EVIL

2006-05-05T20:24:00.000-04:00

Ok, I am officially done with databinding. Today I was working with Steve on a piece of fairly trivial code, all we wanted to do was dirty checking on a few controls and provide the ability to roll back on a simple form. We poked around in the designer, and clicked here and there, then changed a couple lines of code. Overall it was very annoying, and very repetitive work because the databinding was acting flaky. Eventually we got the dirty checking on a modal form to work correctly. Before we checked in, we smoked the application real fast just to make sure everything was still working. We clicked around for a few seconds, we noticed the dirty checking was not working correctly sometimes, but we could not pin point the exact cause. By chance, we figured out the problem. If we move the modal form around on the screen after changing a value in a combo box, databinding goes nuts which breaks the dirty checking. For the most part of the day, I thought I was high because one second databinding was working, next it was blowing up.

We have been feeling the pain on databinding for a while now. I even wrote databinding on our house of pain white board, when I thought I understood databinding. We decided to stick with it because datatbinding makes things "look" so easy. It is like magic. The problem with databinding is it makes something that is very comoplex under the covers to appear stupid simple. Almost every example found in any book or on the Internet uses databinding. It seems databinding is the way to go. Databinding works fine if you have very simple UI that does nothing but display data in a primitive way. Soon as you introduce complex and rich UI, databinding makes things much harder. If databinding is so easy to use, why is Brian Noyes' book "Data Binding with Windows Forms 2.0" 696 pages? There is a lot more to databinding than what meets the eye, which can lead to some serious disconnect between team members. This can often lead to dangerous situations when the wrong assumptions are made. Before you know it, you are adding hacks, so databinding would work correctly as you would expect.

The predictibility of databinding is very low because not all controls behave the same way when databinding is used. Duplication is one of the worst things you can do in any program. The concept of what value the control is displaying is duplicated. For example, if you want to retrieve data in a combo box, do you get it from the binding source or from the control it's self? The worst part of all is the value displayed in the control can be out of sync with the underlying binding source.

I hope this does not sound like I am ranting, because I am not. Maybe I am old fashioned, but manually populating the controls will be much easier and more understandable. On top of that, the code will be more testable. Less magic is a good thing.

Role Based Command Authentication With CAB

2006-05-04T08:55:00.000-04:00

At work, we've been having some conversations about the security architecture for our Smart Client. Specifically, we talked about using Authorization Manager (AzMan) to define roles within our application. I personally have no experience with AzMan, so I decided to google it. I found a couple of useful articles on Mariano Szklanny blog on CAB role based authentication. One of them is using AzMan.

CAB - Adding Command-level security to applications
CAB - CommandAuthorization AzMan Sample Application

.NET BigInteger and BigDecimal

2006-05-03T08:38:00.000-04:00

I always wondered why there are no classes that represent big integers and decimals in the .NET API like the classes found in Java. Apparantly, as Greg pointed out in his post, the BigInteger and BigDecimal exists in the J# redistributables. It lives inside vjslib.dll. I guess my question is why does it lives in J# redistributables, and is it safe to use in any .NET application? BigInteger or BigDecimal can be very useful to any financial or mathematical application. You would think they would not hide it in the J# redistributables. Who uses J# anyways? ;)

Aardvark'd

2006-05-02T23:16:00.000-04:00

We all know Joel has a great blog, published a couple of great books, but on top of that, he owns a great company. What else can a geek do after these accomplishments? How about an indenpendent film? Aardvark'd is a documentary on last summer's interns at his company, Fog Creek. I checked out the trailer, it looked interesting, but it is a little short in my opinion. What will Joel do next?

Rethrowing Exceptions

2006-04-30T22:46:00.000-04:00

It is very common to see code that catches an exception then rethrows it without doing anything. Pieter Gheysens has a post on why you should not just rethrow the exception.

Lazy User Interface Part III

2006-04-25T22:53:00.000-04:00

Lets start with our fictitious application from the TDD approach; write the tests first, and let the tests drive our design. This time I will start from the presenter level to ensure all the UI functionalities are testable. Before we start I would like to share the overall structure of the application, then I will touch more in depth in necessary areas. Let take a look at all the files listed in the solution explorer. All the files requiring the application to run are in the RealtorApplication project, and the other project is only for automated testing. Each view implements a specific interface. For example, CustomerView will implement ICustomerView. Each view has a property for the presenter to be injected as such:



public CustomerViewPresenter Presenter {
 get { return this.presenter; }
 set {
   this.presenter = value;
   this.presenter.View = this;
 }
}

The RealtorPresenter takes in an IRealtorService because when the button is pressed on the NavigationView, the RealtorPresenter needs to retreive data from the service. You can think of the service as a facade for where the data should be retrieved in this case. I am going to use DataBinding, so CustomerView and RealtorView will have their own BindingSource and it will be exposed as a property.

In the test project you will notice there is a folder for all the mocks. I am only interested in making the view testable, so it is safe to mock everything else. Lets start with the NavigationView because that is where the user interaction will happen first.

namespace RealtorApplicationTest {
 [TestFixture]
 public class NavigationViewPresenterTest {
   private NavigationViewPresenter presenter;

   [SetUp]
   public void SetUp() {
     presenter = new NavigationViewPresenter();
   }

   [Test]
   public void CanNotifyNavigationViewWhenButtonIsClicked() {
     EventSubscriber subscriber = new EventSubscriber();
     presenter.LoadData += new EventHandler(subscriber.Handler);
     presenter.NotifyNavigationView();
     Assert.IsTrue(subscriber.HasBeenCalled);
   }

   [Test]
   public void NotifyNavigationWithNoHandler() {
     EventSubscriber subscriber = new EventSubscriber();
     presenter.NotifyNavigationView();
   }
 }
}

We start with these two simple tests. The first test ensures that the presenter will fire an event when the button is clicked . The second test makes sure no exception are thrown when the event is not being handled. EventSubscriber is just a helper class that allows me to test if the event gets fired.

When practicing TDD, it is very important to make the test fail before you make the test pass. Since all the tests are passing, we can wire up the event to fire when the button is envoked in the NavigationView.

private void loadButton_Click(object sender, EventArgs e) {
 presenter.NotifyNavigationView();
}

Lets move on to the RealtorViewPresenter and write a test before we run the application.

namespace RealtorApplicationTest {
 [TestFixture]
 public class RealtorViewPresenterTest {
   private RealtorViewPresenter presenter;
   private MockRealtorView view;
   private MockRealtorService service;

   [SetUp]
   public void SetUp() {
     service = new MockRealtorService();
     view = new MockRealtorView();
     presenter = new RealtorViewPresenter(service);
     presenter.View = view;
   }

   [Test]
   public void HasTheServiceBeenCalled() {
     presenter.OnLoadData(this, EventArgs.Empty);
     Assert.IsTrue(service.HasFindAllRealtorsBeenCalled);
     Assert.IsTrue(view.HasBindingSourceBeenCalled);
   }
 }
}

When the RealtorViewPresenter receives the event it should call FindAllRealtors() and set the databinding on it. The two asserts ensure that happens. The LoadData event should be wired to RealtorViewPresenter.OnLoadData(). Everything so far has been very basic. I will continue with the rest in the next few days.

Lazy User Interface Part II

2006-04-23T22:49:00.000-04:00

In order to make the application testable, proper separation is required. I will be using MVP pattern to separate out the tiers. MVP is a derivitive of MVC, the only difference is the View only communicates with the Presenter, and the Model only knows about the Presenter, not the View. I personally like MVP better because I think it is a little cleaner when the Model does not know about the View.

Since I have been shopping around for a house, I decided to make this superficial real estate application. The actual structure of the application and the data it holds are irrelevant, that is why they are over simplified. The import thing here is the interactions between objects to make the code testable. I might update the UI to make it more "realistic" later if it requires it.

Before we start, let me explain the basic layout of the UI. There are three views, and one presenter per view. The view on the left is the NavigationView. The purpose of it is to load fictitious data into the top right view which is the RealtorView. When the user selects a realtor from the RealtorView it will show all the customers associated with that particular realtor. For those who noticed the title of the article, Lazy User Interface is refering to making the view as lazy as possible by delegating everything to its presenter. I will start coding the lazy UI in the next post.

Lazy User Interface Part I

2006-04-23T10:54:00.000-04:00

I was recently working on code that deals mostly with the front-end portion of our software.
Before I began the task, I glanced over the wire frames, opened up the designer, dragged and dropped a few controls here and there, changed a few properties, and added some methods to handle the business logic. Before lunch, the task was complete.

Something just did not feel right about this task. I noticed that the time I spent writing and running unit tests was significantly less than usual. At first I dismissed the thought because I convinced myself most of the code was UI related, so no need to test. After work, I decided to take another look. I started at the presenter level (we use MVP pattern), and noticed very little code was in the presenter, and the view seemed to be much larger. Since we practice TDD at work, how could this happen?

Part of the problem was that I started the code at the UI level instead of the presenter level. The problem with starting the code at the view level is because everything seems to belong inside the view. For example, when the user right clicks on the grid, it will show a context menu and the items enabled in the context menu are dependent on what the user has selected on the grid. Pretty simple scenario, right? When I worked on this part, I enabled the context menu items in the view because it seems like the view should be responsible for it. After all, context menu it is a visual thing. In order to figure out which context menu items to enable, I need to figure out what the user has selected. How can the view retrieve the data? Oh wait, the grid is DataBound. Perfect! All I have to do is peak at the BindingSource to figure out which context menu to enable. The problem now is that I do not have unit tests to prove the context menu is correctly enabling the items. Since all the code lives in the view, I have no way to tell what is enabled in the context menu without spinning up the view.

If I start at the view level a lot of the code seems to belong in the view instead of the presenter. There is nothing wrong with adding code in the view, as long as it does not stop you from writing unit tests and has proper separation. The view should be responsible for all UI renderings such as popping up a message box or drawing something on the form. Everything else, in my opinion, should belong in the presenter which makes the code testable. In the next few posts I will use a simple application to address how to write testable UI using the MVP pattern with TDD.

Internet To Go

2006-04-17T20:44:00.000-04:00

We are so used to having fast Internet connection whenever and wherever we want, it can get very irritating when that is not available to us. I found this cool free utility today that allows you to save any Internet content on to your laptop or mobile device. Yeah sure, you can manually save any web page on to your laptop, but if you want to save the whole site it might not be possible when there are thousands of external links to other websites. Webaroo comes to your rescue. You can add a URL to Webaroo, and it will traverse all the links for you, so any link off the website will still work offline. I saved Joel Spolsky's whole website on my hard drive and it took four megabytes. Webaroo also provides an interface that allows you to synchronize with all your local versions of the website.

This tool is ideal for anyone who travels a lot because now you can surf your favorite website or corporate Intranet even on the airplane. Since all the pages are saved to your local machine, you can even use it to back up any content you have on the Internet too.

Quality With a Name

2006-04-11T22:03:00.000-04:00

I felt honored to be one of the first few to read the latest insightful essay written by Jim Shore: Quality With a Name. Since I proof read the essay prior to Jim publishing the post, I do expect my royalty check to be arriving any day now, and yes I do charge interest Jim :) With all the joking aside, this article should be read by any serious software developer. The quality of a good design is a topic that has been explored since the begining of software development. Jim arrives at the conclusion of what a good design is in a concrete and rigorous manner. It just got nominated for inclusion in Joel Spolksy's "Best Software Writing II", need I say more? Enough talk, go read it, and maybe my check will come sooner.

Ruby in .NET?

2006-04-10T21:18:00.000-04:00

With Generics in .NET 2.0 more possibilities are availble, such as Ruby like closures. Michael Stal has a great posting on Simulate Closures in C# 2.0, so I decided to try it myself.

class Program {
 static void Main(string[] args) {
   int[] ints = new int[]{2,4,6};
   string[] strings =
     new string[] {"a", "b", "c", " ", "A", "A", "R", "O", "N" };
   // output is 12
   Console.WriteLine(Collector<int>.Collect(ints, Add, 0));
   // output is 14
   Console.WriteLine(Collector<int>.Collect(ints, Add, 2));
   // output is Dabc AARON  
   Console.WriteLine(Collector<string>.Collect(strings, Add, "D"));
   Console.ReadLine();
 }
 static int Add(int res, int parm) {
   return res + parm;
 }
 static string Add(string string1, string string2) {
   return string1 + string2;
 }
}

public class Collector<T> {
 public delegate T CollectDelegate(T temp, T parm);
 public static T Collect (ICollection collection,
   CollectDelegate collectDelegate, T initVal) {
     T res = initVal;
     foreach (T elem in collection) res = collectDelegate(res, elem);
       return res;
 }
}

Subersion Offline Revert

2006-04-04T21:52:00.000-04:00

Sometimes when I am refactoring, I get led down the wrong path. It is easier to start over with fresh source code then try to dig a bigger hole for yourself. In the past, I would just simply hunt down those files and delete them and then do an update. It works fine, but it takes too much time trying to figure out what I have changed. Just simply doing a revert in your sandbox is much more efficient. Recently I have noticed files can be reverted without having a connection to SVN. This is a really useful feature when you do not have Internet connectivity or do not want to deal with slow VPN connection. It is very obvious that connectionless revert is possible since SVN stores all your changes locally in the .svn folder, but for some reason it never occured to me to try it.

One Week Iterations

2006-04-01T21:50:00.000-05:00

Recently we decided to do an experiment by reducing our iteration duration from three weeks to one week. We have been having trouble providing accurate estimates on stories during a three week iteration. Sometimes I feel it is hard to accurately estimate a story that is dependent on other stories that we have not done. Some stories may look like a story you have done before, but you are never sure until you try it.

It is crucial that we have accurate estimates for all stories because incorrect estimates can lead to false expections. The idea behind a one week iteration is that we get to practice our estimation skills more often. We also made the stories much smaller, so we can still fit a few stories within the week. I have to admit, I was a little skeptical in the begining.

To my surprise, one week iterations actually worked out really well! Since all the stories are much smaller, it is much easier to estimate accurately. Smaller stories also mean that everyone can work in various parts of the system more often. When we used to do larger stories, sometimes a pair would get stuck in one part of the system for days. It can be frustrating at times when we encounter a road block. On top of that, it is very easy to lose contact with other parts of the system if one does not see it often. One week iterations definitely make the work more pleasant and exciting.

In the begining, I thought one week iterations would slow us down since we have to estimate once a week. It usually takes us two solid days to estimate all the stories during a three week iteration. If it still takes two days to esimate during a one week iteration, we would never get anything done! It turns out we can estimate much faster during a one week iteration since all the stories are smaller, and therefore, more visible.

Overall I really enjoy working on one week iterations. One week iterations might not work for all Agile teams, but it has worked well for us so far.

CAB Workspace Flickering

2006-03-23T19:20:00.000-05:00

Delarou has a great post about how to prevent the flickering when you switch between Controls in a CAB workspace. This happens because the Controls are drawn while it is initalizing. With his trick, it will only redraw after Controls have been initalized. He basically extends a workspace and overrides the default behavior. Pretty cool trick.

Smart Client Baseline Architecture Toolkit

2006-03-22T23:17:00.000-05:00

At work I am working on a team that develops a Smart Client application with Composite UI Application Block (CAB). We have been struggling to figure out the best way to leverage CAB within our software. We started the application out with the basic MVP pattern and slowly we fused CAB into our software. In the beginning, we started out with a presenter communicating with multiple views in a CAB module. That turned out to be problematic when we tried to coordinate actions across views. From a TDD point of view, it was also a pain to inject multiple mock views into the presenter. At times we feel the mock views have to be almost as smart as the real views.

Recently a couple of my colleagues went to Redmond and worked with the CAB team. They brought back many useful insights on the best practices for CAB. One thing I think will be very useful is the Smart Client Baseline Architecture Toolkit (SCBAT). SCBAT automates a lot of daily CAB mundane tasks to increase productivity. For example, you can create a new Smart Client project in VS 2005 with all the recommended organizations with one click of a button. New context menus are also added for creating a view with a presenter, and create a new CAB module. But you say: "Wait, I like to organize my Smart Client application differently....". Not to worry, you can tweak the automation to your needs using Guidance Automation Toolkit (GAT).

Before you install SCBAT, there are a couple of prequisite packages:

Guidance Automation Extensions - Run time component that is required to run Guidance Automation Toolkit.
Guidance Automation Toolkit - Create customized "Guidance Packages" for developers.

Of course, you must have CAB and Enterprise Library installed already. Open the Guidance Automation solution from the location where SCBAT is installed. Compile the solution and installer project. Run the installer and you should be done.