David Douglass

Not Playing Nice Together

David Douglass — Sun, 14 Mar 2010 18:10:24 GMT

One of the things I’ve noticed is that two industry trends are not playing nice together, those trends being multi-core CPUs and massive hard drives. It’s not a problem if you keep your cores busy with compute intensive work, but for software developers the beauty of multi-core CPUs (along with gobs of RAM and a 64 bit OS) is virtualization. But when you have only one hard drive (who needs another when it holds 2 TB of data?) you wind up with a serious hard drive bottleneck. A solid state drive would definitely help, and might even be a complete solution, but the cost is ridiculous. Two TB of solid state storage will set you back around $7,000! A spinning 2 TB drive is only $150.

I see a couple of solutions for this. One is the mainframe concept of near and far storage: put the stuff that will be heavily access on a solid state drive and the rest on a spinning drive. Another solution is multiple spinning drives. Instead of a single 2 TB drive, get four 500 GB drives. In total, the four 500 GB drives will cost about $100 more than the single 2 TB drive. You’ll need to be smart about what drive you place things on so that the load is spread evenly. Another option, for better performance, would be four 10,000 RPM 300 GB drives, but that would cost about $800 more than the singe 2 TB drive and would deliver only 1.2 TB of space.

All pricing based on Microcenter as of March 14, 2010.

Be Prepared

David Douglass — Fri, 26 Feb 2010 01:32:42 GMT

Your machine is dead. Now what? I keep these bootable CDs on hand, just in case:

SpinRite. This program has saved me several times. Fixes unusable disks that cause systems to hang. Worth $90 the first time you use it.
Ultimate Boot CD for Windows. This will allow you to boot a dead system from a CD and copy all the important stuff to an external hard drive (plug the hard drive in before booting). There are also a lot of system utilities on the CD to help with repair. Free but requires a Windows XP license.
Microsoft Diagnostics and Recovery Toolset is similar in concept to Ultimate Boot CD for Windows but is from Microsoft. Unfortunately, Microsoft restricts distribution to customers who have purchased Software Assurance.
Acronis True Image Home boot disk. Boot from CD and backup to external hard drive. Program also performs regular backups from Windows. $50 list.
Memory testers. These exercise the system’s memory and report on any problems found. All free. Memtest86, memtest86+, Windows Memory Diagnostic.

Round & Round with Enums

David Douglass — Fri, 26 Feb 2010 00:02:10 GMT

Enumerated constants in C# can be represented 3 different ways:

as a C# program constant
as a number (typically int)
as a string spelled identically to the C# constant

Here a sample program demonstrating how to convert between any of these formats.

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication2 {
    public enum Color {
        red,
        white,
        blue
    }

    class Program {
        static void Main(string[] args) {
            string toString, fromString = "red";
            int toInt, fromInt = 1;
            Color toColor, fromColor = Color.blue;

            //    string to enum
            toColor = (Color) Enum.Parse(typeof(Color), fromString);

            //    string to int
            toInt = (int) (Color) Enum.Parse(typeof(Color), fromString);

            //    int to enum
            toColor = (Color) fromInt;

            //    int to string
            toString = ((Color) fromInt).ToString();

            //    enum to string
            toString = fromColor.ToString();

            //    enum to int
            toInt = (int) fromColor;

            Console.ReadLine();
        }
    }
}

Dropbox Does it Right

David Douglass — Thu, 25 Feb 2010 23:27:35 GMT

I sent my kid off to college this fall and it didn’t require a soothsayer to know that she wouldn’t do any backups and at the end of the semester her hard drive would crap out. After an emergency repair with the magnificent SpinRite, I started looking into personal cloud based backups. Dropbox was the only solution that did it all just right. After installing Dropbox you designate a folder to watch (your dropbox). Then just do your work, saving it in your dropbox. Every time a changed file is closed it gets backed up to the cloud. Nice touches include an file icon overlay to indicate backup status and a tray icon that shows overall backup status. Need your stuff? Go to the Dropbox web site and download it or use another computer with Dropbox installed. You can get 2 gigabytes of space for free. What’s not to like?

Speaking at the Fairfield / Westchester Code Camp

David Douglass — Wed, 04 Nov 2009 02:08:27 GMT

This Saturday, November 7, the Fairfield / Westchester .NET User Group is hosting the 3rd annual Fairfield / Westchester Code Camp at the Connecticut Information Technology Institute in Stamford, CT. I’ll be speaking on New Debugging Features in Visual Studio 2010. Hope to see you there!

Fixing Your Windows Explorer Shortcut

David Douglass — Sun, 01 Mar 2009 17:24:12 GMT

I’m sure you’ve noticed that Windows Explorer thinks that everything you care about is in My Documents. If you’re like me that isn’t true; important stuff is in the C drive, network shares, external storage, etc. Wouldn’t it be nice if Windows Explorer opened showing all the devices on the computer? Change your Windows Explorer shortcut as below and it will.

%SystemRoot%\explorer.exe /e,::{20D04FE0-3AEA-1069-A2D8-08002B30309D}

Microsoft Should Just Give Up on Search

David Douglass — Sun, 01 Mar 2009 16:20:42 GMT

So I’m doing a little coding using reflection and the following exception is raised:

It is illegal to reflect on the custom attributes of a Type loaded via ReflectionOnlyGetType (see Assembly.ReflectionOnly) -- use CustomAttributeData instead.

I don’t get it so I pump the error message into Microsoft’s Live Search. Live Search comes back with:

We did not find any results for It is illegal to reflect on the custom attributes of a Type loaded via ReflectionOnlyGetType (see Assembly.ReflectionOnly) -- use CustomAttributeData instead..

Not believing this for even 1 nanosecond, I run the same query using Google. Google’s first hit points me to Kirk Evens’ MSDN blog where the exact messages appears in the entry!

I’m Speaking at Code Camp NYC

David Douglass — Wed, 07 Jan 2009 11:35:13 GMT

I’m Speaking at Code Camp NYC (http://nyc.codecamp.us/) this Saturday, January 10 on Virtualization for Developers. You can register for the code camp at https://www.clicktoattend.com/invitation.aspx?code=134146.

Hope to see you there!

Garbage Collection in VB6 and .NET

David Douglass — Sun, 30 Nov 2008 16:47:13 GMT

I've noticed some confusion amongst VB6 programmers who've moved to .NET regarding garbage collection, so I'd like to explain the differences.

VB6 is built on top of COM. In COM, each object has a hidden reference count inside it, a count of the number of in scope variables that point to the object. When you new an object the reference count is set to 1. If you then assign that variable to another, the reference count is incremented to 2. As those references go away, either by variables going out of scope or having a different value assigned to them, the reference count is decremented. When the reference count goes to 0, there is no way for the object to get used and it gets garbage collected at that time.

In .NET, objects do not have a reference count. Instead, the .NET run time maintains a list of what points to what. When an object instantiates another object, the .NET run time keeps track of the relationship. If the object gets passed around, it remembers those relationships also. Eventually, all the pointers to an object go away. At that point, unlike VB6, nothing happens; there simply exists an unreferenced object in memory. At some point, so much garbage (i. e., unreferenced objects) will build up in memory that the .NET run time will decide to track down unreferenced objects and garbage collect them (that's a simplification, but it will serve).

These differences affect how to program. In VB6, it is common to set a variable to nothing to force the reference count to drop to 0 and cause garbage collection of that object. This doesn't make sense in .NET. Setting something to nothing in .NET, assuming there is only 1 reference, simply cause the object to become a candidate for garbage collection at some later, undefined time. If you find you really need to force garbage collection in .NET there are 2 options:

Refactor your program to keep scopes as narrow as possible
Use the Dispose pattern

Where and how you declare objects affects how long they are in scope. Shared variables are in scope for the life of the program, member variables for as long as the object exists, and local variables until a function is exited. Always strive for the narrowest scope, this way object will naturally garbage collect at the best time.

There can be times when you need to release an object at a specific point in a program. This is done using the Dispose pattern. See Dispose, Finalization, and Resource Management for a complete discussion. The Twitter version is that the Dispose pattern lets you tell an object "You're done; release your resources now". This is not the same as garbage collection; garbage collection still happens later as described above. If you need to implement Dispose, pay close attention to the details. I ran into a nasty bug when this wasn't done correctly, which I discussed at Observations on .NET Object Disposal.

The 2 options are not mutually exclusive at all. #1 should always be done, #2 should be done whenever necessary.

There is an option 3 which should be avoided, calling the Collect method on the GC class. Performance will suffer by using GC.Collect.

There is an important difference between forcing garbage collection in VB6 by setting a variable to nothing and forcing clean up in .NET by calling Dispose. In VB6, garbage collection happens only once there is no way for the object to be accessed. In .NET, as far as the run time is concerned, Dispose is just another function like any other (compilers treat Dispose special, but not the run time). You can call Dispose no matter how many references exist to an object. Also, nothing stops you from using an object after it has been disposed. Whether this "works" depends on the design of the class. Nonetheless, using an object after it has been disposed is a violation of the pattern. Future maintainers of the code may assume the pattern has been followed correctly and cause objects to be unusable once disposed.

Quick Database Sanity Check

David Douglass — Fri, 28 Nov 2008 13:43:49 GMT

My project is on the move, literally. We're migrating from our old data center to a new one; everything is being brought up on new hardware. Since we're using full and incremental backups, an important sanity check is to make sure all the data has been restored, which is being done using the following query:

select
    'select ''' + TABLE_SCHEMA + ''' as TableSchema, ''' + TABLE_NAME + ''' as TableName, count(*) as [Rows] from ' + TABLE_SCHEMA + '.' + TABLE_NAME + ' union' as [SQL]
from
    INFORMATION_SCHEMA.TABLES
where
    TABLE_TYPE = 'BASE TABLE'

The query above produces a query. When run against the AdventureWorks database you get:

select 'Production' as TableSchema, 'ProductProductPhoto' as TableName, count(*) as [Rows] from Production.ProductProductPhoto union
-- many rows removed
select 'Production' as TableSchema, 'ProductPhoto' as TableName, count(*) as [Rows] from Production.ProductPhoto union

The result isn't perfect. The last union operator needs to be replaced by an order by:

select 'Production' as TableSchema, 'ProductPhoto' as TableName, count(*) as [Rows] from Production.ProductPhoto
order by TableSchema, TableName

When you run the fixed up query you'll get a list of every table in a database along with the number of rows in each table:

If there's too many tables to compare by hand, save the results from the source and destination databases to text files and compare using WinMerge.