.Net Ramblings

Construx recently wrote a white paper about software development’s most common mistakes. These mistakes are often called classic mistakes because they happen so frequently and have such predictable results. You can read the full white paper here (you’ll have to register to download it).

Of all the classic mistakes, the most frequent one is having an overly optimistic schedule where not enough time is given to complete a project. As I reflected on this it didn’t take me long to realize that it is also one of my personal classic mistakes.

In my first job I didn’t have much control of this mistake. Upper management personnel were the ones that set the deadlines for projects, and although my teammates and I regularly fought back and said we needed more time, the deadline was rarely extended. We were always able to meet the deadline, but many times we spent the next two to four weeks working out the bugs that were missed, and it didn’t make a good impression on our clients.

Currently I’m working at a place where I’m the only software developer, and although I am now the one that sets the schedule, I find that I also have the tendency to be overly optimistic on the deadlines, and I don’t have anyone to blame but myself. So I got to thinking why I have the tendency to be overly optimistic on project deadlines.

One of the causes I’m most prone to use is thinking in terms of how long it will take to create a working prototype of the application instead of creating production ready code with test coverage and clean, organized code. Many times I can get an application up and running within a day or two, but it doesn’t have any unit tests and the code is sloppy. It can take another week or two to clean up the code and write unit tests to get it production ready.

Another reason I find myself making overly optimistic schedules is because I base the schedule out of being able to work on it full time. However, I’m never fully able to actually work on the project full time because I get pulled into other projects and tasks.

I love playing with new tools and libraries, but I find that they are also another cause for this classic mistake. Tools usually save time on a project, but the learning curve when first learning a tool can drastically add time to the project, and I often times forget to factor in the learning curve time when deciding on deadlines. /For example, NHibernate has been a great tool I use and saves a ton of time, but the learning curve is large and it took me quite some time before I was up to speed with it.

I often like to think that I’m too good a software developer to fall into making classic mistakes, but it is evident that I’m not much different from others and have the same tendencies. But now that I know this mistake is one of my weak spots, hopefully I can be mindful of it in the future and not fall into making the same classic mistake.

I resonated with the following article by JP Boodhoo: http://blog.jpboodhoo.com/FocusOnFunAndStepIntoFreedomInYourCareer.aspx

I must admit I have lost the “fun” in programming lately and desire to get it back. One thing I’ve always wanted to do was be part of an open source project but I’ve been too timid to do so. I’ve also been overwhelmed by all the open source projects and not knowing which one I should commit to. So this past weekend I committed to working on the Fluent NHibernate project. This project allows you to make NHibernate mappings in the code, where it is compile-safe and has refactoring ability, instead of using the hbm xml files. I’ve used it in a couple of my projects and its fluent interface is very welcomed over the xml files.

So here’s to having fun programming once again.

Oren Eini posted his results from typealyzer which determines your personality profile by reading your blog. So I thought I would see what the typealyzer said about me based upon my blog.

INTJ - The Scientists

The long-range thinking and individualistic type. They are especially good at looking at almost anything and figuring out a way of improving it - often with a highly creative and imaginative touch. They are intellectually curious and daring, but might be pshysically hesitant to try new things.

The Scientists enjoy theoretical work that allows them to use their strong minds and bold creativity. Since they tend to be so abstract and theoretical in their communication they often have a problem communcating their visions to other people and need to learn patience and use conrete examples. Since they are extremly good at concentrating they often have no trouble working alone.

I would have to say that description fits me pretty well.

I have always been annoyed by implementing the INotifyPropertyChange interface, which is needed if I want to take advantage of data binding for my class entities. I get annoyed because of how much code is involved in the Setter methods. Here’s an example:

public class Employee : INotifyPropertyChanged
{
  private string _name;

  public string Name
  {
    get { return _name; }
    set
    {
       if (_name != value)
       {
      	  _name = value;
          OnPropertyChanged("Name");
       }
    }
  }

  public event PropertyChangedEventHandler PropertyChanged;

  private void OnPropertyChanged(string propertyName)
  {
  	if (PropertyChanged != null)
    	  PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
  }
}

I hate all the if (_name != value) conditions that have to be in every setter, not to mention the lack of automatic refactoring since the property name is hard set. Therefore, I was really excited to see this post from my friend Jonathan Fuller and his much cleaner way of implementing INotifyPropertyChanged.

Be sure to read his entire post, but in a nutshell, by using his implementation, I would be able to cleanup the code above to the following:

public class Employee : NotifyPropertyChanged
{
  private string _name;

  public string Name
  {
     get { return _name; }
     set { SetProperty(()=> Name, ()=> _name, value); }
  }
}

Now that’s the kind of cleaning I like to see!

From Slashdot:

After years of boasting about the Mac’s near invincibility, Apple is now advising its customers to install security software on their computers. Apple - which has continually played on Windows’ vulnerability to viruses in its advertising campaigns - issued the advice in a low-key message on its support forums. ‘Apple encourages the widespread use of multiple antivirus utilities so that virus programmers have more than one application to circumvent, thus making the whole virus writing process more difficult.’ It goes on to recommend a handful of products.

This makes me laugh :-)