Simon Green posted a good comment on a previous post of mine (I like Guids), which is a generic class that wraps Guids, so that you get a nice compile time error if the wrong guid is used in the wrong place.

e.g.

/* Doesn't compile
Library.BorrowBook(bookId, personId);
*/

// Compiles fine
Library.BorrowBook(personId, bookId);

Whereas with a normal signature of (Guid, Guid) you'd get no compile-time error if the parameters were mixed up.

Try his solution out, and let me know what you think.

Cheers,

Kirk

On Krzysztof Cwalina's blog there's an example of what may be coming in the Managed Extensibility Framework, a framework for dependency injection, naming and activation, and duck typing. Looks like it could be interesting when released.

While on his blog, I got to reading some of the older posts:

• The second edition of Framework Design Guidelines is in the works, and may be out by the end of the year.
• The Framework Design Guidelines Digest v2 is available for download in PDF format.
• How to Design Exception Hierarchies gives good advice on when to create new exception types, and when to reuse existing types.

There's good stuff buried in the archives of Krzysztof and Brad Abrams blogs.

Here's an idea that would work well in Courtenay Place:
http://stevewellsphoto.wordpress.com/2008/04/16/cruising/

A sign on the side of the road that says:

No Cruising Zone
Motorists passing the traffic control point 2 or more times in 4 hours are subject to citation

That'd teach those kids a lesson!

The photo is taken by photographer extraordinaire Steve Wells. Formerly of Wellington, now in Paris, and has a great new photo every day on his blog.

I'm presenting at the Wellington .NET Users Group this Wednesday night.

The aim is to have a bit of a run-through some of the interesting bits I pulled out of the Lang.NET Symposium videos, run through how the different CLR languages fit together and into the CLR, and talk about some of the things we have been hinted at for the future.

More details on the Wellington .NET Users Group site.

These guys crack me up:

And congratulations to Stephen and Melanie :)

Inversion of Control Containers and the Dependency Injection pattern

Some final thoughts on threat modeling - a series on threat modeling

FXCop blog: What rules does Microsoft use?

Gilad Bracha - Computational Theology, Functional versus Imperative, Language History and Futures

Programming in the Age of Concurrency - Anders Hejlsberg and Joe Duffy: Concurrent Programming with PFX

LinFu.DynamicProxy, part 2

What is Ruby?

Guidelines for building RESTful web services:

Generate Your Own Security Code Review Checklist Document Using Outlook 2007

Inbox Zero

LINQ Framework Design Guidelines

LINQPad

Framework Design Studio

Anders Hejlsberg Film Festival: The C# and other VS Language Teams at the Movies

OAuth - Getting started

Instant domain search

Cool - Igor Moochnick has announced the release of pash, an open source implementation of PowerShell that runs on Mono or Microsoft's CLR.

I will be interested in seeing the uptake of Posh among Unix developers -- Powershell is more of an evolution of the standard Unix scripting environments such as bash, perl, and tcl, so should feel right at home.

This Star Trek parody to the tune of Ruby is quite nerdy and fun:

http://www.youtube.com/watch?v=mQoVqY2mWus

From 2006 - you may have seen it already, I hadn't.

I've been reading Charlie Calvert's blog, and his list of LINQ providers, and watching both the Lightspeed and LLBLGen Pro LINQ beta's with interest.

There's an available product that you can buy - the CHI69 "Computer Human Interface" - I have written a LINQ provider over the API provided within the supplied SDK.

Download the beta LINQ to Spouse provider here.

Connect to the CHI69 device, and read in the environment:

// Open environmental interface
Environment environment = CHIConnector.Connect<Environment>();

Build the representation of the user:

// Open self-representation
Husband me = CHIConnector.Self<Husband>();

The device allows querying the local environment for objects of different types using LINQ: 

// Search all available for a girlfriend
var prospects = CHIConnector.AllAvailable<Girlfriend>();

Girlfriend girlfriend =

(
from prospect in prospects
where
(prospect.Husband == null || prospect.MaritalStatus == MaritalStatus.Rocky)
&&
prospect.IsCompatibleWith(me)
select prospect
).First();

Peform some realistic actions with returned objects:

Thread.Sleep(69);

The library exposes a rich interface:

// Test marriage criteria

if (me.Mood == Mood.Romantic &&
    environment.Lighting <= Lighting.Flattering &&
    girlfriend.Emotions.Contains(Emotion.Desperate))
{

// Note the downcast. Some functionality will become unavailable
me.Wife = (Wife)girlfriend;

}

So go ahead and test the library and provider. I'm interested in any feedback you can give.

Some notes:

• Wife inherits from Husband (by definition, the functionality is a superset)
• Version 69 of the CHI device only allows for monogamous relationships. Due to demand, apparently this requirement will be removed in an upcoming release
• As an optimisation, some inherited properties are implemented or cached in the class library, rather than querying the real-world object (e.g. wife.IsRight does not require a remote call as the result is deterministic)
• The default device communication protocol is messy. Using SOAP would clean it up.
• Setting me.Salary = 0 will throw an OutOfLuck exception, terminating the program.
• High intensity emotions (e.g. wife.Emotion.Intensity >= Intensity.Danger) result in unpredictible behaviour.

PageofWords.LINQToSpouse.zip (14.36 KB)

It's good to see on John Lam's blog that videos from Lang.NET are now available.

They are Silverlight hosted, but if you want to download them directly, here are the links to the WMV files (right-click to save them to your disk):

Videos/1-00 - Keynote - Jason Zander

Videos/1-01 - CSharp3 - Anders Hejlsberg

Videos/1-05 - Lively Kernel - Dan Ingalls - Sun

Videos/1-06 - JScript - Pratap Lakshman

Videos/1-07 - Irony and ERP Language Challenges - Roman Ivantsov

Videos/2-00 - Democratizing the Cloud with Volta - Erik Meijer

Videos/2-01 - Newspeak - Gilad Braha - Cadence

Videos/2-02 - Resolver One - Giles Thomas - Resolver

Videos/2-03 - Retargeting DLR - Seo Sanghyeon

Videos/2-04 - Visual Basic - Paul Vick

Videos/2-06 - PHP - Wez Furlong

Videos/2-07 - Phalanger - Tomas Petricek

Videos/2-08 - Pex - Peli de Halleux

Videos/2-09 - Numerical Computing with the CLR - Jeffrey Sax - Extreme Optimization

Videos/2-10 - remotion Mixins - Stefan Wenig and Fabian Schmied - rubicon

Videos/2-11 - CodeIt - Serge Baranovsky - submain

Videos/3-00 - IronRuby - John Lam

Videos/3-01 - Ruby.NET - Wayne Kelly

Videos/3-02 - FSharp - Luke Hoban

Videos/3-03 - Parsing Expression Grammars in FSharp - Harry Pierson

Videos/3-04 - NStatic - Wesner Moise - SoftPerson

Videos/3-05 - Moonlight and Mono - Miguel de Icaza

Videos/3-06 - Visual Studio Shell - Aaron Marten

Videos/3-07 - Modeling and Languages - Don Box

Videos/3-07 - Modeling and Languages - Don Box_1

Videos/3-08 - Cobra - Chuck Esterbrook

Videos/3-09 - Intentional - Magnus Christerson

The .NET user group is kick-starting the year with a country-wide road trip around New Zealand. Chris Auld and Jeremy Boyd are travelling to 11 towns and cities around NZ, and this Wednesday Feb 13, they come to Wellington:

http://wellingtonroadtrip08.events.live.com/default.aspx

Please come along and check it out. The event is shaping up to be the biggest .NET user group event that Wellington has seen yet, with over 350 people registered! I remember the first .NET user group meeting I organised, it had less than 10 people...

The session starts at 1:30 (doors open at 1pm), and will cover lots of cool new things, including Windows Server 2008, SQL Server 2008 and Visual Studio 2008, as well as covering some other cool related technology such as HyperV.

See you there!

Kirk

A few years ago I wrote a guid shrinker, so that I could send out urls with guids in them, but have shorter messages. This was for mobile work, and so I called them "Muid's" (for mobile unique identifier).

To do this, I wrote a converter that converted from a 16 byte guid to a 21 or 22 character string, increasing the character set to 64 characters instead of the 16 characters used by guid's default ToString() (A-Z, a-z, 0-9, - and $).

It was with a little embarrassment that I read Dave Transom and Mads Kristensen's posts, where they use the Base64 encoder to do the character encoding, while I didn't think of that, and wrote an encoder / decoder myself.

So check out Dave's ShortGuid if you want shorter urls with all the benefits of guids (very hard to guess, globally unique), but don't want to sacrifice the extra 10-14 characters in every url.

Ever wondered which website stole your address and sold it to nasty spammers?

If you use GMail you can use a handy feature known as "Plus Addressing", which lets you receive emails into one GMail account using a variety of email addresses.

When spam arrives in your inbox, you can use the extra information you put into your email address to figure out which website sold your email address or spammed you.

How to do it:

You don't need to make any changes to your GMail account. When signing up to each new website or mailing address, use a slightly different email address.

For example, if your email address is kirkjackson@gmail.com, when you sign up to www.last.fm, you can use the email address kirkjackson+www.last.fm@gmail.com and the mail will still come through to your GMail account.

e.g. Sign up to each site with a distinctive email address:

live.com - kirkjackson+live.com@gmail.com
facebook.com - kirkjackson+facebook.com@gmail.com
evilnasty.com - kirkjackson+evilnasty.com@gmail.com
etc

When you receive emails:

Each email you receive in GMail will have a different "to" address, with the site that sent it to you. Click "Show details" on the message to see the full address that the email was sent to.

If you're receiving spam to a particular email address (e.g. kirkjackson+evilnasty.com@gmail.com), then you know which site to complain to -- although that probably won't work. But better than that, you can write quite a simple filter in GMail delete messages as soon as they arrive.

Caveats:

This works best for sign up emails to sites that you don't trust, and that you don't expect to use again. It can be hard to remember your email address to log in if you need to return to Facebook.

If spammers get smart, they could just send email to your base email address (e.g. kirkjackson@gmail.com), even if you entered kirkjackson+evilnasty.com@gmail.com into their site.

Some websites won't allow you to enter +'s into an email address form -- because they haven't read RFC 2882.

Another year coming up. Back to work tomorrow after a relaxing few days off.

Today I was awarded a Microsoft MVP again, so that's a good start to the year.

The Australian Windows Server team have done a good job with the new comic strip Server vs Client:

Not sure how you subscribe, but they're going to update weekly. Check it out.

Kirk

On Wednesday I listened to an interesting talk on IronRuby by Ivan Porto Carrero.

Ivan has a set of interesting posts on IronRuby on his blog, including a few examples on how to wire up WPF apps using IronRuby rather than XAML.

The slides from his talk are available.

Thanks Ivan!

Next session at the Wellington .NET User Group is 5 December. More details to follow.

Wellington is a happening place if you want to learn something new. Last week at the .NET user group we had a great presentation by Jeremy Boyd on the developer features in SQL 2008.

Next Wednesday we've got a presentation on IronRuby by Ivan Porto Carrero.

Mark Carroll is starting a new Team System user group in Wellington, the first meeting is 28 November (Jeremy has the details).

As well as .NET and Team System, other user groups in Wellington are:

• Wellington SQL Server Users Group
• Wellington Sharepoint Users Group
• Zamdes (WPF and Silverlight)
  
• Wellington Connected Systems User Group
• Wellington Office Users Group
• Project user group

If you managed to go to all of them, you'd be eating lots of pizza!

Kirk

Perhaps more interesting than the other PowerShell features announced in the past week, the SQL 2008 team will release a PowerShell provider in their latest CTP.

For a little more on providers, see my earlier post. I hope the provider allows data access, and not just management capability.

Looking forward to having a play with that when I can get my hands on it!

Kirk

Reading, transforming and instrumenting MSIL has been something that has kept me interested (and sometimes over-wraught) since the .NET framework came out in 2000.

It's interesting to see the benefits that a common intermediary language and a virtual machine bring to the party: difficult problems can be dodged by programming language designers (such as garbage collection); languages can interoperate; compiled code can be platform independant, and JIT compiled when needed -- and doing fun stuff with compiled code is easier (and more fun!) with MSIL or Java bytecode.

A few interesting things have happened with Java bytecode over the past few years, with a couple of high profile cases recently. Java bytecode is no longer just the output of a java compiler and the input for the Java Virtual Machine:

• Google's new Android phone platform translates from Java bytecode to its own virtual machine -- which is not a JVM (via Miguel and Stefano)
• IKVM.NET, a runtime and set of libraries that convert Java bytecode to .NET MSIL
• Jython, a version of the python language that compiles to the JVM

Of course the same thing happens in the .NET land -- there are a multitude of languages that compile to MSIL, and MSIL can be run on the Microsoft .NET CLR, Mono's runtime engine and a few other runtimes built by Microsoft and third parties.

The angle taken by Google in developing an alternative virtual machine, rather than using the CLR or Sun's JVM is very interesting. On one hand, they have the benefit of full control of their platform, and this move means that they are not reliant on other vendors solutions. They promise to open source the platform, so the typical arguments about closed proprietary platforms may not apply, but it will still be interesting to see how another VM fits into the ecosystem.

I think it was Derek that first convinced me of the beauty of the Guid, and I have been using them in databases ever since.

Wade Wright has written up the "Gospel of the Guid". It has a humorous coverage of some of the good Guid reasons:

• No database roundtrips to get the next integer ID
• Easy merging, mirroring and deletion of erroneous merges
• Ability to wire up relationships in memory before saving

I remember when I first started using Guids there was talk of them not being unique, due to dodgy network cards having the same MAC address. Thankfully that's no longer a problem.

Something that I struggle with though, is the lack of type safety when using Guids. e.g.

Guid personId = Guid.NewGuid();
Guid bookId = Guid.NewGuid();

Library.BorrowBook(personId, bookId);

...or is it this way around?

Library.BorrowBook(bookId, personId);

There's no compiler checking that the correct Guid is passed to the right parameter. I've been toying with a Guid wrapper that would be a bit like a typedef in C++, but typesafe. Has anyone already done this?

I seem to spend less time in Virtual PC and more time in (nested) remote desktop sessions these days. I'm not a huge mouse fan, and when using the keyboard I need to do this when I'm in a windowed remote-desktop session:

• ALT+PgDn / ALT+PgUp - cycle through programs (ala ALT-TAB)
• ALT+Home - display start menu (ala CTRL-ESC)

My fingers still do the regular ALT-TAB / CTRL-ESC the first time round, but after a while I remember to use the alternate shortcuts.

Thanks to Mark Wagner.

Adam from Xero and I went to look at the Eee PC at Dick Smith's today. Quite a cute little PC that has no spinning hard drive, no fans and only weighs 900 grams.

Looks like a nice little email / web PC, but the screen is a little tiny for my liking. The install of Linux is quite smooth, and Firefox is integrated nicely onto the desktop.

Quite good for $600NZ though!

Kirk

I've been looking forward to the CTP of PowerShell 2 for a while, and it's finally here.

I'm looking forward to installing it on a VM tonight (don't install it on your production / main desktop system just yet).

The stand-out features from the two blog posts (The Community Technology Preview (CTP) of Windows PowerShell 2.0, What's New in CTP of PowerShell 2.0) are:

PowerShell Remoting

"Windows PowerShell 2.0 provides support for executing Cmdlets and Scripts remotely. PowerShell Remoting allows managing a collection of remote machines from a single client. Managing remote computers using PowerShell 2.0, requires that PowerShell 2.0 be installed on all the computers taking part in the operation; that is the client computer and the computer(s) being managed."

This solves a problem that a lot of sysadmins have - being able to nicely administer many machines in their farm / network using PowerShell.

Background Jobs

"Windows PowerShell 2.0 introduces the concept of a background job (PsJob).  A PsJob runs a command or expression asynchronously and "in the background" without interacting with the console. The command prompt returns immediately and you can query for the job results at your convenience.  You can run background jobs on a local or remote computer."

Hurrah! I was surprised how much I missed this unix feature, so it's good to see background jobs make an appearance. I'll be interested to see if they have changed the threading model within PowerShell.

Graphical PowerShell

"This release includes a very early alpha version of the new graphical shell..."

Definitely something that people want, although others have filled the void quite well up until now. Looking forward to playing with this.

Well done PowerShell team!

Kirk

No, not PowerShell.
I have been having fun measuring how much electricity our house uses, and which appliances are the worst offenders (Oil column heaters = bad, heat pump = good).
The tool I have been using is a Centameter, which is a clever little gadget that you clip onto your mains feed into your house (www.centameter.co.nz). You can also get one for a single power point from Jaycar.
A good idea if you want to reduce the impact your consumption has on the world (and your wallet!)

Kirk

James Newkirk and Brad Wilson have cooked up a new testing framework for .NET development: xUnit.net.

In his blog post announcing xUnit.net, James outlined the reasons why they have created a new framework -- primarily to bake best practice techniques into the test framework, and leverage some of the newer .NET features.

The Comparison between Nunit, MSTest and xUnit.net page on the site lists some of the differences between xUnit.net and Nunit / MSTest. Removing setup and teardown, and providing aspect-like functionality are both interesting angles which I want to spend some time with.

Here's a couple of examples from the samples download. First, an example of usage of BeforeAfterTestAttributes, which let you add behaviour before and after the execution of a test (ala AOP):

[Test, TracingSplicer]
public void TestThis()
{
}

...

public class TracingSplicerAttribute : BeforeAfterTestAttribute
{
    public override void Before(MethodInfo methodUnderTest)
    {
        Console.WriteLine("Before : {0}.{1}",
            methodUnderTest.DeclaringType.FullName, methodUnderTest.Name);
    }

    public override void After(MethodInfo methodUnderTest)
    {
        Console.WriteLine("After : {0}.{1}",
            methodUnderTest.DeclaringType.FullName, methodUnderTest.Name);
    }
}


Here's an example of test method extensibility:

[RepeatTest(5, Timeout=500)]
public void RepeatingTestMethod()

You can create your own attributes that inherit from the TestAttribute base class, and define what will happen when the test runs (in this example, the test will run 5 times).


Good work guys, looks useful!

Kirk

If you've been a Perl programmer, you've probably used File::Temp occasionally, to generate unique filenames for temporary files and clean up afterwards. In other lanuages you may have used a variation of the standard POSIX tmpnam or tmpfile.

In PowerShell, you'll often need to generate temporary files, especially if you're working with import-csv or import-clixml -- as they don't support data on the pipeline.

There's not (yet) anything I could find that is quite as nice as File::Temp, but if you want to generate a unique filename or directory name, or create a temp file on disk ready to be used, you can use these methods on System.IO.Path:

System.IO.Path.GetRandomFileName() [msdn]
Returns a random folder name or file name. The filename generated is cryptographically secure, meaning that no malicious script should be able to guess what filename you've just been given.

To use from PowerShell:
53> $filename = [System.IO.Path]::GetRandomFileName()
54> $filename
lbhrurye.uhp
55> Get-ChildItem > $filename

System.IO.Path.GetTempFileName() [msdn]
This method will actually create a temporary file on disk, in your temp directory (returned by System.IO.Path.GetTempPath). The file is 0 bytes, and ready for you to clobber with your own content. You can be sure that no other process has generated the same filename, but it's not exactly a secret what filename you've got -- you should use the GetRandomFileName method if you need a bit of security.

To use from PowerShell:
59> $filename = [System.IO.Path]::GetTempFileName()
60> get-childitem | export-csv $filename

The other thing to remember with GetTempFileName is that you need to remember to delete the temp file after you're finished (something that File::Temp does quite nicely for Perl'ers). Some day I might write a wrapper that deletes the file when the variable goes out of scope.

Darryl Burling has been posting a series on starting and running a user group for the new site mscommunities.net.nz. He asked me to write a post on "Speakers, topics, costs, refreshments", which he has now posted:

"Continuity, speakers and good running"

The most interesting part for me was adding up how many user group events we have had in Wellington (about 45), and how many pizzas I have ordered (approx 800!). If anyone from Pizza Hut or Dominos is reading this, they should get in touch with a discount offer!

Details of all our previous meetings are available on the Wellington .NET user group site, and on the old website.

As I posted earlier, this week Andrew Tokeley is presenting Dynamic Data Controls - come along.