Obishawn

Hiring a Programmer

2009-12-01T14:01:00.001-06:00

Next time I need to find and hire a new programmer (which I hope won't be for a long time), I think I'm going to follow Aaron Swartz's hiring process. Thanks for the tweet on this Brandon!

LINQ Success Story

2009-12-01T09:50:00.002-06:00

While processing some order data that comes in via a SOAP web service, I needed to check to make sure that user would not exceed the maximum allowable quantity for that product for the month. Easy enough, I started looping through the products and checked the quantity against how much they've ordered that month. It then occurred to me that I needed to make sure that if they ordered the product twice in the same order (placed the item in the shopping cart twice resulting in two line items on the order), then I total the quantity. Think about how I would do this in the past, I'd be looping through all of the line items in the list multiple times.

With LINQ, it was simple to code up:

var products = from i in request.LineItems
               group i by i.ProductID
               into p
                select new {ProductID = p.Key, Quantity = p.Sum(i => i.Quantity)};

I could then loop through products and once and leave LINQ take care of the ugliness of grouping the products and totaling their quantities.

While this is a very simple example of LINQ and doesn't show it's full power or potential, it does demonstrate how it can be used in normal code using standard collection objects to simplify your code and still get the job done.

Technorati Tags: .NET,LINQ

"Software Tools You Should Be Using and Blogs You Should Be Reading"

2008-11-01T05:00:00.000-05:00

I've read so many Dugg and Kicked articles about "Top 10 Tools" or "Top 10 Blogs", etc. that you should be using and probably aren't. Every time I read one I think, what makes that person the authority on this topic and what research did they do to determine that yes, in fact these are the top 10 tools or blogs? But ultimately it's just a title that is meant to draw your attention to tell you what tools that person or team is using or blogs they read. And who knows, you may even find a tool or blog that you've never heard of but is just the one you've been looking for.

However, there's a problem with these articles. There's a huge portion ("huge" added for dramatic effect, I have no research showing exactly how much) of the target audience that isn't even reading that article. There are developers out there, probably working for a small company on a team of 5 or less that simply will never end up reading that article or hearing about those tools. They may even be ignorant to the fact that such things exist. These people are the ones who need to be reading these articles the most. They are the ones positioned to gain the most benefit from it.

I'm not saying that anyone that works for a small company on a team of 5 or less fits in that category. I work for just such a company yet I do not fit in that category. In fact, I and a colleague brought a toolset to the company I currently work for and the other developers didn't realize that there were such tools out there or maybe just never bothered to really try to find them. We've recently brought a new developer onboard and even in his experience working for several companies, including software development contracting companies, had never seen a toolset as large as the one we had constructed at this company. We're talking the basics: source control, build processes, development aids such as Notepad++ and RegexBuddy.

So what makes us different from the developers that don't have an extensive toolset? Much of the suggestions I'm about to make extend beyond the tools you use and into the improvement within your field in general.

Read the best blogs and technology sites

This one has been preached several times over. I'm guilty not doing this one well though. I read a couple, but I don't read the best ones and I tend to gloss over too many articles without actually paying attention to them.

This also requires changing your habits from time to time. Blogs and technology sites go stale or become polluted with bad information. Sometimes you have to give up on a site and move on to the next one. Don't be afraid to abandon one of your favorite sites after it has gone bad or lost the lead. Don't let their falling behind let you fall behind.

Strive for improvement

It's not just a matter of reading news on technology sites or reading popular blogs to try to stay on top of your field. You have to be constantly on the lookout for better ways to do what you're doing. You're not going to be spoon-fed every new tool, better process, better techniques or new technology. Sometimes you have to go hunt for a better way by yourself.

Don't be satisfied with Notepad to record your notes or edit your text files. There's Notepad++ and it's free! Better yet, there's Microsoft OneNote for keeping track of your notes. Don't want to pay for OneNote? How about Zoho Notebook or Google Notebook? Software constantly breaking because you and another developer deploy from your local working copy and end up ultimately overwriting each other's changes? Set up a build server and build process. It's what all the big boys do and maybe it's time you do too even if you're working for a Mom and Pop shop. As long as it can improve your process, why not consider it? NAnt does wonders for creating a build process and CruiseControl.NET is great for setting up the build server. Both are free and XML based so they're fairly easy to work with. Don't like those? Search for more. Search for better.

Also, when reading technology articles about the 'Top 10 Blabity Blah', don't be satisfied with what the author is telling you. Look for better. You may stumble upon a whole new slew of tools and blogs and ways of doing things that you've never heard of.

The same can be said for developing and testing software. Don't be satisfied writing code the same way you used to. Learn about design patterns, development methodologies, software testing techniques.

You have to be constantly hungry for knowledge.

Be curious

Don't shy away from the unknown. Take a look at the ads on your favorite blogs or the technology site that you just discovered searching for a solution to your problem. Hear something you've never heard of? Google it. Learn more about it. It may not be as complicated as you think or it could help you in ways you've never dreamed.

A colleague once asked me if I had ever heard of 'Inversion of Control' (IoC). I hadn't. I read about it on Wikipedia and kind of got it. But I was curious so I kept digging. I found out about 'Dependency Injection' (DI) and 'Aspect Oriented Programming' (AOP). All of which I was never taught about in college. Never anything even remotely similar to these. This also led me to the Spring.NET framework. I started playing around with Spring.NET and within a month had employed IoC/DI and AOP and it greatly reduced the complexity of my code, decreased the development time and increased the unit testability and the system testability of the application.

On another day, I had been searching for the solution to a problem and saw an ad for XHTMLiT. This company claimed to take any design file (of the popular file types such as PSD, PNG and AI) and generate valid XHTML and CCS. They also said all the right things such as 'table-less' design (if you want), hand-coded and more. All this in 8 business hours and for an extremely low price! I was curious and decided on an upcoming web site revamp to try them out. The price fit well within the budget and if they could get it taken care of in 8 hours, then they'd save me a bunch of time. Sure enough, they delivered and got it done in far less time than it would have taken me. If I hadn't taken the time to click that ad, I would have added probably a week or more to the schedule for that project.

Listen to others and more than that, talk to others

Don't wait for your friends or colleagues to tell you what they are doing or what they are using. Ask them. A vast portion of my knowledge and tools I use have been conveyed to me from one of my colleagues. He does a lot of the footwork for gathering the information and I basically leech off of his knowledge. Ok, I don't leech. I do reciprocate. I educated him on Spring.NET, AOP, IoC and DI. So when I say 'talk' to others, I also mean that you should volunteer your knowledge. They may be one of the people waiting to be spoon-fed. So spoon-feed them once in a while and then educate them on how you learn about everything.

Don't be afraid to experiment

You have to experiment and play with new tools, technology and techniques before you can become familiar with them. It's a rare breed that can simply read about something and put it into play the next day. The first couple tries at using something may not be pretty. But you learn more from your mistakes than you do from your successes. Edison himself learned 2000 ways not to make a light bulb.

The toughest part about this one is that you either have to experiment on your company's time or your time. The choice is yours, but either way, you have to do it. Sometimes just monkeying with something helps you figure it out easier than reading about it or being taught about it and you can learn things about it that may not have been obvious or documented or taught.

Don't accept the world the way it is

Just because a set of processes, tools, etc. are already in place does not mean that they are the best. Be the butterfly flapping its wings off the coast of India that causes a tornado in Kansas. Speak up. Suggest the new stuff. Even if they don't change to what you suggest, it may be the catalyst for other change. And sometimes you have to be more forceful. Sometimes you have to implement a new tool without anyone knowing just so you can prove to them that it works. Be smart when choosing to do this, but don't be afraid to do it if you think it will work.

Don't be afraid to throw the old stuff out

Things change all the time. Tools, processes, methodologies, none of these live in a bubble. They are subject to the same rules as everything else and thus they change as well. When a tool just doesn't cut it anymore, get rid of it. You may love it, have a long history with it and are an expert with it, but if it doesn't get the job done, then what good is it? Throw it away and get a new one.

You must unlearn that which you have learned.

When you have a hammer, everything looks like a nail. When you have a better hammer, everything still looks like a nail, but the nails are easier to pound.

I've got a million of these... Ok, I don't.

Keep your eyes open

One of things I have seen done as part of Lean is to observe your day-to-day tasks. Even go as far as video tape your day. Then analyze it. Really scrutinize it for waste. If you find waste, try to figure out if there's a tool that would be helpful in reducing or eliminating that waste. Be mindful of what you are doing. Things that are repetitive that we've done day in and day out are often glossed over and not seen as waste because we do them all the time and don't think twice of why we do it the way we do. Find these tasks and ask why you do them that way and if there's a better way to do it or if there is something that will help you do it better or faster.

Not everything I suggested here is always feasible within a company because you are dealing with their money and time. I can't go learn a new tool if my company doesn't allow me or I don't have the time. Just be smart and you can sometimes find ways. Explain to your manager how it could benefit the company and in the long run save them money. But just because it may be difficult to follow these suggestions does not mean that they are any less valid of points.

Got any other suggestions? Leave a comment.

Technorati Tags: Development Tools

One Scary Judge Of Talent

2008-09-10T16:52:00.001-05:00

How does a programmer judge how talented he or she is?

I got to thinking today about one of my major projects. It's a vital piece of our daily business and would cost the company a large amount of money if it came grinding to a halt for a day.

There are two new branches of this application that were recently rolled out and while I was rolling the first out I worked extensively with the team that would be benefiting from this branch to get this developed to meet their needs. After I rolled it out, it was modified slightly to become the second branch that was rolled out. I haven't heard much from the team that is using that second branch but I know it gets used heavily and they benefit dramatically from it. In fact, as I thought about it, I hadn't heard from the first team in a while either. I called someone up from the second team to find out how things were going and she said things were going great! and thanked me for checking in.

I'm not saying I'm talented (I'll leave that up to my peers to decide), but I did take a large amount of pride in my work today. If I were to try to judge how talented I was, I would take the fact that this major piece of software that is used so heavily and has had no complaints against it or feature requests for it to assist in that judgement.

I admit this could also mean that people have come to live with it, deal with the problems and have been too lazy to request new features or think the feature requests will fall on deaf ears. However, this software hasn't been out long enough for people to "learn to deal with it" and the second team sounded very pleased with it making me believe they truly have no feature requests at this time.

Development vs. Production Web.config

2008-07-10T15:02:00.001-05:00

One of the big pains that I've run into creating a build process for a web site is the web.config. When running in development, the web.config needs a certain set of development-only settings that get changed for production. For example connection strings. When developing, the web.config points to the development database but in production, it should point to the production database.

In the past I've kept two configuration files. Web.config and Release.config. At build time, the web.config was overwritten with a copy of the release.config. Horrible you say? Yeah, I know. For those that it's not obvious to, the release.config and web.config will contain a lot of duplicate information. Especially if you extend the web.config with your own custom configuration sections. Let the synchronization issues ensue!

The ideal solution to handling the web.config is simply to change those values that you want changed. But how to do this without writing some kind of script to find and replace these values?

Thankfully, the configuration file is just XML. XML can be easily modified using XSLT. And guess what! NAnt (our build script language of choice) has a <style> step that allows you to perform an XML transformation with XSLT. Ok, the only thing I needed now was time to get back up to speed on XSLT. As you may have guessed it, I'm writing this post because I found that time. Below is the code needed to make those changes.

XSLT:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
    xmlns:msxsl="urn:schemas-microsoft-com:xslt" exclude-result-prefixes="msxsl"
>
	<xsl:output method="xml" indent="yes"/>

	<!--Copy every node from the web.config applying templates when possible-->
	<xsl:template match="@* | node()">
		<xsl:copy>
			<xsl:apply-templates select="@* | node()"/>
		</xsl:copy>
	</xsl:template>

	<!--Remove custom debugging app settings-->
	<xsl:template match="/configuration/appSettings/add[@key='CreditCardTestMode']" />

	<!--Remove Conditional Compilation Symbols - Removes the 'compilerOptions' attribute-->
	<!--If you use the DEBUG conditional compilation symbol, you will have to transform your web.config before compiling your website.-->
	<xsl:template match="/configuration/system.codedom/compilers/compiler/@compilerOptions" />

	<!--Remove Debug Trust--> 
	<xsl:template match="/configuration/system.web/compilation/@debug">
		<xsl:attribute name="debug">false</xsl:attribute>
	</xsl:template>

	<!--Switch to production database-->
	<xsl:template match="/configuration/connectionStrings/add[@name='myDB']/@connectionString">
		<xsl:attribute name="connectionString">Data Source=SERVER; Initial Catalog=MYDB; User ID=DBO; Password=REALLYSTRONGPASSWORD;Application Name=APPLICATION;</xsl:attribute>
	</xsl:template>

</xsl:stylesheet>

NAnt Step:

<!--Build website using the aspnet compiler-->
...

<!--Modify web.config for production-->
<style style="${buildfiles.path}webconfig.xslt" in="web.config" out="${website.output.path}web.config" />

One of the other big hurdles is the DEBUG conditional compilation symbol. Most of our web projects depend on that symbol so things happen a little different while in development (such as exception handling). Because of this, our web.config would have to be transformed before we compiled. Thankfully, that code should be able to be removed from the web project and moved into the supporting project. Yay! Less code in the web project! I'm all for less code in the web project. That's the way it should be.

Technorati Tags: XML,ASP.NET,web.config,.NET,XSLT,NAnt

Why You SHOULD Have 100% Code Test Coverage

2008-06-12T05:00:00.000-05:00

I recently wrote a post about the level of code coverage that I achieved on a project that I was working on. Then I started seeing articles about how 100% code coverage is a fallacy, or how code coverage tools are "evil". I disagree.

Ok, before everyone kills me, let me explain. I do agree to the following:

Code coverage numbers can be abused (just like a defect/bug count)
Code coverage is NOT and indicator of how well tested your code is
Code coverage number should never be used by themselves to draw any sort of conclusion about the code

Argument 1: It's Waste of Time

The first argument that I saw was that testing simple pieces of code such as simple getter/setter properties is a waste of time that can better used writing a unit test for a more complex piece of code. So more bang for your buck.

You don't have to waste your time writing tests for simple getter/setter properties. A good testing framework can take care of this for you with little or no work on your part. NewtonSoft Utilities.NET contains a class that will dynamically test all of your properties. Using this utility, you can write a single unit test that tests all of your properties on a class. And this unit test can copied and pasted with one or two minor modifications to test the next class. Elapsed time: 30 seconds to create class, write function and run test.

In addition, no unit test should ever be considered a waste of time. A single unit test is meant to test a single scenario and that unit test will also ensure that chunk of code will always behave as expected in that scenario. What starts as a simple getter/setter property may evolve to a more complex one and the unit tests written for that property will ensure that the evolution of that property does not sacrifice functionality without you know about it.

Argument 2: Trust Your Programming Language/Framework

Another argument against testing things such as simple getter/setter properties is that why would you not trust your programming language/framework/environment to perform a simple get or set operation?

Why would you trust your programming language/framework/environment? Programming languages are software and thus can contain bugs too. Now the likelihood that you will ever encounter such a bug is low, but why take the risk? As long as you have a good testing framework as I stated above and unit testing your properties takes little or no time, then it is far better to catch the bug in unit tests than in production code.

More importantly, unit testing the simple pieces of code is not about not trusting your programming language but rather not trusting yourself. I, and I'm sure most of you, have at one time or another fat-fingered something in code. There are numerous ways to screw up on a simple property. How about having the following? It is very easy to do the following, especially with code-completion. This is not really a bug you want making it into production code, especially if a single unit test would have exposed this. And if the problem doesn't immediately stand out at you, then you've proved my point. And now imagine this property inside of a class with other code and documentation. Suddenly this bug because camouflaged and less easy to see with the naked eye.

public int Width
{
	get { return Width; }
	set { _width = value;}
}

Argument 3: Code Coverage Is Not An Indicator Of Code Quality

This argument is half true. The true reason that code coverage can not be used as an indicator of how well the code is written is because code coverage only indicates that the individual lines were executed. It does not indicate what combination of individual lines were executed. In other words, it says nothing about code execution paths.

However, code coverage can help indicate how modularized the code is. What?! I said it helps indicate that. If you have complex code, the quicker you are able to achieve 100% code coverage (or a high level of code coverage), the more modularized your code possibly is. Very modular code means that the individual pieces of your code are smaller and less dependent on other pieces of code. This in turn means that your unit tests will be smaller, more focused and require less setup. Given all of that, the unit tests should be quicker to write.

In my previous post about code coverage, I stated that I employed IoC/DI and AOP and was able to achieve a high level of code coverage very quickly and every class was either 100% covered or 0% covered and the 0% covered classes were very small and contained "untestable" code. The application had its complexities, yet I was able to achieve this code coverage scenario relatively quickly. Analyzing the code showed that it was very modular. TDD yields the same results. Modular code with high code coverage.

Having modular code means that you should be able to write more unit tests quicker and more effective unit tests because they are more focused on smaller pieces of code. This could lead to more quality code. It is important to note that highly tested modular code does not guarantee quality. But the chances of it are higher.

Conclusion

While it does not give you the world, aiming for 100% code coverage does help you write better software depending on the steps you take to achieve this high code coverage. Code coverage in and of itself is not evil and the code coverage percentage does provide some useful insight when used in conjunction with other pieces of data about your code.

Just as with everything else, the quality of your code depends on the methodologies, techniques and technology that you use coupled with your development skill level. Aiming for 100% code coverage is just another technique.

Aim high. Never let your grasp outreach your goals.

Technorati Tags: Code Coverage,Inversion of Control,Dependency Injection,Aspect Oriented Programming,Test Driven Development

FeedBurner 404 Error

2008-06-05T05:00:00.000-05:00

I recently encountered a 404 error when attempting to fetch one of my RSS feeds from FeedBurner. I have a web application that requests the feed using an HttpWebRequest in .NET and then formats it and displays it on the page. I could navigate to the feed just fine, but my web application stated that the connection could not be established because the server returned a 404-Not Found error. This was working all the while, so something had to have changed somewhere (and it wasn't in the code since the code hasn't changed in a month according to source control). Stepping through the code, I discovered that the URL that it was claiming it couldn't find was http://feedproxy.feedburner.com/.... The URL I was originally requesting was http://feeds.feedburner.com/..., so FeedBurner was redirecting my request for some reason. Using Live HTTP Headers in Firefox, I could see that my browser was not receiving this redirect.

Turns out that when I make the HttpWebRequest, if I supplied a UserAgent, then I didn't get redirected to that feedproxy.feedburner.com address. I've been meaning to go back in and supply a UserAgent anyway. I'm not sure what the feedproxy.feedburner.com URL does or why it went down, but supplying a UserAgent seems to avoid the redirect.

Technorati Tags: .NET,FeedBurner,RSS

Empty EventArgs

2008-06-04T05:00:00.000-05:00

How many times have you written an event whose event handler just takes in a generic EventArgs object and when you raise that event you pass in new EventArgs()? Turns out the EventArgs class has a static read-only instance field EventArgs.Empty that you can use so you don't have to instantiate a new copy of this class for no reason. Microsoft's documentation says that this instance is the equivalent of calling the constructor. Again the benefit is that this instance is already created.

To quote a colleague, "Think of the performance boost we’ll get!" I'm fairly certain he was being sarcastic.

public event EventHandler<EventArgs> MyEvent;

protected void OnMyEvent(EventArgs e)
{
	EventHandler<EventArgs> hnd = MyEvent;
	if (hnd != null) hnd(this, e);
}

public void DoSomething()
{
	OnMyEvent(EventArgs.Empty);
}

Technorati Tags: .NET

Unit Testing Enum Value Support

2008-06-03T05:00:00.000-05:00

Let's say you have a function that takes in an enum value or uses an enum value fetched from some other source (a private class field, a property of an object passed in, etc.). If a value is added to that enum, how do you write a unit test for that function so that it catches that something has to be added to your function to support that enum (or at minimum, you need to check to see if you have to add anything to the function to support it).

I've already discussed how to put in a check for making sure that your function will bomb if an unsupported enum value is passed in in my "Unit Testing Switch Statements" post. This takes it one step further to ensure that your unit tests catch the bombing of this function if a new enum value is added so that this bombing doesn't occur in production or even in QA's testing.

Below I have an example of this situation. I apologize for the crude example but it gets the point across on how to test this situation.

public enum CalculatorOperations
{
	Add,
	Subtract
}

public static class Calculator
{
	public static int PerformOperation(CalculatorOperations operation, int a, int b)
	{
		Check.Invariant(operation == CalculatorOperations.Add ||
		                operation == CalculatorOperations.Subtract,
		                string.Format("{0} is not a supported CalculatorOperations value.", operation));

		int result = 0;
		switch(operation)
		{
			case CalculatorOperations.Add:
				result = a + b;
				break;
			case CalculatorOperations.Subtract:
				result = a - b;
				break;
		}

		return result;
	}
}

[TestFixture]
public class Calculator_Tester
{
	[Test(Description = "Tests for unsupported CalculatorOptions values.")]
	public void Test01()
	{
		Type enumType = typeof (CalculatorOperations);
		foreach (FieldInfo field in enumType.GetFields(BindingFlags.Static | BindingFlags.Public))
		{
			CalculatorOperations operation = (CalculatorOperations) field.GetValue(null);
			Calculator.PerformOperation(operation, 1, 1);
		}
	}
}

Now if I add Multiply and Divide to the CalculatorOperations enum, my unit test will fail because Calculator.PerformOperation will throw an exception on the unsupported value.

Remember, "do nothing" is still an intended behavior. So even if you don't explicitly use an enum value in a function, you need to have it in your "supported enum values" list to ensure that that value allows the function to perform the way it is intended to. The added benefit of this technique is that it also catches scenarios that you haven't tested for. Even if PerformOperation is going to return 0 (do nothing in the switch statement) when Multiply or Divide are passed in, then you need to write unit tests for those values and then add those enum values to the function's "supported enum values" list.

Technorati Tags: .NET,Unit Test

Workflow Runtime Manager - Streamlined Launching

2008-05-29T05:00:00.000-05:00

If you've read Bruce Bukavics's "Pro WF - Windows Workflow in .NET 3.0", you may have seen some code for a Workflow Runtime Manager that wraps common steps to managing your Workflow Runtime such as launching workflows, adding services, retrieving output parameters and capturing exceptions from a workflow instance.

I expanded upon Bruce's implementation in two simple yet useful ways. First, I created an interface from it. I know, that's revolutionary! and nobody else would have ever though of that! *cough* *cough* Anyway, that's not the point of this post. I just needed to state that because I'm about to show you a clipping of the interface derived from Bruce's implementation.

public interface IWorkflowRuntimeManager
{
	...
	WorkflowInstanceWrapper StartWorkflow(Type workflowType, Dictionary<string, object> parameters);
	...
}

The problem with this is that I still have to set up that dictionary of parameters. And what if I want to launch this workflow from multiple locations in my code? I have to reinvent the wheel each time. And how do I ensure that everyone is supplying the correct set of input parameters and they're named the same? That's easy! With the addition of another interface.

using System;
using System.Collections.Generic;

namespace Ipc.Framework.Workflow.Hosting
{
	/// <summary>
	///		Provides an interface for starting a workflow using
	///		<see cref="IWorkflowRuntimeManager"/>
	/// </summary>
	public interface IWorkflowStartInfo
	{
		/// <summary>
		///		The type of workflow that the <see cref="IWorkflowRuntimeManager"/>
		///		implementation should create and launch.
		/// </summary>
		Type WorkflowType { get; }

		/// <summary>
		///		The dictionary of parameters to feed to the new workflow instance.
		/// </summary>
		Dictionary<string, object> Parameters { get; }
	}
}

This interface basically describes how to build a key to start the car. I simply write a class that implements this interface for each workflow defined in my project. See an example implementation below.

public class HelpDeskCaseWorkflowStartInfo : IWorkflowStartInfo
{
	private const string PARAM_CASEID = "CaseId";

	private readonly Dictionary<string, object> _parameters;

	public HelpDeskCaseWorkflowStartInfo(int caseId)
	{
		_parameters = new Dictionary<string, object>();

		_parameters.Add(PARAM_CASEID, caseId);
	}

	#region IWorkflowStartInfo Members

	public Type WorkflowType
	{
		get { return typeof (HelpDeskCaseWorkflow); }
	}

	public Dictionary<string, object> Parameters
	{
		get { return _parameters; }
	}

	#endregion
}

And for the final step, let's expand the IWorkflowRuntimeManager interface as shown below. The two functions accomplish the same task, but the second method allows compile-time binding of parameters wherever it is used (you just have to do the work to make sure that the parameter names you use in the implementation are correct).

public interface IWorkflowRuntimeManager
{
	...
	WorkflowInstanceWrapper StartWorkflow(Type workflowType, Dictionary<string, object> parameters);

	WorkflowInstanceWrapper StartWorkflow(IWorkflowStartInfo startInfo);
	...
}

Technorati Tags: .NET,Windows Workflow Foundation

Workflow Foundation Anatomy

2008-05-23T15:01:00.001-05:00

One of my confusions that I ran into when I first started working with Microsoft's Windows Workflow Foundation (WF) was how the WF was structured. A lot of words were being thrown at me such as Workflow Runtime, Workflow Instance, Core Services, Local Services, and Host Application. The book that I was reading to learn WF did a piss-poor job explaining these. Hopefully I can explain them in a way that may help you if you've run into the same problem.

Host Application

This one is fairly straight forward. This is the application (Windows application, web application, web service, Windows service, etc) that creates and launches the workflow instances. This is the guy that winds up the robot and lets it go.

Workflow Runtime

This one is a little more tricky to describe, but the name basically does say it all again. This is the runtime environment that the workflow instances run in. The instances are created using the Workflow Runtime and the Workflow Runtime is the guy doing all of the work executing the instances. The Workflow Runtime is the box that the robot operates in. The Host Application will use the same box for all the robots doing similar tasks.

The Runtime does a good job isolating the Host Application from the Workflow Instances. If any Workflow Instance bombs, the Runtime reports it to the Host Application through an event. Anything that happens to an instance gets reported through events. So if an instance completes, terminates, aborts, etc., it is reported to the Host Application via an event. So the robots in the box can't hurt you when they explode because the box is pretty strong and contain the blast.

Workflow Instance

Ok, I've already been throwing this one around a bit, but I'm sure that you get this one already. If I have a Workflow defined that takes in a set of input A and does an action B, when I need to fire off an execution of this workflow, I create an instance and give him to the Workflow Runtime to execute. This instance of the workflow is the Workflow Instance (complicated isn't it?). The Workflow Instance is the robot.

Core and Local Services

Ok, this is where my robot analogy begins to get a little more complicated. It is important to note here that the Core Services and Local Services are actually an Inversion of Control. Figuring this out helped me understand the Core and Local Services.

Local Services

Local Services are kind of like the code behind a web service. A Local Service is nothing more than a class that implements an interface that has the 'ExternalDataExchangeAttribute' applied to it. A Workflow can call a method on a Local Service using the 'CallExternalMethodActivity'. The Local Services are loaded into the Workflow Runtime when the Runtime is first being initialized. The WF provides a way to configure a Workflow Runtime via the application configuration file, so these Local Services can be swapped out after the application has been deployed and thus change how the application can function. To use the robot analogy, Local Services are basically port holes in the box that the robots can put items in and possibly get items back. Maybe there is one port hole that the robot can put a chunk of gold in and get gold coins back. Or maybe the robots just deposit the gold in a port hole and don't get anything back.

For a real-life example, take a banking system. I may have a Local Service that has functions defined for it such as CreateAccount, CloseAccount, DepositMoney, WithDrawMoney and GetBalance. My Workflow can now use that Local Service via the interface that it implements (remember, the interface must have the 'ExternalDataExchangeAttribute' applied to it). And after I've compiled and deployed my application to my test environment, I may want to switch out that Local Service with another one for testing (so that it doesn't hit against live data). All I have to do is change my application configuration file and run the application again. So instead of using MyCompany.MyApp.BankingSystem, I'm using MyCompany.MyApp.Testing.BankingSystem.

Core Services

Core Services are even more tricky. Core Services are software components for the Workflow Runtime written into WF. They provide functionality such as Workflow Persistence and Tracking (among others). These are add-on functionality components that you can use to enhance your Workflow experience. The persistence service gives the Workflow Runtime the ability to save it's running state, including the running state of the Workflow Instances, to a SQL Server database in order to suspend and resume the Workflow Runtime and its Workflow Instances. The tracking service allows you to track a Workflow Instances so you can watch its progress. In the robot analogy, since the box (the Workflow Runtime) is basically a black box and I can't actually see the robots, I use the Tracking service to watch what they are doing. I can hook that up to my Host Application and it's basically a monitor on the side of the box that I can watch any given robot and what it is working on. Or maybe, it's a unit that records all of the robot's activities (the Persistence service) so if I need to power down the box for the night, the robots can pick up tomorrow where they left off.

Note: In order to use the Core and Local Services, any input or output in those service or Workflow parameters must use Serializable objects.

Another Note: When using Local Services, objects are serialized, passed to the Local Service and passed back as a serialized object. This means that the object going in is not going to be the same instance as the one coming back. So if you have a Local Service that modifies an object, you're going to need to pass that object back.

Technorati Tags: Microsoft,Windows Workflow Foundation,Inversion of Control

Unit Testing Switch Statements

2008-05-22T05:00:00.000-05:00

A standard practice of mine when using switch statements with enum values is to throw a NotImplementedException on the default case. This is so that when I add a new enum value, the function will bomb if I didn't account for that value in one of the switch statements.

Take the following example. I have an enum called MyValues. I've recently added Value3. All the unit tests that I've written for my method MyClass.DoSomething pass, so I'm done... Right? Wrong! My switch statement doesn't explicitly use the new value and it should. The unit test technically passes because no exception is thrown, but I wanted it to do something with that value, but instead it did nothing.

public enum MyValues
{
	Value1,
	Value2,
	Value3 //	Added to support feature #123
}

public static class MyClass
{
	public static void DoSomething(MyValues myValue)
	{
		switch (myValue)
		{
			case MyValues.Value1:
				System.Console.WriteLine("Did first action.");
				break;
			case MyValues.Value2:
				System.Console.WriteLine("Did second action.");
				break;
		}
	}
}

[NUnit.Framework.TestFixture]
public class MyClass_Tester
{
	[NUnit.Framework.Test]
	public void DoSomething_Test01()
	{
		MyClass.DoSomething(MyValues.Value1);
	}

	[NUnit.Framework.Test]
	public void DoSomething_Test02()
	{
		MyClass.DoSomething(MyValues.Value2);
	}

	[NUnit.Framework.Test]
	public void DoSomething_Test03()
	{
		MyClass.DoSomething(MyValues.Value3);
	}
}

Ok, let's go ahead and change that switch statement to now throw an exception on the default case.

switch (myValue)
{
	case MyValues.Value1:
		System.Console.WriteLine("Did first action.");
		break;
	case MyValues.Value2:
		System.Console.WriteLine("Did second action.");
		break;
	default:
		throw new System.NotImplementedException(
			string.Format("The switch statement does not have an implementation for the MyValues value {0}.", myValue));
}

Now my unit test DoSomething_Test03() fails and I realize that I haven't accounted for MyValues.Value3 in MyClass.DoSomething.

switch (myValue)
{
	case MyValues.Value1:
		System.Console.WriteLine("Did first action.");
		break;
	case MyValues.Value2:
		System.Console.WriteLine("Did second action.");
		break;
	case MyValues.Value3:
		System.Console.WriteLine("Did third action.");
		break;
	default:
		throw new System.NotImplementedException(
			string.Format("The switch statement does not have an implementation for the MyValues value {0}.", myValue));
}

But I still haven't figured out how to test the default case in unit tests. This means I do not have 100% code coverage. It's a moot point as the default case is a simple throw statement, but I really want to achieve 100% code coverage on this class. For this, I'm modifying the DoSomething method to employ a Design-By-Contract class (find the code here) to check the enum values So now my code looks like this.

public static class MyClass
{
	public static void DoSomething(MyValues myValue)
	{
		Check.Require(myValue == MyValues.Value1 || 
			myValue == MyValues.Value2 || 
			myValue == MyValues.Value3);

		switch (myValue)
		{
			case MyValues.Value1:
				System.Console.WriteLine("Did first action.");
				break;
			case MyValues.Value2:
				System.Console.WriteLine("Did second action.");
				break;
			case MyValues.Value3:
				System.Console.WriteLine("Did third action.");
				break;
		}
	}
}

Now I can achieve 100% code coverage. And you'll notice, I no longer need the default case since I've already listed the enum values that I support in the function at the very top of the function. If I wrote my unit test better to automatically just test every value of that enum without me having to explicitly define a test for each enum value, then I could switch that Check.Require to Check.Invariant and then that check won't even occur during production execution (as long as you don't have the DBC_CHECK_INVARIANT conditional compilation symbol defined in your Release configuration). I can do this because I know that the unit tests will catch any enum values I don't support.

Technorati Tags: Unit Test,.NET,Design By Contract

Ninja Level Code Coverage

2008-05-21T10:29:00.001-05:00

At my old job, I and another developer embarked on writing a .NET assembly that offered low level functions into the system that our company developed. One of our goals was to unit test the heck out of the assembly since it was so low level. That assembly had to be as bug free as possible and when a change was made, we needed a way to try to ensure, without a huge effort on QA's side, that nothing would break.

We therefore needed to make sure that we had as much code coverage as possible. Code coverage is simply the lines of code actually executed during the unit tests. Now 100% code coverage, while it means that every single line of code has been executed, does not by any means mean your code is bug-free. Code coverage does not take into account code you didn't write. For example if I have a function Add(int a, int b) that returns an integer and my method just does 'return a+b;', I've got a huge bug if a+b > Int.MaxValue. I could have had 100% code coverage and still missed that bug.

So while having 100% code coverage does not mean a great deal towards the quality of your unit testing, having 10% code coverage is a horrible level of code coverage. In the past, we had unit tested some projects and eventually fallen behind on testing certain classes, or didn't employ test-driven development (TDD), etc. and we found we had about 20-30% coverage. If you do not employ TDD, 20-30% is probably the best you're going to do (unless you are an amazing developer and can write completely testable code without even thinking about it). With this project though, we did employ TDD and we achieved about 80% code coverage. Most of that remaining 20% was untestable code because it interacted with the database through SQL command objects or with system APIs.

Let me clarify my definition of "untestable". When I write unit tests, anything that interacts with another system or the environment is considered untestable. Unit tests should really be environment independent. Anything that requires a specific setup on the environment or a specific system could mean that the next developer is not able to run the unit tests on their system. For example, if code interacts with SQL Server, what happens when the next developer does not have access to that server or the server is down? Then the tests fail. If possible, we will substitute one dependency for an equivalent, move versatile dependency. When testing our nHibernate mapping files, we use SQLite because nothing needs to be installed and this unit test can run on any environment.

With a project I am working on right now, web services that our customers use to interact with our system, we need a heavy amount of unit testing as well. We do not want a change on our side to force our customers to change on their side as well. This requires them to spend money and until they change their code, there is a potential for their application to either break or cause invalid in our system (depending on the change and how it is implemented).

So I've been working hard on writing the library assembly for these web services using TDD and employing any techniques I can to streamline development, increase testability, leave the code easy to read and develop, etc. I am using Spring.NET to help me do this. I am using their Dependency Injection (DI) functionality of their Inversion of Control (IoC) container as well as their Aspect-Oriented Programming (AOP) components. Lastly, I used a Design-By-Contract to assist in validating parameter arguments.

Using the DI, my classes already are stripped of their hard dependencies making them easier to test. Using the AOP, I've simplified the code in my services classes by removing things such as authentication, logging and exception handling. Each one of these aspects can be tested independently of the service class. By not having them mixed in with the actual service execution code, the unit tests for the service code have less paths to test so less unit tests that need to be written. In addition to this, as I was developing the library assembly, I stayed mindful of what code would be untestable and coded around that pulling those pieces of code out into their own classes.

The result? I have about 75% code coverage already (the remaining 25% is a combination of untestable code, code that will eventually be removed as it is no longer needed and method stubs that haven't been developed yet and for now just return generic data for UI testing). The interesting effect of my development process I noticed is that every single class had either 0% code coverage or 100% code coverage.. So the 0% tested classes were classes that were not developed yet or were untestable code. A quick glance at those classes and I noticed that all of the untestable classes were very minimalistic (about 3 - 10 lines of actual code per class). These classes can easily be checked by two developers to determine if there are any bug potentials in them and most likely will be fully tested in a simple, manual QA test.

I have to admit, I thought that was really cool. I used to think just having high code coverage was exciting. But then seeing that every single class has either 0% or 100% code coverage, that definitely tops the cake (at least until I can achieve 100% code coverage on an entire assembly).

Technorati Tags: Spring.NET,Inversion of Control,Dependency Injection,Aspect Oriented Programming,Design By Contract,.NET,nCover,Unit Test,Test Driven Development

Dependency Injection

2008-05-20T13:54:00.001-05:00

A while back a colleague of mine sent me a link to a Wikipedia article about a design pattern called Inversion of Control (IoC). He also told me about a framework called Spring.NET that is apparently very popular (as well as other similar frameworks that extend the .NET Framework in an attempt to make building enterprise level applications easier). In reading up on Spring.NET, I also came across a methodology called Aspect Oriented Programming (AOP) and a technique called Dependency Injection (DI). After getting to fully know these design patterns, techniques and methodologies (oh my!), I feel like I've been living under a rock not knowing about them.

Let's talk about Dependency Injection first. This is a specific form of IoC. This technique allows the user application to swap out functional pieces of the application thus changing how the application runs. Instead of a software component creating or retrieving it's own dependencies, it asks the user layer for it's dependencies.

Quick example: I have an AccountManager class in a banking program. The AccountManager class interacts with the persistent data via the BankDb class. Pretty typical. The AccountManager class depends on the BankDb class and knows how to instantiate this class on it's own. However, if we employ DI, we would modify the AccountManager class to take in a IBankDb class on instantiation. Then when we instantiate the AccountManager class in the interface layer, we can supply the BankDb (which implements IBankDb) and the AccountManager no longer needs to know how to create that instance on it's own because it will be spoon-fed this object.

But wait! We're not done. Now we employ the help of the Spring.NET framework to do the DI for us. We can now define in XML configuration files (such as the application configuration file) what class should be passed in to the AccountManager class when we instantiate the AccountManager. Instead of hard-coding a BankDb object into the constructor, we retrieve the IBankDb object to use from the Spring.NET IoC container. The Spring.NET IoC container is configured using the XML configuration files.

Ok, so what exactly do we have?

We have an AccountManager who doesn't care what object it uses to interact with the persistent data as long as it's an object that implements IBankDb. And we also have an application that is able to dynamically load which object to pass into the AccountManager via the application configuration file.

How does this benefit us?

Well first, you can now fully unit test the AccountManager class (as long as IBankDb is it's only dependency). You can use a framework such as Rhino Mocks or NMock to mock the IBankDb in order to help you fully unit test the AccountManager class.

Second, what if the person that needs to write the actual BankDb hasn't written it yet and you're not able to write it yourself because you don't have the appropriate access to write that code? Well, you can write your own mock BankDb class that does enough for you to test your interface and when the actual BankDb class is created, you simply change a configuration file instead of your code.

Another example of the second benefit is in a web service. Say you now have a web service that uses the AccountManager class. You now want to create a development set of web services that allow consumers of the web services to develop their applications without hitting the live data but acts the same in all other aspects. You can use the same exact AccountManager class, but now supply it a different BankDb class using just a configuration file change. (By the way, Spring.NET has a way of dynamically generating .NET web services, so you don't even need to actually create another .asmx file - it's all done through the web.config).

Can't we accomplish the same thing by swapping the BankDb object via code?

Yes. Using Spring.NET to do your DI vs. code is really your call. This call is roughly equivalent to choosing C# over VB.NET, or Pepsi over Coca Cola. There are arguments for either choice but at the end of the day, they both accomplish the same thing. The only advice I can offer there is to go with what your comfortable with. Spring.NET configuration files do have their headaches involved, but being able to change the functionality of the application without recompiling your application is pretty cool and sometimes handy.

Another example before I let you go. I recently developed some web services. I made three projects: The web service project, a .NET library and a Windows application to test the web service. I relied on Spring.NET to do all of my DI. The web services consume local services (code run directly from the library - not Windows services) to accomplish their tasks. The tester application is written such that by commenting out one line and un-commenting another in the application configuration file, I can switch the tester application between using the production web services, using the development web services and using the local services without recompiling the application. When the Windows app is using the local services, it is using the same exact Spring.NET configuration files that the web services do (thus injecting the dependencies the exact same way the web services would). So I can test the local services and work out the bugs, then switch over to the web services (confident that the local services will work the same for them as it did for the Windows app) and do a great deal less testing on the web services.

If you've never looked at IoC, DI or Spring.NET (or equivalent frameworks), I encourage you to do so. There can be a learning curve involved in figuring out when to and when not to use these, but I'm sure that you'll be able to figure out when those times are.

Technorati Tags: Inversion of Control,Aspect Oriented Programming,Dependency Injection,Spring.NET,Rhino Mocks,NMock,.NET

URL Rewriting and Postbacks

2008-04-15T13:37:00.000-05:00

Where I work, we use a heavy amount of URL rewriting for a couple goals.

SEO (Search Engine Optimization) - We use 301-redirects to correct URLs that are not in a format that we want indexed. For example, with my domain, http://obishawn.com would cause a 301-redirect to http://www.obishawn.com/ ensuring that the search engines do not index http://obishawn.com separately from http://www.obishawn.com/ (unfortunately, my blog software does not employ these techniques).
Legacy URLs - Pages from the old version of a site need to be 301-redirected to a new page due to a site reorganization. From an SEO standpoint, you should never rename a page, but sometimes it's necessary. So we have a URL rewriter that redirects a certain list of URLs to new URLs.
Virtual URLs - Dynamic pages that are loaded from a virtual URL. For example, http://www.mydomain.com/products/a12345/ would actually be hosted by http://www.mydomain.com/product.aspx?sku=a12345.

The framework that we wrote for the URL rewriters works great, are very efficient (well as efficient as processing the URL of every single request can be) and we can turn certain rewriters on or off via the web.config in case we need to do some testing or bug hunting. The problem lies with the Virtual URLs and specifically when those pages do postbacks to the server.

The rewriters for SEO and the legacy URLs perform 301-redirects. This means that a response is sent back to the client when it requests a URL informing the client that URL does not exist and that file has been permanently moved to a new URL and then supplies the client with the new URL. The client can then request the new URL. In your browser, this will cause the URL in your address bar to change. The virtual URLs however are a different story. This is a server side transfer of the request on to a page other than the one that you would expect based on the URL.

Take my example from above (http://www.mydomain.com/products/a12345/). I would expect the page '/products/a12345/default.aspx' (or some other default page based on the type of web application - PHP, ASP, HTML, etc.) to process that request. Little do I know from a client machine that the directory 'products' doesn't even exist on the server let alone the page '/products/a12345/default.aspx'. Instead, the server sees that request and realizes that it should be processed by a different URL, namely http://www.mydomain.com/product.aspx?sku=a12345. Product.aspx can then render the response that should be sent to the user. All without changing the URL in the client browser's address bar. The virtual URL looks a little nicer than the product.aspx URL with a query string.

The issue is that if product.aspx has to postback to the server for whatever reason (maybe you have a pricing table that updates based on an option in a dropdown box). Because of how the request was transferred to product.aspx, the postback URL is 'product.aspx?sku=a12345'. So the URL looks really nice and can hide what programming language the server is using, but as soon as you postback, all that niceness and hiding goes out the window as the URL in the address bar changes to the product.aspx?sku=a12345 URL. The source of this problem is the 'action' attribute on the 'form' element of the rendered page. This attribute is automatically set to the URL servicing the request and not the URL in the address bar. So how do you get around this?

Easy! With the ActionlessForm!

The trick is to have a custom form control that does not render the 'action' attribute. If there's no 'action' attribute, the page just posts back to the URL in the address bar. Here's the ActionlessForm solution from straight from Microsoft. There are many problems with this solution. The biggest that I ran into is the 'onsubmit' attribute and the fact that in Microsoft's solution, this attribute does not get rendered, ever. This attribute holds the JavaScript postback scripts that have to run in order for client-side validation to be done on a form. That's kind of a big problem. If you take a look at the source code for the HtmlForm control's RenderAttributes function, there's a lot that this solution is missing. I've come up with a better solution. Two classes are needed. MyHtmlTextWriter which inherits from HtmlTextWriter and the ActionlessForm class which inherits from HtmlForm.

Simply put, the ActionlessForm creates his own custom HtmlTextWriter from the one passed into it's RenderAttributes function. The custom HtmlTextWriter then ignores the action attribute as long as it does not begin with default.aspx. The reason for the default.aspx exclusion is I ran into issues when http://www.mydomain.com/ tried to postback to the server without an action attribute on the form element. This will have to be modified if you use other default pages such as index.aspx.

public class ActionlessForm : HtmlForm
{
    private class MyHtmlTextWriter : HtmlTextWriter
    {
        public MyHtmlTextWriter(TextWriter writer)
            : base(writer)
        {
        }

        public override void WriteAttribute(string name, string value)
        {
            if (name != "action" || value.StartsWith("default.aspx"))
                base.WriteAttribute(name, value);
        }

        public override void WriteAttribute(string name, string value, bool fEncode)
        {
            if (name != "action" || value.StartsWith("default.aspx"))
                base.WriteAttribute(name, value, fEncode);
        }
    }

    protected override void RenderAttributes(HtmlTextWriter writer)
    {
        base.RenderAttributes(new MyHtmlTextWriter(writer));
    }
}

Technorati Tags: Microsoft,.NET,SEO,ASP.NET

Windows Welcome Screen Override

2007-12-07T11:42:00.000-06:00

Here's a little known fact about the Windows Welcome Screen: If you need to log in to Windows with an account that is not displayed on the Welcome Screen (e.g. the Administrator account), there is a way to switch out of the Welcome Screen while at the Welcome Screen. Simply log out of all accounts on the computer and when you're sitting at the Welcome Screen, press Ctrl+Alt+Delete,Delete (hold down Ctrl+Alt and press Delete twice in quick succession). This should bring up the regular Log On window that allows you to enter a username and password.

I know this works on Windows XP, but I have never tried it on Windows Vista. Again, all accounts must be logged out for this to work.

Tags: microsoft, windows

Development Machine Virtualization

2007-11-01T12:42:00.000-05:00

Computer: Dell D630 (laptop)
Processor: 2.40GHz Intel(R) Core(TM) 2 Duo - Excellent
Memory: 4GB - Excellent
Hard Drive: 120GB 7200RPM - Excellent
Media Bay Hard Drive: 80GB 7200RPM - Good
Screen: 14.1WXGA+ (1440x900) - Good
Operating System: Windows XP sp2 (Excellent) Company Core Load (Ok)

So the good news is that the laptop is a great laptop. The screen is a bit smaller than I'm used to with my personal HP Pavilion, but I've become accustom to is with my MacBook Pro with the exception that the MBP is a 15.4 inch screen instead of 14.1. The downside is that the laptop came with the company's core load. Now, I understand the purpose of having a core load for leased machines from the support, standardization and security standpoints. The problem is that no one image is ever perfect for everyone. Even having machines on the company's domain with your own setup can cause problems when they push down a standard change. For example, if the company cracks down on ActiveX controls in IE for security, but you develop ActiveX controls for IE, you're going to run into problems. So from the company's standpoint, core load images are a wonderful thing. For the user's standpoint, that's not always the case. Being in software development, it's usually not the case.

My machines at minimum are usually wiped clean (formatted) and I install Windows from scratch. This way I know every setting that is set within Windows and I hopefully won't be find out that my software doesn't work because of something being locked down by the domain or core load image. This helps me develop much faster and reliably. IT is fairly lenient with us because we have special needs compared to the rest of the company. However, there are a few things that they still require such as anti-virus, machines staying up-to-date with Windows updates, etc. Any machine that can not go on the domain is supposed to be on an air gapped network. So I keep my eyes open for ways to get my work done and yet comply with IT's standards, rules and regulations. I've worked in IT before and so I've seen it from their side.

My goal with this new laptop was to run the core load and not wipe it clean. To do this, I determined that I would have to rely heavily on virtual machines. Thankfully I knew that the Intel(R) Core(TM) 2 Duo is a screaming processor that it handles virtual machines beautifully and the 4GB of RAM means that I will not have to skimp on the memory for each virtual machine.

Host Environment

A couple things to note about my host system. All I have installed on it is the company's core load which contains the operating system, remote dial-up/VPN software, security software, anti-virus software, Office and the company's instant message client. In addition to this, I have installed the VMware products such as Workstation, Converter, Server Console and Infrastructure Client.

Partitions
The laptop came with the primary hard drive partitioned with the C:\ drive at 20GB. At first I did not like this as I don't like others determining how my hard drive is partitioned. But this is actually large enough for the extra software (VMware products) that I had to install, so I'm okay with the size they chose. The benefit of having it already partitioned like this is that I already have a partition for my virtual machines on the primary hard drive. Virtual machines really should be stored on their own partition as this allows for better fragmentation on that drive. VMware files are essentially all extremely tiny files or very large files, so when they become fragmented, they do so in larger chunks (at least in theory). This also makes it easier to de-fragment the partition if the files are fragmented in larger chunks. Unfortunately, this partition is not 100% going to be used for virtual machines as the company's core load moves the 'Documents and Settings' folder to this second partition (so as to not lose any data if the C:\ drive needs to be re-imaged) and I also have a few Portable Apps on this second partition. However, this is not a large amount of data and should not cause too many issues in terms of fragmentation.

Anti-Virus
A big concern is the fact that this laptop is running anti-virus. We all know anti-virus is meant to protect us, but as most of us know, this is a major performance killer as the anti-virus software constantly scans files as they are accessed. So, the anti-virus software must be configured to not scan (real-time scan) the virtual machine directories. This is not just a slight performance boost, but rather a life-or-death performance boost. I've seen people struggling to get their virtual machines performing at a usable level only to find out that the anti-virus was what was killing them. Night and day performance.

Development Virtual Machine

Description: This virtual machine contains just the minimum tools that I need to do 80% of my work and is configured in a way to be the best performing of my virtual machines.

Hardware: I decided to give this virtual machine 768MB of memory. If need be, this virtual machine can be upped to 1GB, but so far it has been running fine with 768MB. I only need about 20GB for the hard drive in this virtual machine as the source code does not take up much space and I'll be keeping the number of applications on this virtual machine to a minimum. The key feature of this virtual machine is that this hard drive will be created with all of its space pre-allocated. Pre-allocating the space for this hard drive means that it VMware will not have to dynamically increase the size of the hard drive as it needs it because the space is already there. This gives the virtual machine a performance boost.

Software: Again, I keep this virtual machine as small as possible. Since the majority of my work will be with .NET 2.0 and 3.0 applications and SQL, I installed just Visual Studio 2005 with just the components that I need, SQL Server 2005 Tools (just the tools), TortoiseSVN and KDiff3 (my diff tool of choice). I do not need full blown SQL Server on my development image as I have a test system that contains my development database(s). Keeping the software to a minimum ensures stability and high performance within this virtual machine.

Notes: I do not take snapshots with this image as I want the performance of this machine to be as high as possible and snapshots branch off the hard drive files defeating the purpose of my pre-allocated hard drive.

Test System Virtual Machine

Description: This virtual machine is the system that I use to install the development builds on and contains the database(s) that I develop against.

Hardware: The memory allocated for this system matches what we require for our software and can be adjusted as needed. The hard drive(s) also are sized as needed and can be adjusted as needed. I leave VMware dynamically allocate the space for these drives as I am not concerned too much with the performance of this image.

Software: This is obviously whatever is needed for our software plus our software itself.

Full Development Virtual Machine

Description: This virtual machine contains everything for the development of any piece of our product including previous versions of the software. This image is actually a copy of our build box minus the software that I am not licensed for. Essentially, I could almost run an entire build on this virtual machine. This is actually the virtual machine that I use to edit our build process as well.

Hardware: This virtual machine is a beast and it needs the hardware to match. I actually allocate 1GB of memory for this virtual machine and it contains 2 hard drives. One for the operating system and software and one for the data/source code. The second hard drive is a massive hard drive and can be deleted and recreated without destroying the virtual machine. It makes for easy cleanup of the virtual machine.

Software: This has it all. Visual Studio 6, 2003 and 2005, SQL Server 2000 and 2005 (full SQL Server), third party controls, etc. Again, this is a copy of our build virtual machine with certain software uninstalled that I am not licensed for such as InstallShield. With this virtual machine I can develop on the old Visual Basic 6 controls and applications plus the older versions of my pieces of the software that are still .NET 1.1.

Notes: This machine is easy to recover. All I need to do is take another copy of the build machine and uninstall a couple items.

Benefits

Any one of these machines can be recreated without having downtime (assuming the original image is still usable). Say my development image becomes unstable because I installed the wrong software (be it third party controls that I'm testing, etc.), I can easily start to set up a new image while still using the old one to continue developing until the new one is set up. To reset up a physical system, your choices are to take down your main system or find a backup computer to continue developing on while your system is being reinstalled.
If I find that the core load image is locked down in some way, my virtual machine will not be.
Network isolation/security. Using VMware Workstation's Host-Only or NAT network settings, I can either isolate my virtual machine from the network or secure it. This also helps keep the network safe as my virtual machines that are not managed by the domain are secured as well.
One benefit that I've found is that when I shut down my laptop for the night (which I typically put it in standby), I find it's best to suspend all virtual machines and close Outlook and instant messenger. Within my virtual machines, I may leave stuff running, I may close everything, but on my host system, everything is shut down for the night. So, when I get in in the morning, I am starting fresh. And when I close down for the night, I make sure to check in my changes and find a good spot to leave off. It is much easier to leave stuff open, not checked in, etc. when it's running on your host desktop machine that you leave up and running overnight. But when I close stuff down for the night, I find I leave off in better spots. This leaves me less stressed and better organized for the next day. Because I'm less stress and am starting fresh each day, I also find I'm more productive.
Task segregation - I've also found that my individual tasks are segregated by virtual machine so its easier to stay focused on one task at a time.

The setup that I've described above is not meant to be an fix-all, universal solution. But hopefully you find that this gives you ideas how to improve your development machines or environments.

Tags: VMware, Visual Studio, Microsoft, Windows, SQL, SQL Server, virtualization, .NET

Smart Image Resizing

2007-08-23T12:41:00.000-05:00

I want to see this in the next version of iPhoto or Picasa.

Source

I Want Picasa for the Mac

2007-06-06T12:36:00.000-05:00

One of my favorite programs is Google's Picasa. However, as I recently posted, I made the switch to a MacBook Pro as my primary home computer. I initially tried to use iPhoto to manage my photos as I've heard good things about it. After using it a bit, I realized that the good things I heard about it must have been from people that never used Picasa.

Picasa works so smoothly. You just point it to the directories that you store your photos in and it automatically loads them into the program for you to view, edit and organize. The program automatically displays all of your photo folders on the left hand side as your "albums". On the right side are all your thumbnails of your photos grouped by these albums. You can scroll up and down through your entire library as thumbnails You can also change the size of the thumbnails with a slider in the lower right-hand corner and watch the size change real time. All of this is done ultra-fast.

Picasa gives a number of really great enhancements for your photos. These extend beyond your typical redeye-reduction and contrast adjustment. It offers enhancements such as saturation, which intensifies the color, glow, black-and-white, sepia, blur, focal blur as well as others. They also have a "I'm Feeling Lucky" button that automatically adjusts the photo to make it look better. I would say with over half my photos, this really does make them look much cleaner and nicer looking (less washed out, more vibrant, realistic color, etc.) Below is a photo that I took and, with Picasa, increased the saturation a bit, warmified it and added some glow. I clicked the Saturation button, slid the slider to the intensity I wanted and hit Apply. I then clicked the warmify button. I then clicked the Glow button, slide the sliders to the intensity and radius that I wanted and hit Apply. It was that easy. All this while previewing the change live.

A great feature of this is that it doesn't actually change the picture file itself until you tell it to or export it. Instead it just remembers what changes you made and displays the changed picture to you within Picasa. Again, this is all ultra fast. You don't have to sit and watch it constantly apply these changes every time you access the picture. It's as if it actually is changed, but opening the picture from Windows Explorer shows that it's not actually changed. This also means that you can undo any change at any point even after you've closed Picasa, rebooted your computer, whatever. So you can undo a couple changes, make others, then undo all the changes and make a whole new batch of enhancements.

The first picture is the original. The second picture is the Picasa enhanced picture.

Personally, I think the enhanced picture is ready for the cover of a magazine.

Picasa also allows you to bulk edit your keywords. Though this feature could be improved upon some, it is nice that you can do it from the library view. I would improve it by not having it as a popup window but rather a frame somewhere within the window. I can never seem to maneuver the window to be in the best spot to bulk edit multiple groups of thumbnails. You can also search by keywords. As you type, it already starts filtering right before your eyes. And again!, it's all very, very fast.

I have a number of issues with iPhoto. The first and foremost is that you have to import your photos into its library. It doesn't just dynamically load the photos from where they are in the file sytem like Picasa does. This irritates me because I don't like having all of my pictures stored in some database file. If one file becomes corrupt, I'm ok with it because 1 out of 2000 pictures I can deal with. One file of one corrupted means I lose everything in one swipe. Yes I know that's what's backups are for, but that's beside the point. I would still have to restore my entire library just to recover that one corrupted file whereas to recover one corrupted picture in my file system is just one picture. Plus, I just don't think there is any good reason that I should have to put my files in a library. Picasa has no problem loading the pictures from where they exist in the file system. Yes this means there is a service running that constantly updates the library, but I'm willing to have a service running doing this if it makes my life easier.

iPhoto is not organized as nice as Picasa. In iPhoto, I have to specify my libraries and add the photos to it. Even when I import a folder of pictures organized into folders, iPhoto isn't smart enough to load them into libraries for me. You can view by the year they were taken. I don't find that useful whatsoever. Also, when viewing the library of thumbnails, as you scroll, it renders the thumbnails at low quality and then in the background reloads them in higher quality. This feature, which is meant to speed things up, actually slows things down a bit when trying to scroll quickly up or down. Also, when a thumbnail is scrolled off the screen, it is unloaded. So if you scroll down and back up, it has to reload the thumbnail. Now, I say slow, but honestly it's not that slow. Not Windows Explorer slow. But it definitely can not hold a candle to the speed of Picasa.

Don't get me wrong. iPhoto is a great program. But if you've used Picasa, you may find yourself preferring Picasa as I do. I debated for a while where to keep my photos, in iPhoto, in my Mac file structure or in my BootCamp partition. I've decided that I'm willing to wait for my BootCamp Parallels VM to boot just so I can use Picasa.

With that said, I tried desperately to find out if Google is planning on releasing Picasa for the Mac. Unfortunately, all I found is that Google is aware that users are asking for Picasa for the Mac and that you can get a Picasa Web uploader for iPhoto. Google, this is my plead to you, "Please, oh please! Make a Mac version of Picasa." Until then, all I can hope is that the next version of iPhoto in Mac OS X Leopard has greatly improved.

Tags: Google, Picasa, iPhoto, Apple

Visual Studio .NET Intellisense

2007-04-26T12:34:00.000-05:00

So today I needed to go work on a .NET project in Visual Studio 2003 and found that my intellisense was not working. I tried typing even the simplest 'string.Format' and when I hit '.' no help popped up. Figuring that it was ReSharper, I uninstalled it. However, that did not solve the problem. So I repaired VS 2003. Nope. So I continued to uninstall, repair, run CCleaner, etc. Nothing seemed to fix it. Then it occurred to me that it might be something in my profile. Sure enough, I logged in as a different user and that user had intellisense.

I proceeded to clean out my %UserProfile%\Application Data, %UserProfile%\Local Settings\Application Data and %UserProfile%\Local Settings\Temp directories for anything related to VS but that still didn't fix it. Finally I came to terms with the fact that it was in the registry. I deleted the HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\7.1 key (which unfortunately holds all of my VS 2003 settings) and went back in. Sure enough it was fixed.

I'm not sure what specific key or value shut off the intellisense though. One of these days I may try to narrow it down.

Tags: Microsoft, .NET, Visual Studio

Rank Trending

2007-04-25T12:33:00.000-05:00

Did you ever wonder how each post you make to your blog affects your Google Rank? Maybe you want to keep an eye on your Google search rank for a specific phrase because you want to make sure your site stays known for that topic. Or maybe you have some other statistics from say a service like awstats that you want to overlay with your Google Adsense to see just how they relate.

Then RankTrend is for you.

Datasources
RankTrend tracks a number of datasources for you such as search engine rank (what position your website shows up in a search result list), Google PageRank, how many people link to you in Del.icio.us, how many Diggs a post of yours gets and many more including a generic datasource so that you can upload your own custom data. Here's the beauty: RankTrend keeps track of these over time so you can see how each change from day to day, week to week, etc.

Events
RankTrend also allows you to enter events that you can overlay on top of your data. For example, when you pay for an ad for your website in a magazine, you can add an event so that you can see at what point in the data that you got that ad. It helps you visualize what kind of change that ad brought for your website. Here's the cool part: you can give RankTrend RSS feeds too so that it automatically adds in an event for each new item in the RSS feed. So if you have a blog, give RankTrend your RSS feed and watch how each post affects each of your datasources.

Charts
So you have all this data, now what? The heart of RankTrend isn't in the collecting of this data, it's in helping you visualize it and compare it. RankTrend offers a charting system that allows you to plot your various datasources together and overlay whatever events you'd like. The charts are powerful and the RankTrend team is working on even more trending options that will take it to the next level. Below is an example of a chart that I made in which I imported some of my daily awstats into a generic datasource and charted it. Now I know awstats gives you a basic chart to visualize this data, but RankTrend offers this kind of charting on any of their datasources. Plus you can't plot your events over top of your stats on the awstats site.

Reports
RankTrend also offers the ability to build your own reports that can be emailed to you daily, weekly or monthly. So say I built 7 charts and wanted those and a site summary emailed to me weekly so I can keep an eye on things, I can do that.

RankTrend is in Beta
As I mentioned before, RankTrend is in beta. You'll need a special code for now in order to sign up. This code is posted on certain forums, so if you can find it, you can take part in the beta testing. Hopefully it will be out of beta soon. The RankTrend team is committed to offering more and better ways to track and trend the data about your website that is important to you.

I highly recommend you check it out and subscribe to their RSS feed to be notified when RankTrend comes out of beta.

Tags: RankTrend.com

Office 2007 and OneNote 2007 Installation Crash

2007-01-12T11:27:00.000-06:00

Problem: Office 2007 and OneNote 2007 crash right away when starting the install reporting: 'Error: ORegistryKey.GetSubKeyNames failure: Cannot get all sub key names for registry "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall" HResult: 0x80070103.'

Description: My work machine has been about 6 months overdue for a reinstall of Windows, so today I finally decided to do just that. I decided this would be a good time to transition to Office 2007 and OneNote 2007. I used a XP CD that had SP2 and all the latest updates slipstreamed into it as well as Internet Explorer 7, Windows Media Player 11, the latest DirectX 9 and the Windows Genuine Advantage add-in. So after the OS was installed, all I had to do was update some drivers and start installing all of my software.

I tried to install OneNote first and as soon as it started to install, it crashed. I tried a couple times with no luck (shutting down various applications such as AV between tries). So I moved on to Office. Same thing happened. Looking at the contents of what was going to be sent to Microsoft about the error, I discovered the problem: 'Error: ORegistryKey.GetSubKeyNames failure: Cannot get all sub key names for registry "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall" HResult: 0x80070103.' I checked, and sure enough, the key existed. So that didn't help.

I decided to make sure everyone had access to that key and the sub-keys. After doing this, I was able to install OneNote. So I figured I was good and Office would install. Nope. Same problem as before. So I got drastic. I exported that key, deleted all of its contents (well, I deleted that key and its contents and then recreated the key rather than deleting 50+ keys 1-by-1). Hooray! Office installed! (I then blew the key that I backed up back into the registry.)

Solution:

Warning! Do not attempt this fix unless you have a clear understanding of registry and the risks of manually editing its contents. You run the risk of corrupting your system by performing these steps!

Reset permissions on that key and all of its children.
If that doesn't work...
1. Export that key.
2. Delete the contents of that key.
3. Install Office, merge the exported key.

Update 2-14-2007

Turns out this may be due to SVS. If you are using SVS, deactivate all layers before installing Office or OneNote before trying the above solution(s).
Source

Tags: Microsoft, Office, OneNote

Windows Live Writer Part II

2006-09-07T12:27:00.000-05:00

I was looking around Windows Live Writer a little more. This program has quickly become my preferred way of posting messages.

In my previous Windows Live Writer post, I mentioned that I had installed Tag4Writer in order to tag a post and that it doesn't work for Community Server. It turns out Windows Live Writer actually has the tag support built in, it just appears to be unable to add new tags. In the upper right-hand corner of the program is a drop down list that lists the categories. Categories in CS 2.x have basically become tags and so the tags that I entered in CS show up there. Simply checking these check boxes tags the post.

Also in that post, I had mentioned that WLW removes my tags. Those category choices would explain why. If I repost a message after having entered tags on the web, then it re-posts the message with no categories. Selecting the tags in this list would have kept the tags when the message was re-posted.

Tags: Windows Live Writer

InstallShield Exit Code -1073741819

2006-08-23T12:26:00.000-05:00

Problem: InstallShield IsCmdBuild.exe exit code -1073741819

Description: A while back we ran into a problem with our build box at work. One of our installers suddenly stopped building, giving back the error code -1073741819. I immediately opened InstallShield's GUI and built the installer and it built with no problems. I tried again to build it with the Visual Build step (calling the ISCmdBuild.exe - InstallShield's command line tool to build the installer) and it failed again. So I made the Visual Build step output the command line it was calling. I then copied that and ran that exact command in a command prompt. It built successfully. This led me to believe that it was a problem with Visual Build. Posting a message on their forums proved useless as they said there was a workaround that had you just handle the error event, look for that Id and change the status of that step to good if it encountered that error. The problem is that the installer did not build, so the step truly did fail. So I went back to the idea that it was an InstallShield problem and so tried posting a message on InstallShield's forums and got no response whatsoever.

During my investigation, I did determine that the only time that IsCmdBuild.exe would fail on this step was if the Visual Build project was launched by a Windows Scheduled Task.

The first time we got this message, I had to restore an old version of the build box and work with that. The second time I didn't have the luxury of doing that. So I dug and dug into the InstallShield files and tested a couple theories. I finally came across a solution that worked.

Solution:

Uninstalled the InstallScript Objects.
Deleted the .msm files in C:\Program Files\Common Files\Merge Modules.
Deleted C:\Program Files\IS11.5\Objects\MDAC28.msm.
Ran the IS11.5 install and ran a "Repair".
Reinstalled the InstallScript Objects.
Downloaded MDAC 2.8 Merge Module from the Objects section in an InstallShield InstallScript project.

I kicked off a new build and everything worked. We haven't seen that problem resurface since.

Tags: InstallShield, VisualBuild

Windows Live Writer

2006-08-22T12:24:00.000-05:00

I just came across the Windows Live Writer browsing Channel9 and had to try it out. I fired up SVS, created a new layer, installed Windows Live Writer, updated the layer to include the Tag4Writer and here I am creating a new post on my blog using Windows Live Writer. It seems pretty nice. Nothing too bulky, simple, straight forward. It even satisfied a co-worker of mine. He was a user of Blogjet but he said he wanted one that supported tags, allowed you to set the title of the page (Blogjet does not do this but Windows Live Writer uses the name of the post as the title of the page) and writes good HTML.

A couple nice features: allows you to insert pictures and maps with the click of a button, gives you the ability to save drafts and has very simple style editing (if I'm going to write a fancy looking post, I'm going to write the HTML myself, not use a post creator). It defaults to a Web Layout style, so as you type, your post already looks like what it will on your blog. Then you can switch to the Web Preview and view the post as if you actually posted it (displays in the context of your actual blog).

Windows Live Writer supports a number of different blogs from Windows Live Spaces to Community Server to Wordpress to Blogger. Check it out. You'll probably like it.

Update:

Tag4Writer does not actually fully support tagging in Community Server. It simply puts in links in the post to specific tags. As far as I am aware, CS does not parse these tag links in a post. I actually had to manually put the tags in myself and then I had duplicate links on the post for each tag. So I decided to not use Tag4Writer for now. CS 2.1 added the ability to add tags via AJAX right when viewing a post (if you're logged in). That's good enough for me for now. Hopefully WLW adds tagging support or Tag4Writer adds that functionality to their software.

Another thing I realized with WLW is that it allows you to update a post. Tremendous! However, I think it may be clearing the tags on my post when I post an update. Hopefully it was just something I did.

Update:

Yep, the tags were removed.

Tags: Windows Live Writer, Channel9, SVS, Blogjet, Tag4Writer

Imaging Software

2006-05-01T12:24:00.000-05:00

So I just realized that my last post was over a month ago. April was a busy month for me. Anyway, we just purchased a license for a new piece of imaging software at work that is fairly slick.

Up until now we have been using Symantec Ghost and it has been working fairly well. When I started working for the company that I am at right now, one of the first things I did was transitioned their imaging system from PowerQuest Drive Image to Symantec Ghost. I had created some boot CDs that were specifically designed for our test machines and would boot in about 15 seconds. These disks would establish a network connection, map a drive and then execute some batch files on that share in order to finish the boot. About 75% of the boot process could be controlled by the files on the network share so modifying the boot process didn't always require me to re-burn the CDs. This system has been adequate up until recently when we got a machine that is going to be used for the system test.

This new machine contains 2GB of memory. The RAMDisk that I was using for the boot CDs only supports up to 1GB of memory. So I switched to using Bart's Boot Disk. It takes a lot longer to boot but at least it supports 2GB.

Then we decided to upgrade one of our performance servers from 1GB to 3GB of memory and we got a second performance server with 8GB. Suffice to say, I think Ghost is now out of the question. So we started looking into new software. We came across Acronis True Image. This software is pretty nice. You can even image the computer while running Windows. Also they have a tool that can allow you to install an image taken on one set of hardware and deploy the image on another set of hardware. VMware already implements this type of ability in their P2V software which I've used before and love.

So I wanted to test the software out myself and see how it works. I downloaded the evaluation version, installed it on my computer and started it taking an image within about 5-10 minutes. 15 minutes later, I had taken an image of my C: drive which contained about 40GB of data. The image, with their default compression was about 20GB in size. I then deployed the image to a new virtual machine. This took about 2 hours. This is longer than I would have expected, but I'm sure there's some kind of setting that you could mess with to make this deploy faster. I then used P2V to strip out the hardware specific drivers. Then I fired up the virtual machine and had a copy of my physical box running as a virtual machine. I didn't try Acronis's Universalization software because I already had P2V setup and I figured I'd just use that. All this was done and I never had to interrupt my work because I was able to do it all without shutting down Windows (other than the reboot to finish installing the Acronis True Image software).

Tags: Symantec, Ghost, PowerQuest, Drive Image, VMware, Acronis, True Image

Build Machine Virtualization

2006-03-27T11:23:00.000-06:00

So hopfully by now you've heard the term 'virtualization'. There is a definate trend toward running production servers at virtual machines to fully utilize the capabilities of new servers, to help achieve 0 downtime, to reduce the amount of hardware needed, etc. There's also a trend towards quality testing being performed more and more on virtual machines rather than physical machines where possible to reduce the number of physical test machines required which thus reduces price, to more easily facilitate reproducing problems, saving snapshot of problem environments, to help facilitate automated testing, etc.

So why not go virtual with build environments?

Where I work they have the concept of freezing build boxes with every release. So at the end of a release, that build box is frozen and a new box is purchased for the next version. This was a new concept to me. However due to some events that unfolded when we did not freeze a build box and decided to build that version's two service packs on the same box. Bad things unfolded. Suffice to say, I now am all for the freezing of build boxes. The problem is that process gets expensive and time consuming (setting up and maintaining those boxes and providing disaster recovery for all of them).

So when we got close to the end of our last version, I proposed to our project manager that we go virtual with our build environment. I recommended buying a beefy server capable of storing multple environments and running a number of them too. So we got a dual Xeon, 4 GB Dell server with a good amount of storage and a license of VMware GSX Server (only to find out shortly after purchasing the license that VMware is offering its Server software free in Q2 '06 - oh well, we still need a support contract). Here are the benefits that running a build machine in a virtual environment:

Multiple machines utilizing the same hardware - the hardware for a good VMware server may be expensive but if you freeze build boxes with each version or have multiple products, the cost can easily be made up.
The build environment can be run on any VMware Server or Workstation (of compatible version). This means that you don't need high-end hardware to run a virtual build environment. Even a simple workstation computer would do.
The build environment can easily be copied - for testing reasons, build machine redundancy, etc. Obviously you'll need to worry about software licensing on the build machine if you copy it.
Since the build machine can be run on any VMware Server or Workstation, if the physical machine dies, you can easily transfer it to another machine and be back up and running more quickely.
Since you can just copy build machines, you can easily set up base build machine images or copy the build machine as a starting point for the next version.
Here's my favorite: Easily archive the build machine at the end of a version. Simply burn the image to DVDs (it is highly recommended that you have the virtualization software to span the hard disk files at 2GB - VMware definately has this functionality). Then if you have a disaster were you lose the build machine somehow, just retrieve the DVDs, find a VMware Server or Workstation (or download VM Player) and you'll be back up in a short time. No need to wrry about compaitble hardward. The problem with images (such as Ghost images) is that you have to install on the same hardware or you're going to have major issues.

I highly recommend running a virtual build environment if you can.

Tags: VMware, virtualization

Build Reproducibility

2006-03-19T11:22:00.000-06:00

When designing a build process, you should design a way that the build process can be re-run for a particular build. The easiest way to do this is to divide each step into one of three categories:

Master
Build
Test

Build category

Any step that is required to build the software, documentation and installers are those that fall under this category. These steps are heart of the build process. The build steps should be unaware of source control, versioning, build output distribution, etc and should assume that everything it needs is on the box it is running on. These build steps should ideally also contain only relative paths making them location independent.

If you had all of the build steps contained within its own build file or able to be executed by themselves, then someone who had all the build software installed on their computer should be able to fetch the source code himself, execute the build and have the same output that he would if he ran the same thing on the build computer. Also, in the event of a catastrophe where you lose a build, you simple restore the source code for that particular build number and run this file again, then when it is done running, you should have the same output as you did when that build was originally run.

Test category

Any step that tests the build belongs in this category. These steps should, like the those steps in the build category, be unaware of source control, versioning, build output distribution, etc and should assume that everything it needs is on the box it is running on. These build steps should also ideally contain only relative paths making them location independent.

Master category

The steps contain in this category are those that fill in the gaps between the build and test category. These steps include maintaining and incrementing the version number, pre-build modification of the source code (for example updating resource files with the most recent translations), tagging or labeling the source code, fetching the source code (preferably from the tag or label), executing the build and test steps and distributing the output of the build (such as making the installers publicly available or at least available for QA). The master build file should also be the one who actually updates any build status application such as a build status web page. It is often beneficial to have notices on the individual steps of the building of the applications, so you may have to develope your build category steps to take in a flag as to whether it should output its status to an external source but should default to not update that external source. This way, only when the Master build steps execute the Build steps will they actually notify others of its status.

Example:
Here's a quick example of how this works. Say I have a .NET project that I build 1 solution, generate 1 help file and make 1 installer. This project has a database that the build process automatically generates the install scripts for. This application also works for multiple languages so I have a database in which I keep all the translations for my software which the build process reads and updates all of the resource files in the project. Below is how I would define the build process.

Master Build File

Increment the build number
Read the latest translation data from the database and update the resource files.
Commit changes to build number and resource files to the database. Note: at this point, since I have truely consumed another build number, I can consider the build to actually have started.
Tag/label the source code with the new build number.
Fetch the source code from the tag/label.
Execute the Build file
Save the installers and binaries from the build to a public share for others to pick up
Execute the Tests file
Distribute the results of the tests.

Build File

Generate Database install scripts
If executed by the Master build file, update status
Build the .NET solution
If executed by the Master build file, update status
Build documentation
If executed by the Master build file, update status
Build installer
If executed by the Master build file, update status

Tests File

Test Database install scripts
If executed by the Master build file, update status
Build and run unit tests on .NET solution
If executed by the Master build file, update status

Reproducibility
Now imagine that catastrophe strikes and our build machine dies. Luckily we have instructions for setting up a new build environment to be the same as the old one. The instructions contain all of the software and their versions along with the keys needed for them. So within a day we have a new build environment up and running. Now I need to recreate version 1.0 of our software so I create a revision for it. I fetch the source from the tag that we made for v1.0. If I've defined the build process properly, I can simply run the Build File and have output that is nearly the same exact output that we had for v1.0. Hopefully the only difference will be dates of files.

SQL Union Statements Implicitly Perform Distinct Selects

2006-02-27T11:21:00.000-06:00

Ok, so I'm not sure if the title is worded correctly, but I needed something so here's what I'm getting at:

I was working on a SQL stored procedure at work today and adding some more joins and columns to a Select statement that was part of a Union with another Select statement. Everything was going good until I added a Text column to the columns to return. At this point I started getting an error stating that Text columns can not be used with Distinct. The odd thing was that the Distinct keyword didn't exists in the Select statement (or anywhere in that stored procedure for that fact). I thought about it for a little bit, after messing around with the statment for a while, and realized something. A Union will not insert duplicate rows into the resultant data, it basically does a Distinct Select. Since I knew this particular Union statement would never return duplicate data, I modified it from being a standard 'Union' to a 'Union All'. I was then able to add the Text column with no problem.

Tags: Microsoft, SQL Server, SQL

DataGridView Column Header Style

2006-02-24T11:19:00.000-06:00

I was building a .NET 2.0 Windows application which contained a DataGridView object. I was attempting to modify the column header styles to fit better in the application but none of the settings I was applying seemed to be taking effect. So finally I posted a message on Channel9 and got a response with the answer to my question.

In order to use styles in your DataGridView control for your .NET 2.0 Windows application, you must specify dgvMyDataGridView.EnableHeadersVisualStyles = false.

Example of the code:

//Instantiate new DataGridViewCellStyle    
System.Windows.Forms.DataGridViewCellStyle dataGridViewCellStyle2 =     
    new System.Windows.Forms.DataGridViewCellStyle();     
    
//Define Header Style     
dataGridViewCellStyle2.Alignment =     
    System.Windows.Forms.DataGridViewContentAlignment.BottomCenter;     
dataGridViewCellStyle2.BackColor = System.Drawing.Color.Navy;     
dataGridViewCellStyle2.Font = new System.Drawing.Font("Microsoft Sans Serif",     
    8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));     
dataGridViewCellStyle2.ForeColor = System.Drawing.Color.White;     
dataGridViewCellStyle2.SelectionBackColor =     
    System.Drawing.SystemColors.Highlight;     
dataGridViewCellStyle2.SelectionForeColor = System.Drawing.Color.Navy;     
dataGridViewCellStyle2.WrapMode =     
    System.Windows.Forms.DataGridViewTriState.True;     
    
//Apply Header Style     
this.dgvTransactions.ColumnHeadersDefaultCellStyle =     
    dataGridViewCellStyle2;     
    
//Disable Headers Visual Styles - apparently there is an "automatic"     
// visual style that needs to be disabled     
this.dgvTransactions.EnableHeadersVisualStyles = false;

Tags: Microsoft, .NET, Visual Studio, Channel9

Conditional Compilation Symbols for ASP.NET 2.0 Projects

2006-02-19T11:20:00.000-06:00

Conditional compilation symbols are those constants that you can define in order to include or exclude certain code in compilation of your solution. The most common constant is DEBUG. With DEBUG defined in your build configuration, you can define code that only gets compiled into the final binaries if compiled in the Debug build configuration. Below is an example of using the DEBUG constant to include code only when in Debug configuration.

#if DEBUG
            Response.Write("The value of 'a' is " + a);
#endif

Since ASP.NET 2.0 projects do not have project files, there is no place in the Microsoft Visual Studio 2005 IDE to define the conditional compilation symbols like there is in DLL and Windows Executable projects.

It turns out that you can define these constants in your web.config. The downside to this is that they are not bound to a specific build configuration and so you will either have to manually add/edit these constants in your web.config or add something to your build process to handle these constants. Just add the xml below to your configuration of your web.config to define the DEBUG constant and a custom SANDBOX constant. (I like defining SANDBOX in order to hit against a developement/test database rather than the real/production database.)

<system.codedom>
<compilers>
    <compiler language="c#;cs;csharp" extension=".cs"
      type="Microsoft.CSharp.CSharpCodeProvider, System, Version=2.0.0.0,
      Culture=neutral, PublicKeyToken=b77a5c561934e089"
      compilerOptions="/d:DEBUG,SANDBOX"/>
</compilers>
</system.codedom>