Uninstall Hell

In the past 2 weeks, I’ve had to install quite a number of software tools and products ( namely MS CRM 4.0, TFS 2008, VS 2008 ) on servers and workstations for my project. On 2 ocassions due to minor glitches I had to uninstall a CRM tool (via an MSI File) as well as VS 2008 due to something weird happening with Team Explorer and VS 2008 SP1. I encountered the most annoying “Cannot uninstall application due to some error, setup will now end” type of errors. A possible cause may be some screw-up in the registry and the uninstaller is unable to proceed….so what do you do now??? Here are some tips.

Tip: Smart way to ‘check all’ with JQuery

I came across a very nice post to have a “check all” functionality using JQuery. Great stuff and I’m sure will come in useful for many developers.

Check it out here.

Enjoy.

Review my code please

Code review is a necessity, never just a nice to have. Why do I say that? Because it has helped me grow a lot as a programmer. When I started as a junior programmer, I’ve had my code reviewed by many senior colleagues, and I have learnt so much from them. As my experience grew, I took on the role of reviewing the junior programmers, and imparted my knowledge and good practices unto them. There are many benefits to be gained from code reviews, such as:

• Code reviewers help junior programmers learn and grow, as well as enforce good programming habits. If you don’t review their code, you will most probably end up fixing / refactoring their code if quality is bad.
• Getting another pair of eyes looking at your code helps to find bugs. Sometimes explaining what your code does to another person helps you realize you did something VERY wrong.
• It’s a great form of knowledge exchange, not only just in terms of programming, but also business rules and functionality.
• Good form of team bonding and interaction with peers.
• Quality control…nuff said.

Having been through my fair share of reviewing and being reviewed, I thought I would share some of the common pitfalls I have encountered and also been guilty of.

Perfect match: Composite and Visitor Pattern

In one of my earliest post, I talked about the importantance of understanding principles of good programming, and the useful-ness of Design Patterns… in this post I intend to share some implementation of some of these patterns. Patterns are something I use from time to time on projects, and something that I’m continuously learning from reading and from others, and still enjoying it very much. Let’s proceed then…

Design Patterns can be categorized into creational, structural and behavioral. I find two patterns that work pretty well together being the Composite Pattern (structural) and the Visitor Pattern (behavior). Composite Pattern is a structural pattern that helps one create tree-like hierarchial structures whereas the Visitor Pattern is a behavioral pattern that allows a visitor object to “visit” each element in a structural hierarchy to perform some operation/behavior on that element.

C# 3.0 Higher Order Functions

I’ve been reading a lot about F# and functional programming, and it has indeed been pretty head-turning but it’s really powerful if you know how to use it. Type Inference in F# compiler is spectacular compared to the C# one, but I shall not digress. This post is about showing off the functional aspects of C# 3.0, namely Higher Order Functions. In short, higher order functions are functions that can take in one or more functions as input parameters, as well as return a function as an output. In C# 3.0, delegates have evolved a lot and with the introduction of the System.LINQ namespace, plus a lot of functional features have been incorporated into the language, and we’ll see how to make full use of them.

In the System.LINQ namespace, you will find a large bunch of Extension Methods for IEnumerable<T> class. Most of them are higher order functions, meaning that they take in a delegate (or pointer to a function) as an input parameter. Some of these delegate types taken as inputs are Func<T, TResult>, Action<T> and Predicate<T>. What this means is that you can pass in an Anonymous Function (Lambda Expressions and Anonymous Methods) to enable different kind of behaviors. If you’re familiar with the Strategy Pattern, programmers use this pattern in order to “plug in” different behaviors flexibly by writing a family of algorithms encapsulated within derived strategy classes. With higher order functions, I’m inclined to believe that we now have something more straightforward and powerful at our disposal.

Moving to a functional state of mind with F#

In my previous post, I talked about my uneventful journey of learning a functional language and how it was revived again by discovering this great book called Functional Programming for the real world. What’s great about this book is that the authors prepare you mentally for the transition to a functional state of mind. If you are not interested in functional programming, understanding the key aspects of it is still beneficial because it opens up a different approach to solving problems, which is never a bad thing. For example, functional programmers aim to write elegant and succinct code, as well as aiming to be natural to read by making use of it’s declarative nature. Once you learn this skill, you can apply this even to static language, as we will soon see.

Guide to SketchFlow in Expression Blend 3 RC

Expression Blend 3 with SketchFlow RC is finally released today, and I could not resist having a play with it. In this post, I’m going to demonstrate building a very simple prototype using SketchFlow. First you will need to download and install it. Once that’s done, open Expression Blend 3, and create a new WPF SketchFlow solution. (Or Silverlight if you wish)

Expression Blend 3 + SketchFlow (RC) Released

Previously I talked about a great UI Design tool called SketchFlow, but was not available yet at the time of writing. Not anymore…

Download SketchFlow with Expression Blend 3 (RC) here. Have a play with it….:)

Is there a functional programmer inside you?

I only just realized I have had a crush on Functional Programming for ages. When I first learned and used Generics and Anonymous Methods in .NET 2.0, I instantly fell in love. Next came C# 3.0, LINQ and XAML, and I was instantly drawn to it’s declarative nature and style. Having done programming for a relatively short time, I delved mostly in Imperative Programming in statically typed languages like C#, VB.NET and C++. C# 3.0 had a facelift by getting some aspects of functional programming (like lambda expressions) and that made it more powerful, fun and simpler to write/understand. Eventually I decided to venture into the world of Functional Programming, namely F#.

WPF: Window Dock Behavior

**updated this post for Blend 3 RC release

Have you ever used WinSplit Revolution? It’s a utility that helps you organize your windows into regions to assist with organizing your screen real estate. I find this to be a very useful tool, especially when I use two monitors while doing development, being able to organize my windows neatly makes a huge difference. One cool feature is called Drag’n'Go. When you drag your window outside your screen boundary, a semi-transparent rectangle (I’d like to call it an overlay) appears to cue you on the location of where the window will be docked. I really like this feature, and wondered how difficult it would be to incorporate this into a Behavior for a Window class in WPF to exhibit the same kind of functionality. Here’s my result.