Since a color can be thought of as a three-tuple of its R, G, and B channels, the formula is easily distributed to each of these values.

At this point, I decided I could probably just pull out a calculator and crunch the numbers. But maybe, in about the same time, I could also whip something together, say in PowerShell, to do it for me. Since I’m still learning PowerShell, I figured the learning experience would be worth at least something.

So the first thing I needed was the ability to parse an ARGB hex code into a hashtable with each channel separated out. Here’s what I got.

function Blend-Colors ([string[]] $colors) {
    # $argbHexColorRegex should recognize all 4-byte hex color strings prefixed with a '#'
    # and assign them to groups named a, r, g, and b for each channel, respectively.
    $argbHexColorRegex = "(?i)^#(?'a'[0-9A-F]{2})(?'r'[0-9A-F]{2})(?'g'[0-9A-F]{2})(?'b'[0-9A-F]{2})$"

    foreach($colorHex in $colors) {
        if($colorHex -match $argbHexColorRegex) {
            $color = @{
                a = [int]::Parse($matches.a, 'AllowHexSpecifier')
                r = [int]::Parse($matches.r, 'AllowHexSpecifier');
                g = [int]::Parse($matches.g, 'AllowHexSpecifier');
                b = [int]::Parse($matches.b, 'AllowHexSpecifier');
            }

            $color | ft
        } else {
            throw "Invalid color: $colorHex"
        }
    }
}

Ok, not too shabby. If you’re wondering where $matches came from, as a side effect of the -match operation, the $matches hashtable is set with all the matched groups defined. I just prefer to use the object syntax in this case over the index syntax.

So, I’m not real happy with the amount of repetition going on in the assignment of my hashtable. My first attempt to clean it up looked like this:

$color = ('a','r','g','b') | % { @{ $_ = [int]::Parse($matches.$_, 'AllowHexSpecifier') } }

But that just gave me an array of hashtables with one attribute in each. I asked Doug Finke what he thought and he recommended this modification:

('a','r','g','b') | % { $color = @{} } { $color.$_ = [int]::Parse($matches.$_, 'AllowHexSpecifier') }

Cool! It seems a little obvious now, though.

Next on the agenda was to translate the blending equation into PowerShell. Since the equation is a little more involved, I decided to abstract it out into a subfunction like so:

function Merge-Channel ($c0, $c1, $c) {
	$a0 = $c0.a / 255
	$a1 = $c1.a / 255
	return $a0 * $c0.$c + $a1 * $c1.$c * (1 - $a0)
}

$c0 and $c1 are color hashtables and $c is the name of the channel to blend. I had to divide the alpha channels by 255 to produce a value compatible with the equation, namely, between 0 and 1.

The reason I chose to accept the entire color and desired channel, rather than a more terse definition accepting the specific channel values and related alpha values was to make calling the code a little more elegant:

('r','g','b') | % `
	{ $mergeColor = @{ a = [Math]::Min(255, $outColor.a + $addColor.a) } } `
	{ $mergeColor.$_ = Merge-Channel $addColor $outColor $_ }

When blending, the alpha channels simply sum, so I put that in my hashtable initializer and just iterated over the color channels.

Now the final step is to return our value back in hex form. Fortunately, the formatting styles for int make this really easy:

return '#{0:x2}{1:x2}{2:x2}{3:x2}' -f (('a','r','g','b') | % { [int][Math]::Round($baseColor.$_, 0) })

I’m rounding to ensure the highest accuracy to the blended color, as opposed to simply truncating.

Putting it all together, I decided to create two array constants, $argb and $rgb to alias arrays of the channels. While I was at it, I also promoted my $argbHexColorRegex to a constant just for good measure. Finally, I made the base color white, so there would be something to blend against. The result looks like this:

function Blend-Colors ([Parameter(Mandatory=$true)] [string[]] $colors) {
    # $argbHexColorRegex should recognize all 4-byte hex color strings prefixed with a '#'
    # and assign them to groups named a, r, g, and b for each channel, respectively.
    Set-Variable argbHexColorRegex -Option Constant `
        -Value "(?i)^#(?'a'[0-9A-F]{2})(?'r'[0-9A-F]{2})(?'g'[0-9A-F]{2})(?'b'[0-9A-F]{2})$"
    Set-Variable argb -Option Constant -Value 'a','r','g','b'
    Set-Variable rgb -Option Constant -Value 'r','g','b'

    function Merge-Channel ($c0, $c1, $c) {
        $a0 = $c0.a / 255
        $a1 = $c1.a / 255
        return $a0 * $c0.$c + $a1 * $c1.$c * (1 - $a0)
    }

    $argb | % { $outColor = @{} } { $outColor.$_ = 255 } # set $outColor to white (#FFFFFFFF)

    foreach($color in $colors) {
        if(-not ($color -match $argbHexColorRegex)) {
            throw "Invalid color: $color"
        }

        $argb | % { $addColor = @{} } { $addColor.$_ =  [int]::Parse($matches.$_, 'AllowHexSpecifier') }

        $rgb | % `
            { $mergeColor = @{ a = [Math]::Min(255, $outColor.a + $addColor.a) } } `
            { $mergeColor.$_ = Merge-Channel $addColor $outColor $_ }

        $outColor = $mergeColor
    }

    return '#{0:x2}{1:x2}{2:x2}{3:x2}' -f ($argb | % { [int][Math]::Round($outColor.$_, 0) })
}

This is looking really good, and, really, I might have just stopped here. The only things I was missing at this point were pipelining and documentation, and since my solution had become completely over-engineered as it was, I decided I might as well go for broke.

The first thing I wanted to do was abstract out my initialization of $outColor to a parameter. Since I’d have to parse the string, I’d also need to abstract my color hex parser.

function Parse-Color ([string] $hex) {
	if($hex -match $argbHexColorRegex) {
		$argb | % { $color = @{} } { $color.$_ =  [int]::Parse($matches.$_, 'AllowHexSpecifier') }
		return $color;
	} else {
		return $null;
	}
}

The reason I decided to return null instead of throwing an error immediately is because I wanted to treat errors differently in both places. Specifically, if an invalid string is passed in to the -background, I want to throw an argument exception, and if something invalid comes in over the pipeline, I just want to write the error to the error output and keep on trucking.

I tried a few different approaches to being able to both accept input over the parameter list and I finally found out about [Parameter(ValueFromPipeline=$true)]. Here is my test setup:

function Get-Range([int]$max) {
    for($i=0; $i -lt $max; $i++) {
        Write-Host "pushing $i to pipeline"
        Write-Output $i
    }
}

function Test-Pipeline([Parameter(ValueFromPipeline=$true)][int[]]$vals = $null) {
    process {
        foreach($item in @($vals)){
            Write-Host "processing $item from pipeline"
        }
    }
}

And my test output:

> Get-Range 3 | Test-Pipeline
pushing 0 to pipeline
processing 0 from pipeline
pushing 1 to pipeline
processing 1 from pipeline
pushing 2 to pipeline

> Test-Pipeline ('1','2','3')
processing 1 from pipeline
processing 2 from pipeline
processing 3 from pipeline

Notice the @($vals) in my foreach? That’s to protect against null inputs by ensuring $vals is a list.

Now that I’ve got all my pieces together, I just need to put everything in place with a splash of documentation.

<#
    .SYNOPSIS
    Takes a list of ARGB hex values and blends them in order against a specified background.

    .PARAMETER background
    The background color to blend against, defaults to white.

    .PARAMETER colors
    A list of ARGB hex color strings, can be pushed from the pipeline.

    .EXAMPLE
    Blend-Colors '#ff121212', '#705F6A87'

    .LINK

http://en.wikipedia.org/wiki/Alpha_compositing

#>
function Blend-Colors (
    [string] $background = '#FFFFFFFF',
    [Parameter(ValueFromPipeline = $true)] [string[]] $colors = $null) {
    begin {
        # $argbHexColorRegex should recognize all 4-byte hex color strings prefixed with a '#'
        # and assign them to groups named a, r, g, and b for each channel, respectively.
        Set-Variable argbHexColorRegex -Option Constant `
            -Value "(?i)^#(?'a'[0-9A-F]{2})(?'r'[0-9A-F]{2})(?'g'[0-9A-F]{2})(?'b'[0-9A-F]{2})$"

        Set-Variable argb -Option Constant -Value 'a','r','g','b'
        Set-Variable rgb -Option Constant -Value 'r','g','b'

        function Parse-Color ([string] $hex) {
            if($hex -match $argbHexColorRegex) {
                $argb | % { $color = @{} } { $color.$_ =  [int]::Parse($matches.$_, 'AllowHexSpecifier') }
                return $color;
            } else {
                return $null;
            }
        }

        function Merge-Channel ($c0, $c1, $c) {
            $a0 = $c0.a / 255
            $a1 = $c1.a / 255
            return $a0 * $c0.$c + $a1 * $c1.$c * (1 - $a0)
        }

        $outColor = Parse-Color $background
        if(-not $outColor) {
            throw (New-Object ArgumentException -ArgumentList "Invalid color: '$background'", 'background')
        }
    }
    process {
        foreach($color in @($colors)){
            $addColor = Parse-Color $color
            if(-not $addColor) {
                Write-Error "Invalid input color: $_"
                break
            }

            $rgb | % `
                { $mergeColor = @{ a = [Math]::Min(255, $outColor.a + $addColor.a) } } `
                { $mergeColor.$_ = Merge-Channel $addColor $outColor $_ }

            $outColor = $mergeColor
        }
    }
    end {
        return '#{0:x2}{1:x2}{2:x2}{3:x2}' -f ($argb | % { [int][Math]::Round($outColor.$_, 0) })
    }
}

Now all you have to do is save it in %userprofile%\My Documents\WindowsPowerShell\Modules\UITools as UITools.psm1 and call Import-Module UITools to bring in this function.

I’ve broken each code sample into independent blocks wherein all necessary dependencies are contained, so you can take any extension method a la carte or you can get everything from the attached zip file. My solution was built in .NET 4.0 in Visual Studio 2010, but everything should work just fine in .NET 3.5 with Visual Studio 2008.

Also included in the zip file are my unit tests, which may help you understand usage of some of the more esoteric extensions, such as ChainGet, and XML comments for your IntelliSense and XML documentation generator.

Here’s the table of contents, so you can jump around more easily:

• IEnumerable
  • ForEach
  • Append
  • Prepend
  • AsObservable
  • AsHashSet
  • ArgMax
  • ArgMin
• ICollection
  • AddAll
  • RemoveAll
• IDictionary
  • Add
  • AddAll
  • Remove
  • RemoveAll
  • RemoveAndClean
  • RemoveAllAndClean
  • Clean
• Object
  • As
  • AsValueType
  • ChainGet
• DependencyObject
  • SafeGetValue
  • SafeSetValue

IEnumerable

ForEach is pretty straightforward. It mimics List<T>.ForEach, but for all IEnumerable, both generic and weakly typed.

public static void ForEach<T>(
	this IEnumerable<T> collection,
	Action<T> action)
{
	if (collection == null)
		throw new ArgumentNullException("collection");

	if (action == null)
		throw new ArgumentNullException("action");

	foreach (var item in collection)
		action(item);
}

public static void ForEach(
	this IEnumerable collection,
	Action<object> action)
{
	if (collection == null)
		throw new ArgumentNullException("collection");

	if (action == null)
		throw new ArgumentNullException("action");

	foreach (var item in collection)
		action(item);
}

Table of Contents

Append and Prepend simply take an item and return a a new IEnumerable<T> with that item on the end or beginning, respectively. Prepend is the equivalent of the cons operation to a list.

public static IEnumerable<T> Append<T>(
	this IEnumerable<T> collection,
	T item)
{
	if (collection == null)
		throw new ArgumentNullException("collection");

	if (item == null)
		throw new ArgumentNullException("item");

	foreach (var colItem in collection)
		yield return colItem;

	yield return item;
}

public static IEnumerable<T> Prepend<T>(
	this IEnumerable<T> collection,
	T item)
{
	if (collection == null)
		throw new ArgumentNullException("collection");

	if (item == null)
		throw new ArgumentNullException("item");

	yield return item;

	foreach (var colItem in collection)
		yield return colItem;
}

Table of Contents

AsObservable and AsHashSet yield their respective data structures, but check to see if they are already what you want, saving valuable time when dealing with interfaces.

public static ObservableCollection<T> AsObservable<T>(
	this IEnumerable<T> collection)
{
	if (collection == null)
		throw new ArgumentNullException("collection");

	return collection as ObservableCollection<T> ??
		new ObservableCollection<T>(collection);
}

public static HashSet<T> AsHashSet<T>(this IEnumerable<T> collection)
{
	if (collection == null)
		throw new ArgumentNullException("collection");

	return collection as HashSet<T> ?? new HashSet<T>(collection);
}

Table of Contents

ArgMax and ArgMin are corollaries to Max and Min in the System.Linq namespace, but return the item in the list that produced the highest value from Max or least value from Min, respectively.

public static T ArgMax<T, TValue>(
	this IEnumerable<T> collection,
	Func<T, TValue> function)
	where TValue : IComparable<TValue>
{
	return ArgComp(collection, function, GreaterThan);
}

private static bool GreaterThan<T>(T first, T second)
	where T : IComparable<T>
{
	return first.CompareTo(second) > 0;
}

public static T ArgMin<T, TValue>(
	this IEnumerable<T> collection,
	Func<T, TValue> function)
	where TValue : IComparable<TValue>
{
	return ArgComp(collection, function, LessThan);
}

private static bool LessThan<T>(T first, T second) where T : IComparable<T>
{
	return first.CompareTo(second) < 0;
}

private static T ArgComp<T, TValue>(
	IEnumerable<T> collection, Func<T, TValue> function,
	Func<TValue, TValue, bool> accept)
	where TValue : IComparable<TValue>
{
	if (collection == null)
		throw new ArgumentNullException("collection");

	if (function == null)
		throw new ArgumentNullException("function");

	var isSet = false;
	var maxArg = default(T);
	var maxValue = default(TValue);

	foreach (var item in collection)
	{
		var value = function(item);
		if (!isSet || accept(value, maxValue))
		{
			maxArg = item;
			maxValue = value;
			isSet = true;
		}
	}

	return maxArg;
}

Table of Contents

ICollection

AddAll imitates List<T>.AddRange.

public static void AddAll<T>(
	this ICollection<T> collection,
	IEnumerable<T> additions)
{
	if (collection == null)
		throw new ArgumentNullException("collection");

	if (additions == null)
		throw new ArgumentNullException("additions");

	if (collection.IsReadOnly)
		throw new InvalidOperationException("collection is read only");

	foreach (var item in additions)
		collection.Add(item);
}

Table of Contents

RemoveAll imitates List<T>.RemoveAll. A second overload allows you to specify the removals if you already have them.

public static IEnumerable<T> RemoveAll<T>(
	this ICollection<T> collection,
	Predicate<T> predicate)
{
	if (collection == null)
		throw new ArgumentNullException("collection");

	if (predicate == null)
		throw new ArgumentNullException("predicate");

	if (collection.IsReadOnly)
		throw new InvalidOperationException("collection is read only");

	// we can't possibly remove more than the entire list.
	var removals = new List<T>(collection.Count);

	// this is an O(n + m * k) operation where n is collection.Count,
	// m is removals.Count, and K is the removal operation time. Because
	// we know n >= m, this is an O(n + n * k) operation or just O(n * k).

	foreach (var item in collection)
		if (predicate(item))
			removals.Add(item);

	foreach (var item in removals)
		collection.Remove(item);

	return removals;
}

public static void RemoveAll<T>(
	this ICollection<T> collection,
	IEnumerable<T> removals)
{
	if (collection == null)
		throw new ArgumentNullException("collection");

	if (removals == null)
		throw new ArgumentNullException("removals");

	if (collection.IsReadOnly)
		throw new InvalidOperationException("collection is read only");

	foreach (var item in removals)
		collection.Remove(item);
}

Table of Contents

IDictionary

All of these methods have to do with hash tables. I use them pretty frequently and these methods are able to make life a lot easier.

Add and AddAll insert the key and a new collection into the dictionary if the key doesn’t already exist and then adds the item or items to the collection.

public static void Add<TKey, TCol, TItem>(
	this IDictionary<TKey, TCol> dictionary,
	TKey key,
	TItem item)
	where TCol : ICollection<TItem>, new()
{
	if (dictionary == null)
		throw new ArgumentNullException("dictionary");

	if (key == null)
		throw new ArgumentNullException("key");

	TCol col;
	if (dictionary.TryGetValue(key, out col))
	{
		if (col.IsReadOnly)
			throw new InvalidOperationException("bucket is read only");
	}
	else
		dictionary.Add(key, col = new TCol());

	col.Add(item);
}

public static void AddAll<TKey, TCol, TItem>(
	this IDictionary<TKey, TCol> dictionary,
	TKey key,
	IEnumerable<TItem> additions)
	where TCol : ICollection<TItem>, new()
{
	if (dictionary == null)
		throw new ArgumentNullException("dictionary");

	if (key == null)
		throw new ArgumentNullException("key");

	if (additions == null)
		throw new ArgumentNullException("additions");

	TCol col;
	if (!dictionary.TryGetValue(key, out col))
		dictionary.Add(key, col = new TCol());

	foreach (var item in additions)
		col.Add(item);
}

Table of Contents

Remove and RemoveAll simply remove items from the collection associated with the specified key, if there is one. For the predicate overloads, you need to explicitly construct your Predicate<T> delegate because the C# compiler has trouble doing the type inference.

public static void Remove<TKey, TCol, TItem>(
	this IDictionary<TKey, TCol> dictionary,
	TKey key,
	TItem item)
	where TCol : ICollection<TItem>
{
	if (dictionary == null)
		throw new ArgumentNullException("dictionary");

	if (key == null)
		throw new ArgumentNullException("key");

	TCol col;
	if (dictionary.TryGetValue(key, out col))
		col.Remove(item);
}

public static void RemoveAll<TKey, TCol, TItem>(
	this IDictionary<TKey, TCol> dictionary,
	TKey key,
	IEnumerable<TItem> removals)
	where TCol : ICollection<TItem>
{
	if (dictionary == null)
		throw new ArgumentNullException("dictionary");

	if (key == null)
		throw new ArgumentNullException("key");

	if (removals == null)
		throw new ArgumentNullException("removals");

	TCol col;
	if (dictionary.TryGetValue(key, out col))
		foreach (var item in removals)
			col.Remove(item);
}

public static IEnumerable<TItem> RemoveAll<TKey, TCol, TItem>(
	this IDictionary<TKey, TCol> dictionary,
	TKey key,
	Predicate<TItem> predicate)
	where TCol : ICollection<TItem>
{
	if (dictionary == null)
		throw new ArgumentNullException("dictionary");

	if (key == null)
		throw new ArgumentNullException("key");

	if (predicate == null)
		throw new ArgumentNullException("predicate");

	var removals = new List<TItem>();

	TCol col;
	if (dictionary.TryGetValue(key, out col))
	{
		foreach (var item in col)
			if (predicate(item))
				removals.Add(item);

		foreach (var item in removals)
			col.Remove(item);
	}

	return removals;
}

// Usage:
Dictionary<int, List<int>> myDictionary;
myDictionary.RemoveAll(4, new Predicate<int>(i => i < 42));

Table of Contents

RemoveAndClean and RemoveAllAndClean both remove items from the collection associated with the specified key and if the resulting collection is empty, they remove the key from the dictionary as well. These come in both predicate and list forms.

public static void RemoveAndClean<TKey, TCol, TItem>(
	this IDictionary<TKey, TCol> dictionary,
	TKey key,
	TItem item)
	where TCol : ICollection<TItem>
{
	if (dictionary == null)
		throw new ArgumentNullException("dictionary");

	if (key == null)
		throw new ArgumentNullException("key");

	TCol col;
	if (dictionary.TryGetValue(key, out col))
	{
		col.Remove(item);

		if (col.Count == 0)
			dictionary.Remove(key);
	}
}

public static void RemoveAllAndClean<TKey, TCol, TItem>(
	this IDictionary<TKey, TCol> dictionary,
	TKey key,
	IEnumerable<TItem> removals)
	where TCol : ICollection<TItem>
{
	if (dictionary == null)
		throw new ArgumentNullException("dictionary");

	if (key == null)
		throw new ArgumentNullException("key");

	if (removals == null)
		throw new ArgumentNullException("removals");

	TCol col;
	if (dictionary.TryGetValue(key, out col))
	{
		foreach (var item in removals)
			col.Remove(item);

		if (col.Count == 0)
			dictionary.Remove(key);
	}
}

public static IEnumerable<TItem> RemoveAllAndClean<TKey, TCol, TItem>(
	this IDictionary<TKey, TCol> dictionary,
	TKey key,
	Predicate<TItem> predicate)
	where TCol : ICollection<TItem>
{
	if (dictionary == null)
		throw new ArgumentNullException("dictionary");

	if (key == null)
		throw new ArgumentNullException("key");

	if (predicate == null)
		throw new ArgumentNullException("predicate");

	var removals = new List<TItem>();

	TCol col;
	if (dictionary.TryGetValue(key, out col))
	{
		foreach (var item in col)
			if (predicate(item))
				removals.Add(item);

		foreach (var item in removals)
			col.Remove(item);

		if (col.Count == 0)
			dictionary.Remove(key);
	}

	return removals;
}

// Usage:
Dictionary<int, List<int>> myDictionary;
myDictionary.RemoveAll(4, new Predicate<int>(i => i < 42));

Table of Contents

Clean simply goes through all the keys and removes entries with empty collections.

public static void Clean<TKey, TCol>(this IDictionary<TKey, TCol> dictionary)
	where TCol : ICollection
{
	if (dictionary == null)
		throw new ArgumentNullException("dictionary");

	var keys = dictionary.Keys.ToList();

	foreach (var key in keys)
		if (dictionary[key].Count == 0)
			dictionary.Remove(key);
}

Table of Contents

Object

As casts an object to a specified type, executes an action with it, and returns whether or not the cast was successful.

public static bool As<T>(this object obj, Action<T> action)
	where T : class
{
	if (obj == null)
		throw new ArgumentNullException("obj");

	if (action == null)
		throw new ArgumentNullException("action");

	var target = obj as T;
	if (target == null)
		return false;

	action(target);
	return true;
}

Table of Contents

AsValueType does the same thing as As, but for value types.

public static bool AsValueType<T>(this object obj, Action<T> action)
	where T : struct
{
	if (obj == null)
		throw new ArgumentNullException("obj");

	if (action == null)
		throw new ArgumentNullException("action");

	if (obj is T)
	{
		action((T)obj);
		return true;
	}

	return false;
}

Table of Contents

ChainGet attempts to resolve a chain of member accesses and returns the result or default(TValue). Since TValue could be a value type, there is also an overload that has an out parameter indicating whether the value was obtained.

Be careful with this extension. Since it uses reflection, it’s a bit slow. For discrete usage, each call is under 1 ms, but if you use it in a loop with many items, the performance hit will become more tangible.

public static TValue ChainGet<TRoot, TValue>(
	this TRoot root,
	Expression<Func<TRoot, TValue>> getExpression)
{
	bool success;
	return ChainGet(root, getExpression, out success);
}

public static TValue ChainGet<TRoot, TValue>(
	this TRoot root,
	Expression<Func<TRoot, TValue>> getExpression,
	out bool success)
{
	// it's ok if root is null!

	if (getExpression == null)
		throw new ArgumentNullException("getExpression");

	var members = new Stack<MemberAccessInfo>();

	Expression expr = getExpression.Body;
	while (expr != null)
	{
		if (expr.NodeType == ExpressionType.Parameter)
			break;

		var memberExpr = expr as MemberExpression;
		if (memberExpr == null)
			throw new ArgumentException(
				"Given expression is not a member access chain.",
				"getExpression");

		members.Push(new MemberAccessInfo(memberExpr.Member));

		expr = memberExpr.Expression;
	}

	object node = root;
	foreach (var member in members)
	{
		if (node == null)
		{
			success = false;
			return default(TValue);
		}

		node = member.GetValue(node);
	}

	success = true;
	return (TValue)node;
}

private class MemberAccessInfo
{
	private PropertyInfo _propertyInfo;
	private FieldInfo _fieldInfo;

	public MemberAccessInfo(MemberInfo info)
	{
		_propertyInfo = info as PropertyInfo;
		_fieldInfo = info as FieldInfo;
	}

	public object GetValue(object target)
	{
		if (_propertyInfo != null)
			return _propertyInfo.GetValue(target, null);
		else if (_fieldInfo != null)
			return _fieldInfo.GetValue(target);
		else
			throw new InvalidOperationException();
	}
}

// Usage:
var myValue = obj.ChainGet(o => o.MyProperty.MySubProperty.MySubSubProperty.MyValue);

Table of Contents

DependencyObject

These extensions work just like their non-safe counterparts on DependencyObject, but will call Dispatcher.Invoke to do operations if the current thread isn’t a UI thread.

public static object SafeGetValue(
	this DependencyObject obj,
	DependencyProperty dp)
{
	if (obj == null)
		throw new ArgumentNullException("obj");

	if (dp == null)
		throw new ArgumentNullException("dp");

	if (obj.CheckAccess())
		return obj.GetValue(dp);

	var self = new Func
		<DependencyObject, DependencyProperty, object>
		(SafeGetValue);

	return Dispatcher.Invoke(self, obj, dp);
}

public static void SafeSetValue(
	this DependencyObject obj,
	DependencyProperty dp,
	object value)
{
	if (obj == null)
		throw new ArgumentNullException("obj");

	if (dp == null)
		throw new ArgumentNullException("dp");

	if (obj.CheckAccess())
		obj.SetValue(dp, value);
	else
	{
		var self = new Action
			<DependencyObject, DependencyProperty, object>
			(SafeSetValue);
		Dispatcher.Invoke(self, obj, dp, value);
	}
}

public static void SafeSetValue(
	this DependencyObject obj,
	DependencyPropertyKey key,
	object value)
{
	if (obj == null)
		throw new ArgumentNullException("obj");

	if (key == null)
		throw new ArgumentNullException("key");

	if (obj.CheckAccess())
		obj.SetValue(key, value);
	else
	{
		var self = new Action
			<DependencyObject, DependencyPropertyKey, object>
			(SafeSetValue);
		Dispatcher.Invoke(self, obj, key, value);
	}
}

Table of Contents

Getting the first instance open was easy. MSDN has a great article on how to get a query string out of your URI. Straight from the article:

private NameValueCollection GetQueryStringParameters()
{
    NameValueCollection nameValueTable = new NameValueCollection();

    if (ApplicationDeployment.IsNetworkDeployed)
    {
        string queryString = ApplicationDeployment.CurrentDeployment.ActivationUri.Query;
        nameValueTable = HttpUtility.ParseQueryString(queryString);
    }

    return (nameValueTable);
}

I was also aware that you can use a Mutex to synchronize your processes. It’s a much more elegant solution than a process table search. The only question was how do we pass data from one instance of my application to another? A common solution I saw was to defer to native methods and pass strings around that way, but I felt this was too inflexible of a solution, and it requires full trust to boot. Our particular application requires full trust anyway, but in the spirit of getting things done right, we decided to give WCF IPC a shot, and it definitely paid off.

My first proof of concept was much more messy than this, but I’ll spare you the clutter and discuss my better organized version. In any case, you will need to reference System.Deployment, System.ServiceModel, and System.Web.

I decided that I wanted to completely encapsulate the WCF and process synchronization logic, so I setup a class called ApplicationInstanceMonitor<T> : IApplicationMonitor<T>, where T is the type of the message you want to send with IPC. I decorated it with the following service behavior so we can use a singleton instance. Usually I’d go with a re-entrant concurrency mode, but since we won’t be handling very many requests, one at a time is sufficient.

[ServiceBehavior(
	InstanceContextMode = InstanceContextMode.Single,
	ConcurrencyMode = ConcurrencyMode.Single)]

Its implemented interface is pretty simple:

[ServiceContract]
public interface IApplicationInstanceMonitor<T>
{
	[OperationContract(IsOneWay = true)]
	void NotifyNewInstance(T message);
}

Next I created a method to deal with the Mutex, take action to setup IPC as necessary, and report its status.

private readonly string _mutexName; // Set by constructor
private Mutex _processLock;

public bool Assert()
{
	if (_processLock != null)
		throw new InvalidOperationException("Assert() has already been called.");

	bool created;
	_processLock = new Mutex(true, _mutexName, out created);

	if (created)
		StartIpcServer();
	else
		ConnectToIpcServer();

	return created;
}

For the WCF setup, I simply needed a URI to bind to (set or generated by the constructor) and a binding:

_binding = new NetNamedPipeBinding(NetNamedPipeSecurityMode.Transport);

So connecting to WCF was rudimentary:

private readonly Uri _ipcUri; // Set by constructor
private readonly NetNamedPipeBinding _binding; // Set as above
private ServiceHost _ipcServer;
private ChannelFactory<IApplicationInstanceMonitor<T>> _channelFactory;
private IApplicationInstanceMonitor _ipcChannel;

private void StartIpcServer()
{
	_ipcServer = new ServiceHost(this, _ipcUri);
	_ipcServer.AddServiceEndpoint(typeof(IApplicationInstanceMonitor), _binding, _ipcUri);

	_ipcServer.Open();

	_ipcChannel = this;
}

private void ConnectToIpcServer()
{
	_channelFactory = new ChannelFactory<IApplicationInstanceMonitor<T>>(
		_binding, new EndpointAddress(_ipcUri));
	_ipcChannel = _channelFactory.CreateChannel();
}

Now all that’s left to do in our class is expose out the useful methods. I use an explicitly implemented service contract interface to deal with the server-side, since that’s what WCF will call into and the regular implementation for the client side.

public event EventHandler<NewInstanceCreatedEventArgs<T>> NewInstanceCreated;

// NOTE: This is not a subclass, but here for ease of viewing.
public class NewInstanceCreatedEventArgs<T> : EventArgs
{
	public NewInstanceCreatedEventArgs(T message)
		: base()
	{
		Message = message;
	}

	public T Message { get; private set; }
}

public void NotifyNewInstance(T message)
{
	// Client side

	if (_ipcChannel == null)
		throw new InvalidOperationException("Not connected to IPC Server.");

	_ipcChannel.NotifyNewInstance(message);
}

void IApplicationInstanceMonitor.NotifyNewInstance(T message)
{
	// Server side

	if (NewInstanceCreated != null)
		NewInstanceCreated(this, new NewInstanceCreatedEventArgs(message));
}

There it is! Now all we need to hook it up is in our App.xaml.cs (assuming you’re doing WPF)

private Window1 _window; // Set by constructor
protected override void OnStartup(StartupEventArgs e)
{
	if (_instanceMonitor.Assert())
	{
		// This is the only instance.

		_instanceMonitor.NewInstanceCreated += OnNewInstanceCreated;

		_window.Show();
	}
	else
	{
		// Defer to another instance.

		_instanceMonitor.NotifyNewInstance(new MyMessage { QueryString = GetQueryString() });

		Shutdown();
	}
}

private void OnNewInstanceCreated(object sender, NewInstanceCreatedEventArgs e)
{
	// Handle your message here

	_window.Activate();
}

public string GetQueryString()
{
	return ApplicationDeployment.IsNetworkDeployed ?
		ApplicationDeployment.CurrentDeployment.ActivationUri.Query :
		string.Empty;
}

public void HandleQueryString(string query)
{
	var args = HttpUtility.ParseQueryString(query);

	_window.Message = args["message"] ?? "No message provided";
}

[Serializable]
public class MyMessage
{
	public string QueryString { get; set; }
}

And now we’re done. Just a bit of HTML and you’ll be communicating with your ClickOnce in no time!

From the people who confused you with the most elementary algorithms comes a series of things you really need to know to do your job! Watch, mystified, as the book which you have a test on in eight hours invents symbols to explain the details of single digit addition! You might have been top of your class in high school and showed promise through your core and basic classes, but just you wait! Our authors have learned and mastered techniques to simultaneously insult your intelligence and dumbfound you with a needless amount of abstraction and complexity! All this can be yours for the low-low price of $280 for our 120 page full color, hardcover book!

I’ve always been upset with textbook publishers, ever since my days in Computer Science 1, sophomore year in high school. The authors of that poorly constructed book (the binding literally only lasted about six months before self-destructing) took some kind of sadistic enjoyment in coming up with unintelligible vocabulary, patterns, and practices in which to subject students. In those days our teacher was our savior; no matter how mind-gratingly stupid and dull the book was, Mr. Patterson invariably sorted things out and never hesitated to say the book was moronic. I have to thank him for saving my sanity or, at least, staving off the inevitable future.

This semester, I draw particular complaint with the book in my databases class, inappropriately named “Fundamentals of Database Systems (5e),”  by Ramez Elmasri and Shamkant B. Navathe. I’ve been writing SQL for about four years now, but it wasn’t untill my last job that I think I really learned the full potential of a database system. My old boss was an absolute god in writing SQL and I  made certain that the learning experience more than accounted for the pay. It was under his tutelage that I learned how well-designed database systems were made and how to retrieve amazing data no one thought possible. I wouldn’t consider myself a sage in designing databases, but I think that I’m definitely qualified to pass judgment on most designs, especially the ones that would be considered “fundamental.”

During the early stages of my class, my professor discussed the all-important topic of table keys. (For my non-programmer friends, you use database keys to look up data in a particular table. Since some tables can have millions of rows, you have to choose a key that is unique and is as small as possible for quick lookup.) It’s a well-held practice in modern databases that the database is really the best agent to tell you what the keys are, so in general, what you want to do is tell it what your data is, and, like a coat-check, it gives you a little token (a 32-bit signed integer) to get your data again. Because the database chooses the key, you can be assured that it is both unique and small enough to quickly look things up. This is known as an auto-increment integer primary key column, mainly because the integer that you’re given is 1 (or some increment) more than the key that was given out last. Even though it’s not a traditional mechanism in database research, every major database (MSSQL, Oracle, MySQL, Protegé) has some incarnation of it. Traditionally, the programmer chooses one or more fields that combined are unique. While this is effective, it takes significantly longer for the server to prepare the key to look up the data and the number of fields that must be duplicated on tables so the original data can be found becomes tremendous. My database professor still disagrees with me, but I have faith that he’ll have an epiphiny sometime and understand and regret the error of his ways.

So why is it that these authors, from whom my professor quotes, have got it all wrong? In lieu of real research, I did some investigative Googling to find the qualifications of these men.

Ramez Elmarsi

• B.S., Electrical Engineering, Alexandria University (Egypt, 1972)
• M.S., Ph.D., Computer Science, Stanford University (1980)

Elmarsi has spent the bulk of his life in research while consulting for Honeywell developing a distributed database testbed and associated tools from 1982 to 1987. He now teaches at the University of Texas at Arlington and consults for various law firms.

Source: http://ranger.uta.edu/~elmasri/

Shamkant B. Navathe

• Ph.D., Industrial and Operations Engineering, University of Michigan (1976)
• M.S., Computer and Information Science, Ohio State University (1970)
• B.E., Electrical Communications Engineering, Indian Institute of Science (1968)
• B.Sc., Physics, Mathematics, University of Poona (India, 1965)

Navathe was a Systems Engineer for IBM from 1968-1969 before working for Electronic Data Systems in 1971. Starting in 1975, Navathe began teaching at NYU as an associate professor and then moved to the University of Florida for a few years until he ultimately settled at the Georgia Institute of Technology, where he teaches now.

Source: http://www.cc.gatech.edu/computing/Database/faculty/sham/

There’s no doubt that these men have the academic prowess demanded by their degrees and both have an extensive list of published works. But what really disturbs me is their professional résumé. Navathe stopped working professionally in 1971 and Elmarsi has never worked as a full-time employee at any company. This is when I understood exactly why my book is heavy on unintuitive mathematical symbols wielded like a bat with barbed wire and light on intelligence or edifying information. This field changes dramatically every couple years and unless you can keep up to date on the very latest technology, you are willing yourself into obsolescence. But yet some charlatans authors have the audacity to publish texts advising the unsuspecting student to continue using the old technologies of yore, rather than using what is new and efficient. Perhaps even more inexcusable is the book selection committee at my university choosing textbooks no one can read, let alone understand to remind all of us undergrad students that we’re not Ph.D.’s and we haven’t joined their elite clique.

I think this problem is far more widespread than I have broached here. A year or so ago, I wrote a letter I never delivered to my dean, more or less as a venting exercise. I think I’m going to clean it up and discuss my points here, in the event someone who can do something stumbles upon my humble blog.

It’s always interesting to see how different people answer the question. Especially people who have or plan to have degrees in it. Dictionary.com defines it as:

the science that deals with the theory and methods of processing information in digital computers, the design of computer hardware and software, and the applications of computers.

I see this broken down into:

• Science
• Theory
• Design of hardware and software
• Applications for computation

Normally, I’d say fighting the dictionary on definitions would be rather fruitless, but this is by far one of the most vague definitions I’ve ever seen. I think a good analog for CS is math and physics. In that much more mature field, mathematics provides laws that say x should exist. It is then up to the applied physicist to prove in a lab that the theory is true. Even then, it is up to a company and its engineers to productize and actually use the fruits of science. Computer Science, in stark contrast according to this definition, is all of those things rolled up into one. It’s no wonder why no one in this field knows what it means.

To me, the entire term “Computer Science” is a huge misnomer. It’s certainly not science. Science, at least to me, involves creating a hypothesis, setting up an experiment, and proving the truth of your assumptions. Last time I checked, there was no such thing in CS. Nobody sits around and hypothesizes about algorithms, let alone commercial programs. I think upper management would have a conniption if their products were experiments.

So what about computers? Surely you use computers in CS! I suppose most of my professors didn’t get that memo, and, historically, that really hasn’t been the case either. Edsger Dijkstra, one of the most renowned computer scientists in our short history, never used a computer. Even his musings, as late as 2001, were handwritten. Dijkstra had a very particular view of CS. To him, Computer Science was purely theory – really quite close to a real science in terms of algorithm design and such. It was his opinion that all these programs we run on our computers are perversions of computation. In the spirit of our forerunner, my professor in Advanced Data Structures forwent computers in favor of the more conventional pencil and paper. To be fair, I’m almost certain he was a machine, based upon his ability to do the most tedious and mundane calculations ad nauseum with the patience of any of Intel’s creations.

Since it seems my degree is almost as ambiguous as a Liberal Arts degree, I will posit my suggestions for changing it. Fortunately, unlike my comparison, my degree is both useful and salvageable.

My university has done a good job of trying to distill the ideas that I’ve covered here, and, for that, I commend them. It is, however, nothing short of unprovidential that they’ve managed to distill one form of mud into two forms of mud. The school offers degrees in Computer Science and Software Engineering. Despite what you might think, SE is hardly its namesake. What they ended up with is a theory-application mix (CS) and a application-business mix (SE). At least it’s a step in the right direction.

I think we need three degrees, as you have probably noticed that I’ve been hinting all along:

1. Theoretical Computation
2. Software Engineering
3. Software Management

Theoretical Computation would focus on algorithm design and computability, as its name suggests. It’s not a science, and it has no computers in it – just computability, or the ability for something to be derived from calculations and deterministic processes.

Software Engineering would actually live up to its name. Programming would be king, like the pencil is to the artist. Software architecture would be a major emphasis, as well as applied algorithm design, which could reach over into Theoretical Computation.

Finally comes Software Management. Because software planning is a huge issue for any company that writes software, be it boxed or internally distributed, we need people who are trained to help the process along. These people need to be business savvy to communicate deadlines and goals to the non-technical arm(s) of the company. Furthermore, Software Management majors have to be technical enough to be able to choose good employees.

A lot of people in the field feel that there will be a strong resistance to change for such a degree plan, even if it makes sense. I can understand the impetus, but at the same time the degree itself hasn’t existed for forty years, so there is always hope for reorganization.

Jeff’s argument is pretty simple:

• The web is a forgiving place.
• Many big-name websites don’t pass validation.
• James Bennett doesn’t like XHTML.
• CSS isn’t as intuitive as HTML-embedded properties.
• Validity is relative to your standards.

Since Jeff “vehemently agrees” with Mr. Bennett, I decided to investigate his article as well, to try and understand where Atwood was coming from. Benett’s argument is even more basic:

• No real advantages.
• Markup errors are fatal.
• There is some CSS/DOM incompatibility between HTML 4.01 and XHTML.

The majority of these points, are, in my opinion, rooted in ignorance and xenophobia, both of which are disastrously fatal in our industry, especially on the Web. It is true the Web is very forgiving, but only because it must be so. HTML is a novel language, in the sense that you don’t move from line to line, from procedure to procedure, but rather declare the structure of how something looks and let the renderer (IE, Firefox, Safari) choose the best way to view it. A good example is when Firefox switched from an iterative to a recursive implementation in its third version and also reimplemented its graphics engine. Because of the declarative nature of HTML, websites weren’t adversely impacted. However, like all new things, HTML has its quirks. Namely, it’s not very easy for computers to understand. In fact, sometimes it’s not all that easy for even humans to understand – maybe a sort of inverted Turing test.

Like all the triumphs in Computer Science, someone identified the problems that exist in HTML and created a far more flexible and extensible language called XML. XML is now one of the best containers for information because of its well-designed and understandable structure and its infinite flexibility. While that’s great for data storage, what about the Web? Well, that’s where XHTML 1.0 came in, as a statically defined language like HTML, but a machine-understandable and consistent language, like XML. XHTML, is, at its very essence, the best of both worlds.

I think Atwood and Bennett had a similar reaction to XHTML as I did:

Back when XHTML went 1.0, I was somewhat surprised to see that they had actually removed elements and attributes from the specification. Usually, moving to a new product means that you get more, not less.

The difference here is that they refused, either consciously or unconsciously to adapt to and understand where the Web was – and still is – going. The W3C is going for a very specific separation of concerns for websites. XHTML is designed to be the static structure of a website. It contains data (text and such), and some hints on how to present it (whether it be in paragraphs, tabular, or a list), but nothing else. This is where CSS comes in. CSS decorates the XHTML, quantifying distances, sizes, backgrounds, and organization. Finally, JavaScript gives the client a smooth feel, dynamically altering the web page to best suit the client, and, as of late, retrieve data on the fly through AJAX and JSON. This is why HTML attributes are almost all deprecated in XHTML – the static structure doesn’t care how wide things are or how tall they are. One of the best examples that I can think of to demonstrate the division of power between XHTML and CSS is CSS Zen Garden. The opening page is modest enough, but choose one of the designs on the right sidebar and the entire layout changes. The only difference between the default and new design is a new CSS style sheet. You’ll notice it has all the same text, all the same navigation, but a completely different look. Why is this useful or important? Well, as a form of broadcast media, it is salient to shape the way your website looks based on the viewer. For instance, if you go to a website on an web-enabled cellphone, I’d want to strip out as many ancillary graphics as possible and conserve as much width as possible. If you’re vision impaired, I want to be able to deliver to you a web page that a TTY device can easily understand. Or, perhaps, you’re a search engine and I want to get straight to the point so you can index better. This should all be easily accomplished by specifying the use and intention of each style sheet and allowing the user to choose the one that best suits their purpose.

Of course, someone always brings up the fact that many name-brand websites aren’t valid at all. I’d also like to point out that many big-name trading firms are going bankrupt. Just because they don’t care doesn’t mean you shouldn’t. The argument itself is infantile. I’m not trying to inflate my ego any (trust me, that’d be a bad idea), but I find writing XHTML 1.1 (which is by far the strictest) to be very easy. When Marlene and I drew up the static format for this website (that is, before we plugged in all the WordPress stuff), I had about three validation errors, all of which were quelled very easily. Personally, I was a little disappointed I had any, but I suppose perfection was never a trait I had.

Jeff also wonders whether CSS validation is possible. I’m not entirely sure why he didn’t bother to check Google. Of course CSS validation exists, and I’m proud to say this website’s CSS is valid as well.

It’s unfortunate that XHTML markup errors are indeed fatal (and the errors aren’t always very helpful), but as a C# developer, I’m used to having compiled code. If I messed up and miscommunicated with the machine (again, perfection is not one of my virtues), I want the machine to tell me that it doesn’t understand, rather than acting like my girlfriend, misinterpreting what I said, and summarily stating that I don’t love her anymore. Obviously it’s simply untrue; I will always love my computer. Girlfriends are a bit different.

So, perhaps the most important question is, why do we need standards? The need for validation clearly hinges upon the need for standards; without validation, how can one tell if standards are being upheld? And without standards, the Internet would be far more segmented than it is already. Jeff is right that most people don’t understand the W3 Valid “stickers” some webmasters (like myself) have on their websites in various locations. This doesn’t really bother me, though. Most people don’t notice half the validations on many of the products they use everyday. On the inside of the battery cover of your cellphone, there exist a multitude of symbols, each representing a different standards body that approved this device to work with the network. Yet millions of people blithely continue on, blissfully ignorant of the years of effort that go into making such a device. Such is the thankless life of an engineer. No one notices when you make amazing accomplishments (and a W3C valid website is hardly a major feat), but everyone complains when the slightest flaw presents itself.

I suppose we just learn to deal with it.

In any case, my professor is a big proponent of Java, the Waterfall SDLC (which he dubs “the generic SDLC.” I wasn’t aware wet sand was considered “the generic foundation”) and, of course, all the misery that comes with it.

For one of our more recent homework assignments, we were given the trivial task of converting a four Java classes from a previous assignment into UML diagrams. We were obviously applying what we learned in class by putting the cart in front of the horse. Our assignment was to be done in JUDE of all things. In the interests of full disclosure, I am completely spoiled in terms of tools to use. Microsoft, through its godsend of MSDNAA makes Christmas just about every day of the year for me. Sure I know it’s a form of product marketing – analogous to giving crack to kids – but have you used their stuff? It’s head and shoulders above everything else, and in many cases is the paradigm to which the industry only seeks to make parity with. With that being said, I’m hoping you’ll understand my… disposition against Fischer Price’s JUDE product. Instead of trudging through the installation of a clearly inferior product, ripping my hair out trying to understand the UI, and eventually producing a diagram that my 5-year-old cousin could have drawn better, I decided that I would use Visio instead. I made my diagrams down to the letter and they looked beautiful. I spent extra time making sure that the positioning of each class reduced the nmber of times connections intersected and made especially sure that everything was clear. I saved it out as a PDF, so as to be platform agnostic, and submitted it.

I wasn’t nearly as surprised as I was livid when I found out that I had been deducted 50% credit on the sole basis of, “it’s not a .jude file.” That is the kind of arrant pedantry up with which I will not put. To me, it’s really the equivalent of me asking you to write a paper on Shakespeare in blue ink. I’d suppose a lot of people would remark, “well, I write in blue ink anyway, so it’s not a big deal,” and continue on. Still more would say, “normally I write in black ink, but I’ll comply because it seems like a trivial request, and not worth the fight.” This would probably leave me by myself stating emphatically that it is unreasonable to be concerned with the color of the ink that I write in juxtaposed against the magnitude of writing a paper on Shakespeare. Of course, I’d comply if the reasoning for the requirement of blue ink was enumerated, so long as it wasn’t arbitrary.

Perhaps even more important than the freedom aspect of the scenario is the abject insanity that revolves around diagrams. Who cares if your diagram was written in Visio, JUDE, Rhapsody, or on a whiteboard? It’s a diagram. The concept of WYSIWYG is almost an understatement. It might be argued that JUDE is an “enterprise application” and my good professor is trying to do me a favor by showing me a tool that’s used in the “real world.” I don’t think I would ever want to work for an employer that says, “We see  UML on your résumé, but while we think you’re smart enough to work on our codebase, we don’t think you’re smart enough to learn to use the UML tool we have.”

I think it’s more important to state the objectives of any assignment, be it professional or educational, and let the person doing the work choose the best way to accomplish it. Nobody likes a micromanager. Especially me.

So that leave three or so of you guys using IE. Well, I hate to break it to you, but your browser sucks. It really does. Web developers everywhere have been rejecting Microsoft’s browser for some time now, which has given rise to the healthy market share Firefox has had.

How does this affect you and me, you may be wondering. Well, let’s do a case study on the site you’re looking at right now, since I’m fixing it up anyway. For those of you not using a W3C compliant browser (read: IE), the website is supposed to have some blocks of color of varying height below each of the navigation links, which highlight to orange and a main body text that wraps around the sidebar on the right.

My post about hashing as seen in Firefox.

Beautiful. Everything looks just like it should in Firefox, Safari, Chrome, and Opera. But what happens when we look at it in IE?

The same post as seen by Internet Explorer 7

Oh wow. Not what I was going for at all. This is quite common for web developers to experience: write a website and make it perfect for the W3C compliant browsers and then try and get it to work in IE, because in all honesty, IE makes very little sense in terms of expected results. On another project, I instructed the browser to move an object 6 pixels left and 10 pixels down. Firefox was happy to oblige, but IE only moved it 3 pixels left and 8 pixels down.

So what’s going on here at the root, so we can fix it? Well, if you inspect my CSS, you’ll find this tidbit:

#sidebar {
	float: right;
	width: 250px;
	list-style: none outside;
	background: white;
	margin: 0 0 0 10px;
	padding: 5px;
	padding-left: 20px;
}

Most notably, I’m using CSS floats to put the Sidebar on the right. By doing so, I’m instructing the browser to make some space for it and to wrap text around it. IE obviously doesn’t care about my floated div, so it just disregards the instruction. That leaves me in a precarious position. Should I abandon my floats, which lead to nicer, cleaner XHTML in favor of tables because of one non-compliant browser? Of course not! Instead I have a little function that tells me what browser you’re using called get_browser(). The code looks like this:

$browscap = get_browser();
define('IE', ($browscap->browser == 'IE'));

The same post in Internet Explorer 7 with my fixes.

This gives me a global constant, IE that allows me to change how the website looks if you’re running IE. With this in mind, I actually insert in a table in the middle of the page to force the sidebar to stay on the right. Problem solved.

As I was doing all this, I wondered if IE8 would give me any relief. I was somewhat surprised to find that it does, in fact, respect floating divs, and even respects the :after pseudo classes that allow me to add those blocks under the navigation links. Just not the hovering. Sigh. Anyway, all I needed to do was modify my IE code to check the major version number of the browser to say that IE8+ was really mostly W3C compliant.

$browscap = get_browser();
define('IE', ($browscap->browser == 'IE' && $browscap->majorver < 8));

So why is IE this way fundamentally? I don’t have any real code or facts to base these assumptions on, but my speculation is based on working with both XHTML and CSS as well as C# / WinForms / WPF. I assert to you that Microsoft has misunderstood the Web since its inception. With things like ActiveX (now, thankfully, deprecated) it seems like Microsoft has always wanted to bring Windows to the web – literally. In Windows Forms (the battleship gray programs we all used to know), each visual element is a very unique item. Buttons don’t behave very much like Panels which don’t behave very much like CheckBoxes. It follows that you can’t really apply properties that relate to a Button to a Panel. Sensible enough. Unlees you’re dealing with XHTML and CSS. Back when XHTML went 1.0, I was somewhat surprised to see that they had actually removed elements and attributes from the specification. Usually, moving to a new product means that you get more, not less. It took some time, but I eventually realized that the Web isn’t like WinForms at all. Each element on the web (with the exception of form controls like ComboBoxes and CheckBoxes) is really the same. Almost everything can be broken down into a div or a span, and really if you change the display attribute on them, you end up with one amorphous panel.

This is the fundamental difference between IE and the W3C triad. Microsoft insists that floats and hovers really shouldn’t apply to things like divs, because they come from two seperate branches in the object tree. Really, until Microsoft realizes this, throws the existing codebase out, and tries again, IE will never be able to keep up with the rest. It’s a matter of understanding the nature of the Web and using an appropriate architecture to interpret it.

This semester I’ve finally qualified to take the CS Senior Design Project, which, this semester, is to design a Chord client. At the heart of the system is the identifier, which is essentially a glorified hash. We decided to go with SHA-256, partially because the instructor mentioned it was in the class of his favorite hashes. It didn’t really matter to me, since C# supports it just as easily as anything else.

Identifiers have two essential purposes, comparison and addition, from which every method can be derived. I wasn’t particularly intrigued by either of these topics, since almost without exception, you can rely on existing structures in the FCL to do whatever you need to do, and it’s always better to do so. Now, I said “almost without exception,” namely because I stumbled upon the fact that these identifiers unequivocally are exceptions. The thing about using a SHA-256 hash – or any hash for that matter – is that it’s an enormous value – 256 bits to be precise. There aren’t any real 32 or even 64 bit hashes available (I doubt they’d be useful), so relying on the good ol’ FCL goes out the window.

Other students, stuck in the abyss of Java, were having difficulty getting their socket implementations going, so mucking around in massive integer arithmetic was right out. I believe the professor advised them to take the 32 MSB and just rely on an unsigned integer. (Side note: does Java even have unsigned integers?) I considered a few similar options: taking the 64 LSB or separating the hash into several equal groups of 64-bits each and getting the xor result of the segments. Arrogantly I proceeded on, demanding that whatever I wrote work not only for SHA-256 but also SHA-512 or anything else using the full bit-length.

Comparison wasn’t difficult. Essentially, you start at the MSB in your array (which happens to be at Length - 1) and compare until you find a comparison != 0:

public int CompareTo(Identifier other)
{
	for (int i = _hash.Length - 1; i >= 0; i--)
	{
		int compare = _hash[i].CompareTo(other._hash[i]);

		if (compare != 0)
			return compare;
	}

	return 0;
}

Now comes the fun part. First, I wrote a little method called Pad(byte[] list, int size) which pads the MSB of an array with 0′s until it’s the proper length. After several iterations, I finally ended up with this:

public static byte[] Add(byte[] a, byte[] b)
{
	if (a.Length > b.Length)
		b = Pad(b, a.Length);
	else if (a.Length < b.Length)
		a = Pad(a, b.Length);

	byte[] result = new byte[a.Length];

	int carry = 0;
	for (int i = 0; i < a.Length; i++)
	{
		int value = carry + a[i] + b[i];

		// get the bottom part of the bits
		result[i] = (byte)value;

		// knock off the bottom bits that we already got and
		// put the rest into carry.
		carry = (value - result[i]) / byte.MaxValue;
	}

	return result;
}

The data holder for carry has to be large enough for the worst case scenario 0xFF + 0xFF + carry 1, which is why I chose an int rather than a byte (although a short could have worked just as well, I suppose).

Subtraction was more difficult. Consider the way you subtract, with carrying, etc. Carrying on its own is a recursive process, and I can’t imagine writing it out. It was at that time that I remembered how the ALU does subtraction- by taking the two’s compliment of the second operand and doing addition. So I followed suit:

public static byte[] Subtract(byte[] a, byte[] b)
{
    if (a.Length > b.Length)
        b = Pad(b, a.Length);
    else if (a.Length < b.Length)
        a = Pad(a, b.Length);

	byte[] twoscomp = new byte[b.Length];

	// get the 1's compliment
	for (int i = 0; i < b.Length; i++)
		twoscomp[i] = (byte)(byte.MaxValue - b[i]);

	// add 1
	twoscomp = Add(twoscomp, new byte[] { 1 });

	// NOTE: twoscomp is now the two's compliment of b.

	return Add(a, twoscomp);
}

I also needed multiplication, but I’m still working on the solution. I’ve got a working draft, but I’m not entirely sure I’m happy with it just yet. I’ll keep you notified.