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.

Smart Client

2006-03-21T19:38:00.000-05:00

I remain in touch with people I went to college with, and people I used to work with. Many of them are not working in the Microsoft world, so whenever I mention Smart Client, they usually have no idea what I am talking about. "Smart Client? Do you mean Thin Client?" No. Here is the generic definiation of Smart Client from Microsoft:

Smart client (n) Definition: Smart clients are easily deployed and managed client applications that provide an adaptive, responsive and rich interactive experience by leveraging local resources and intelligently connecting to distributed data sources.

In simple terms, Smart Client has a rich look and feel of native applications, and simple deployment like a Web application. A real world example of a Smart Client is Outlook.

Aspect Oriented Programming

2006-03-20T23:20:00.000-05:00

As a software matures, it is normal to see duplication in concepts across a few objects. It is a very normal phenomenon in any software. Any good Agile developer will tell you this is an opportunity to refactor out the duplication. Sometimes, however, things are not as easy to refactor out as one might think.

In our software, we use ORM engine to map our domain objects back into the database. The domain objects do not have the knowledge of the database. So when an object needs to be retrived/saved/deleted from/to/from the database, we delegate it to a "manager" object. For example, Car object can be retrieved from the database by calling the CarManager object with a specified criteria.

At first glance, this looks like a good solution because we are separating out the responsibilities. Ok, fine. As time goes on, a few more domain objects are added, so you also add a few more "managers". Every time a "manager" is added, one will notice that very similar work has been done elsewhere.

One simple solution is to have a "generic manager" that can take in any domain objects. That actually will not work either because some methods in the "manager" object cannot be generic.

I am not sure what the best solution is to this problem. Tonight I just so happened to come across Greg Young's post . He is doing a presentation on AOP with very similar problems as I described above. Too bad I can not attend because it takes place in Atlanta, which is too far away from Philadelphia :(

Singularity

2006-03-18T15:12:00.000-05:00

Singularity is a research project at Microsoft. The goal of Singularity is to build a dependable Operating System using Managed code. The whole OS took about 18 months to develop, and it was developed using a stripped down version of C#.

I came across a couple of interesting analogies when I was reading the presentation slides for Singularity.

"If cars were more like software..."
"Customer service said the seat belt light might turn off if we re-install the engine oil."

"If phone systems were more like software..."
"To reach that number, you need Long Distance Version 2.6.19. Which version do you have?"

The philosophy of Singularity is to make an OS more dependable by making it more predictable. I am glad not everything in the world right now is "more like software" ;-)

If you intested in Singularity, here are a couple of videos from channel 9.

Override Default .NET Configuration File

2006-03-18T00:50:00.000-05:00

In the .NET world App.config is the standard configuration file for an executable. During the compilation process, the compiler will copy the contents App.config into a file with the same name as the executable with .config concatenated in the end.

The common side effect of this configuration structure is the duplication of App.config when multiple executables are being deployed to a machine that shares common DLL. One way to solve this problem is to override the configuration file by using the following:

AppDomain.CurrentDomain.SetData("APP_CONFIG_FILE", @"c:\some_path\someConfig.config");

Just make sure to execute the line above before you read the configuration file. The contents of standard configuration file in the bin directory (programName.exe.config) will remain the same because the compiler is unaware of the code during compilation time.

Bookpool

2006-03-17T19:33:00.000-05:00

In my opinion, Bookpool is the best place to purchase technical books. I prefer it over Amazon because the price is always better. I always load all the books I want into both shopping carts and Bookpool always beats Amazon by $5 - $30. The reason I am plugging Bookpool is because I ordered another batch of books tonight. I have been mooching off the library at work too long, so I decided to purchase my own copy. I have read most or parts of the first four titles, they cover a lot of foundational material. I would recommend them to any serious programmer.

Comparing Value Types

2006-03-13T22:04:00.000-05:00

Value types are commonly used in any meaningful application. People will often implement a static function to compare value types instead of overriding Equals(). Tim Watson has a great post about this with very clear examples. I will not duplicate his work; however, I will provide a condensed version here. I do encourage everyone to read it though.

In the OOP world, an Object contains data and behavior. If you have any questions about the Object such as "Are you equal to another Object?" it should be directed to the Object itself. By providing a static method, it is a procedual way of thinking, even if you implemented the static method off the Object itself.

Additionally, Equals method is the convention in the OOP world for vaule comparrison. If a static function is implemented, people probably will not know it exists (Assuming they are OOP programmers :)

The most important reason to stay away from a static comparrison function is because the Object can not be used as keys for a hashtable. It requires Equals() and GetHashCode() to be implemented.

Winform Catch All

2006-03-12T19:12:00.000-05:00

It is very common for an application to show a user friendly error message with a consistent look and feel of the application when the application bombs out. The simplest way to accomplish this is to pop up a Winform when the application encounters an exception. How can we be sure to show the Winform when the application throws an exception? Put try-catch around Application.Run() then pop up the friendly error Winform inside the catch? That actually will not work for Winform applications because Winform has its own exception handling mechanism which causes the error message to be shown in a unfriendly manner. Worst of all, it will not actually run anything inside of the catch.

If you try the example used above inside Visual Studio, you will notice the code inside of the catch does run even when an exception is thrown. The short answer is Winform application behaves differently inside VS. If you try it agian by clicking the executable you will get a different result.

The correct way to achieve this is to handle the Application.ThreadException event. Inside ThreadException event handler you can show your ultra friendly error message to the user.

Null Coalescing Operator

2006-03-12T02:00:00.001-05:00

Code readablility is subjective, and it often depends on personal style. Some people think the use of ternary operator makes the code hard to read. .NET 2.0 has a new operator that is similar to the ternary operator. The two lines listed below are symonymous:

someBusinessObject ?? new someBusinessObject();

null == someBusinessObject ? someBusinessObject : new someBusinessObject();

You do not have to check for null anymore, it is built into the operator. So is this operator readable? I have to admit, I really like it.

Code Smell with .NET Region Directives

2006-03-11T22:18:00.000-05:00

The term code smell is often used in the software development world to describe code that is possibly structured improperly. The symptom of a code smell is when the code is hard to comprehend and modify which often leads to code duplication. The code smells usually result in hard to find common nasty bugs. As a software developer, it is our best interest to stay away from code smells to reduce software debt.

In the .NET world, many developers use the region directive to hide complexity. It is used as illustrated below:

#region "Import Logic"
/*
Many lines of code here....
*/
#endregion

If you are using an IDE like Visual Studio, you can collapse all the code in between a region directive with a single click. There is a certain code smell associated with regions when it is used blindly. If a class' logic needs to be hidden for any reason, chances are it has too many responsibilities.

In the OOP world each class should only have a single responsibility. That is not to say that regions do not have their place, but it is often over used because it is easier than trying to refactor the code. One thing I also noticed is that many regions' names usually describe a responsibility of another class (Import Logic as used in my example). That is definitely a sign of code smell because the class could possibly delegate the responsibility to another class.

Subversion

2006-03-08T23:52:00.000-05:00

Lately we have been having tons of problems with Visual Source Safe which at times, slowed down our development. The problem that caused the most down time is the merge feature. It should be called "replace" instead because it does a replace randomly when merging. Last week VSS finally blew up, so we buried it.

We decided on Subversion because many of us have used it before. Plus it is Open Source, so what do we have to lose? It took us no time to set up the repository, and show people how to use it. We use TortoiseSVN, so we can perform daily source control functions effortlessly.

TortoiseSVN integrates nicely into Windows Explorer. It uses icon overlays to signify items under source control and the state of the file. I really like this because I can tell the state of the file just by browsing the file system. Once you retrieve all the files, it does not synchronize with the server until you commit your changes. When you commit, it will only transmit the bytes that have been changed. It basically does the opposite of what VSS does.

It used to take about 30 seconds to open our solution because the solution was bound to VSS. It takes less than 10 seconds now. Our Cruise Control build went from 4 solid minutes to 35 seconds.

Overall we are very happy with the switch. Subversion is really fast compared to VSS, and it offers a wider range of features. I would definitely recommend anyone to stay away from VSS if possible. I think it is very ironic that VSS has the word "Safe" in it. If you would like to learn more about Subversion, Pragramic Version Control Using Subversion is a great book to read.

Back to Basics

2006-02-28T19:49:00.000-05:00

In the last post, I discussed the importance of communication during a white board design session. Communication goes beyond verbal. There are tools out there that can help you convey your ideas in a rigorous manner. Are you ready for this? You better sit down and take notes. Unified Modeling Language. I am sure UML is not new to anyone that has done any kind of programming, at least I should hope not.

I know what you are thinking: "I thought people on an Agile team do not produce heavy documentation because that is what UML is used for". Yes, I agree that full blown UML can get very hairy. However, UML does not imply heavy documentations.

Continous design can still be achieved using UML. Well, you may be wondering what is so good about UML that I do not already know? Probably nothing. People tend to use non-standard notation during an informal white board design. This can be problematic because it allows room for derivation.

I would not waste time on learning ALL UML notations (if you do not already know them) because all you need is a very small subset of UML to communicate clearly. Pretty much all you need to know can be found on this UML Reference card (plus more). We started to use only Class Diagram notations during a white board design because it effectively describes relationships.

Wire It Up!

2006-02-25T23:14:00.000-05:00

I have been saying "Wire it up" a lot at work, so it is only natural for me to use it in my daily non-computer related vocab.

People sometimes ask, "What does it mean?" Maybe people ask because I usually snicker after I say it. The phrase came to me during a few of our white board design sessions at work when I noticed a trend. During those sessions, sometimes people would use very generic, broad termonology to describe a complicated process, and draw boxes to cover all the implementation details. After a couple of sentences, the conversation is usually wrapped up by saying "You just wire it up". This approach is fine as an overview, but often more concrete details are required for everyone to get on the same page.

Basically, I use the phrase "Wire it up" when someone tries to cover all the details by using a very high level approach. The purpose of this post is to point out the importance of communication during white board design sessions. I just think it is important to find out what people do not know and try to provide more details in those areas in a non-critial way.

Visual Studio Automation

2006-02-24T22:33:00.000-05:00

We use Code Smith at work to generate ORM objects. It works really well, but there are several steps involved for the code generation process. Although it can get tedious at times, the process is fairly straight forward. One of my colleagues automated the process uing a console program. It made the process so much simpler and faster. The only thing I did not like is having to open a console and run the program outside my development environment. Maybe I am just lazy. I want to generate my objects by just clicking something in Visual Studio. I have never done any work using Visual Studio Automation before, so I decided to do some research.

To my surprise, there is very little information on the web about VS Automation, even on MSDN. The most helpful information I found was the VS Automation samples released by Microsoft. By looking at these samples and using intellisense, I figured out the basics. I was able to create the Addin for ORM object generation in a few hours of playing around.

When I think about a simple development automation tool, a console program is usually used. After finding out how simple it was to create a plugin for VS, I will choose it over a console program from now on.

Working on Your Weakness

2006-02-19T18:35:00.000-05:00

Steve pointed out an interesting blog entry by Kathy Sierra, co-arthur of Head First books, on being f'n amazing. I will give you the short version of the blog here, but I do encourage everyone to read it. She basically states that working on your weakness often leads to mediocrity which will cause you to give up the chance to be f'n amazing. I do agree with Kathy because it is impossible for anyone to be good at everything, especially in the technology world. Rather than working on your weakness, one should strengthen their strengths, and in turn, become f'n amazing. Kathy pointed out a couple of books in agreement with her post, but she has not read them yet. Those books sound interesting, so I will be adding them to my reading list.

DateTime ParseExact

2006-02-15T22:40:00.000-05:00

One of my co-workers on the legacy team was working on a bug fix for our Japanese customer today. Not sure on the exact scenario because I was not the one that tracked down the bug. Basically the software bombed out when the code tried to parse a string into DateTime object on a machine with Japanese settings (I think it works fine if the machine is setup with US settings).

All the dates are stored in Day-Month-Year format separated by hyphen and a space before and after the hyphen. For example, December 31st 2006 will look like the string below:

31 - 12 - 2006

He wanted to know the best way to parse the string without doing custom string manipulation before parsing it. He played around with Parse function on the DateTime class, but he could not figure a way to parse the string without it throwing an exception. The solution is to use the ParseExact static function on the DateTime class because it allows you to specify the exact formats you want to parse, and nothing else. The code listed below shows how the ParseExact function can be used:

// set it to Japanese culture, and allow the user machine to override it.
IFormatProvider format = new System.Globalization.CultureInfo("ja-JP", true);

// noticed it's not dd because dd will fail if a single digit day is used, d will work for both.
string[] expectedFormats = {"d-MM-yyyy"};

DateTime dt = DateTime.ParseExact(
"31 - 12 - 1891",
expectedFormats,
format,
System.Globalization.DateTimeStyles.AllowWhiteSpaces
);

Console.WriteLine("Parsed DD/MM/YY: {0}", dt.ToString("d"));

There is a really good reason why everyone should use ParseExact over Parse on the DateTime class. The Parse function on the DateTime class tries to be really smart about the string you passed in, so you might get unexpected results when it tries to be too "smart". For example, 1/2/2006 should it be Janurary 2nd, 2006 or Feburary 1st, 2006? Should it throw an exception, if so, which one is valid? ParseExact will only parse the way you told it to, so the performance is a lot better. Some things are just meant to be stupid.

40 hour work week?

2006-02-04T21:59:00.000-05:00

As you all know, I'm a member of an Agile team using XP methodolgy. We are building a financial application using many of the latest technologies. Since all the technolgies are fresh out of the oven (some are still in the oven), we spent a lot of time on figuring out the best ways to leverage each technology. We have been doing a fair amount of overtime every week, so we can get a reasonable amount of work done in an iteration.

XP methodology promotes a 40 hour work week because one can not do good work if they are not well rested, as stated in Kent Beck's XP book. We spend a lot of time learning new technologies, and by the time we learn it (ususally late in the week) we have to implement it quickly. This approach could cause bugs, and lower quality software. Of course, eventually we will be up to the speed with all the technologies we use. Before we get to that point, we are building up a lot of debt in our application. It's going to take some time to clean up all the problem

Where do you fit in learning new technology in a 40 hour week? I'm a firm believer that in order to do good work your mind must be clear and fresh. Maybe the solution to the problem is to include "learning" time into the estimate. Since we are not familiar with the technologies, sometimes it's hard to predict amount of time needed.

We started a new iteration by making the stories much smaller. This seems to be helping because each pair has to figure out less. This is also good for the team because we are spreading the knowledge thinner cross the board.

Fo' shizzle my nizzle

2006-02-02T21:58:00.000-05:00

I know my blog can be really boring at times. Today I found a way to spice up any dull websites. Just run it through Gizoogle. It works just like google except it converts all your search results into rap songs that Snoop can be proud of. You can read Gizoogle version of my blog here.

Database Migration with Ruby on Rails

2006-01-23T23:02:00.000-05:00

Our application will eventually have to support multiple databases like many other applications. Managing schema for multiple databases can be really tricky. One simple solution is to write DDL for all the supported databases. This is a very time consuming solution if you are supporting 2 or more databases. On top of that, how do you keep track of the version of the DDL for each client (some of our clients require custom schema) once the software is deployed?

Ruby on Rails has a clever way of handling database migration. But wait! We are building a Smart Client application, not a Web application. ROR database migration is useful even if you are not doing a Web application. If you have no idea what ROR migration is about, you should watch this video. Right out of the box, it didn't do exactly want we wanted, so we had to tweek it by adding some code. Thank God for Open Source projects.

By default, ROR migration doesn't handle Stored Procedures because ROR projects use the built in O/R mapper. That's no big deal to us because we are using Wilson O/R maper, so we don't mess with Stored Procedures anyways.

Steve has a great artcle on ROR migration. He does a much better job explaining it.

Philadelphia Agile Users Group

2006-01-17T23:19:00.000-05:00

Today I finally made it to my first Philadelphia Agile Users Group with my coworker. We got there a little bit late, so we didn't get a chance to talk to everyone before the meeting. We did a "Fishbowl", and the concept is very interesting to me because I have never seen it done before.

For those of you who don't know what a Fishbowl is, I'll try to describe it as best as I can. Basically, you setup four seats while everyone gathers around the seats. Whoever sits down first gets to start the topic, and whoever wants to join the conversation must sit down in the empty seats. When all the seats are occupied one person must get up and stop participating in the conversation. So basically the conversation carries on even when one person leaves. This is interesting because it gives anyone who wants to participate a chance to talk. I think overall it was an good experience, but it could have been better if we could have made it earlier. Maybe next month we can go earlier, so we can get a chance to talk to everyone before the meeting starts.

DataGridView Adventure

2006-01-16T12:50:00.000-05:00

DataGridView is a new feature in .NET 2.0, it is supposed to replace DataGrid one day. Recently I have been playing around with DataGridView a lot to extend some specialized features for work. However, I ran into a road block when I tried to retrieve the area of a displaying row.

I tried to use GetRowDisplayRectangle(int rowIndex, bool cutOverFlow) to get the current Rectangle of a row. For some unknown reason it never returned the correct size no matter how many columns I have in the DataGridView.

If you are new to DataGridView but not new to DataGrid, here is a document that does the comparision and explains some of the new features.

SharpDevelop

2006-01-10T23:14:00.000-05:00

SharpDevelop is an open source IDE for .NET. It is a great tool to use if you don't have Visual Studio on hand. Maybe it will be as good as VS one day. I downloaded SharpDevelop2, which is compatible to .NET 1.1 and 2.0. I was very impressed on how far this open source project has come along since I looked at it last year.

SharpDevelop2 has many features similar to VS 2005, but not all. It is worth taking a look at, if you haven't already. I really love the NUnit integration found in SharpDevelop2. It would be great if VS 2005 had the same integration.

I didn't really play around with it very long because it crashed shortly after I tried to open a VS 2005 solution from work. I'm sure not all the features of VS 2005 have been implemented. That is probably the reason for the crash.

I'm sure in a few months all the features of VS 2005 will be implemented. I hope so.

ANTLR

2006-01-09T23:10:00.000-05:00

ANTLR, developed by Terrence Parr, is a great tool to generate Lexical and Syntactical analysers. It is useful if you want to build some kind of translator or compiler. It will generate all the code for you in various languages, (Java, C#, C++, and Python) if you can provide the EBNF grammar.

I haven't had a chance to build something useful with it yet, but hopefully I can in the very near future.

Ashley J.S Mills has a great ANTLR tutorial that can be found here.

IL Merge

2006-01-08T23:25:00.000-05:00

Today I saw a neat tool called IL Merge. It merges multiple assemblies into one single assembly. This might be pretty useful for deployment when you have a lot of assemblies.

Don't Have Time for more Information?

2006-01-07T18:41:00.000-05:00

I am a pretty lazy reader, so I found ITConversations an easy way to get more information, just drop it into my iPod and listen. Here are some of my favorite conversations:

Paul Graham - Great Hackers
Alistair Cockburn - Agile Software Development
Kent Beck - Developer Testing
Joel Spolsky - Joel on Software
Steve Wozniak Part 1
Steve Wozniak Part 2

DateTime Trick

2006-01-05T23:04:00.000-05:00

Rencently, one of my co-work showed me a pretty cool DateTime trick. I needed to retrieve data for a given day from the database.

DateTime startDateTime = DateTime.Now.Date;
DateTime endDateTime = DateTime.Now.Date.AddDays(1).AddMilliseconds(-1);

Pretty cool, huh? Well, I like it =)

ClickThrough

2006-01-04T09:06:00.000-05:00

What attracted me to use WiX project in the first place? Well, I need a simple way to create MSI package for work and writing XML file is definately simple. On top of that, WiX is free and Opensource, what more can you ask for?

Last night I checked source forge, and to my surprise, there's a new tool called ClickThrough included in the WiX tool kit. I know ClickThrough is still in the beta stage, but I decided to give it a test drive.

It used to take me a good 30 minutes to create a very basic MSI package by writing raw WiX files. Using ClickThrough, it took me 30 seconds and I can update the deployed software via RSS feed. I can't wait to see what features are coming next when it's offically released.

You can find out more about ClickThrough on Rob Mensching's blog.

Automated Daily Builds

2006-01-03T13:02:00.000-05:00

Our build server slowly died during the end of an iteration, and it stayed dead for the next iteration. The reason it was down so long is because we had to wait for our IT group to re-image the machine. I hate how we don't have full control over our build server, but that's another story.

For a WHOLE iteration, we were unable to do daily builds. I wasn't too worried about it because I know the build server will be restored sooner or later.

During our next iteration planning meeting, we did a recap with the business people by demonstrating the software. Since we didn't have automated daily builds, no one outside of development had access to the latest code.

Too make a long story short, there were a lot of surprised and puzzled faces for people outside of development. We spent the whole morning explaining why certain things are done. I'm sure this wouldn't have happened if everyone could see the software on the regular basis.

Want to be a Highly Effective Programmer?

2006-01-02T19:07:00.000-05:00

The president of Technicat, Phil Chu, gives us some hints here.

Null Object?

2006-01-01T21:22:00.000-05:00

Last week I was browsing though Martin Fowler's Refactoring book at the airport, in hopes of finding a solution to a recent problem at work. I found myself reading on Null Object......

To make a long story short, I had to add a conditional branch block to each method in a class to avoid the code from doing improper calculations. If some condition is true, then return zero; otherwise, continue doing the normal calculation. The code started to smell and turned ugly fast.

By using Null Object I can hide a lot of the ugly conditional branches. I'm also a big fan of Fail Fast by James Shore. Null Object will make the code appear to be cleaner, but the code will be harder to debug if there's a logic error.

I'm not sure what path I should take right now, maybe Null Object is not what I'm looking for.

Recent Problems with FIT

2005-12-31T19:23:00.000-05:00

FIT is a great acceptance test framework; however, I recently ran into a road block at work. Our application does a lot of calculations, so we use FIT to ensure all the formulas are coded correctly.

The calculations are heavily dependent on each other. For example, A + B + C + D -E - F = G and G + H - I = J. In this simple example I'll have two FIT tables. The first table will contain all the values to calculate G. Here is my dilemma: in the second table I want to calculate J just by providing a value for G in the table. To make things more complicated, the member variable holds G or J, which are private to the class, and no mutators are available.

I want to do lazy loading and keep all the variables private without mutators; however I don't think that is possible.

I solved the problem by providing a special constructor that is only used for FIT fixture, so I can set all the variables. It works fine, but I'm no longer doing lazy loading. The calculations are done in the constructor as soon as the object is instantiated. The solution doesn't seem to be clean, but will work for now.

First Blog Entry

2005-12-30T22:42:00.000-05:00

Welcome to my blog. This is going to be my first post, so it's going to be pretty boring for a while, until I can add some meat to it. I recently joined another Agile team in the Philadelphia area using XP, so I think it's a good time for me to start a blog to capture my experiences.