So to get my head around the Ruby example, I worked up one way to do it in PowerShell using the New-Module cmdlet, wrapped it in a function and you can see the code below.

Like Ruby, PowerShell lets us assign a string to Address in the first example ($p1) and then in the second example ($p2) to a more complex object without breaking the Person implementation.

Rob Conery’s post goes on to show that C# 4.0 can do the same thing. The dynamic dial is being turned up for this static language.

Rob suggests:

C# is going more and more dynamic – time and feature set have proven that. Maybe it’s time to bend your thinking? Or maybe it’s not…

In either case it is possible to do and should make for interesting discussions.

Function New-Address {
    New-Module -AsCustomObject -Name Address {
        $Number  = $null
        $Street  = $null
        $City    = $null
        $State   = $null
        $Country = $null            

        Export-ModuleMember -Variable *
    }
}            

Function New-Person {
    New-Module -AsCustomObject -Name Person {
        $Name    = $null
        $Address = $null                    

        Export-ModuleMember -Variable *
    }
}            

$p1 = New-Person
$p1.Name = "Mary"
$p1.Address = "Number 17, Cherry Tree Lane"
$p1            

$p2 = New-Person
$p2.Name = "Burt"
$p2.Address = New-Address
$p2.Address.Number = 17
$p2.Address.Street = "Cherry Tree Lane"
$p2.Address.City = "London"
$p2            

# Result
Address                                                              Name
-------                                                              ----
Number 17, Cherry Tree Lane                                          Mary
@{City=London; Country=; Number=17; State=; Street=Cherry Tree Lane} Burt

I wrapped his call like so:

Test-IsAppFabricInstalled

Next would be to enable this to take a list of computer names so it can check remotely for AppFabric installations. I leave that as an exercise for the reader.

Function Test-IsAppFabricInstalled { SearchKB -KBID "KB970622" }

Ron Jacobs PowerShell Script

Function SearchKB($KBID)
{
    $found = $false            

    # Get all the info using WMI 
    $results = Get-WmiObject `
                -class “Win32_QuickFixEngineering” `
                -namespace "root\CIMV2"            

    foreach ($objItem in $results)
    {
        if ($objItem.HotFixID -match $KBID)
        {
            $found = $true
            break
        }
    }            

    $found
}

Code

Right mouse click inside of Main.

Sequence Diagram

Produces this diagram.

• Exception handling
• Breaking out of a loop early
• Long ranges
• Thread-local state
• Configuration options
• Nested parallelism
• Dynamic thread counts
• Efficient load balancing

This is followed by another hundred pages of good info.

C# 4.0 Dynamic with Chris Burrows and Sam Ng

Along the way he comments on the dynamic (evil) keyword debate, pointing out that lambdas enjoyed the same treatment. Some love it, some hate it, some say it bloats the language.

I tend to agree Bertrand, “I’ll just use it where I see a use case, thank you very much”. 

[…] I’d say that although we are having a healthy debate on the dynamic keyword (and we should have that debate), I’m confident that in one or two years, we’ll have some incredibly imaginative uses of the feature that will simply blow us away and will make the current conversation a little sillier than it seems today.

To not only manage exceptions and cancellation, but also to make events composable is yet another challenge.

Check out Matthew Podwysocki’s Introducing the Reactive Framework Part I

It’s never long before anger turns to spreading FUD (Fear Uncertainty Doubt).

The var keyword in C# is a prime example of this. Many developers wrote erroneously that using it would mean that your code was no longer strongly typed and would lead to all hell breaking use.

“My friend used the var keyword in his program and it formatted his hard drive, irradiated his crotch, and caused the recent economic crash. True story.”