Microsoft is really taking major strides in terms of improving the programming experience for developers on all current and future computing platforms.  That’s why, earlier today, Microsoft released a beta of the new “System.QuantumEntanglement” library.  This library, being considered for integration with .Net 4.1 (which, my sources say, is codenamed “Looflirpa”), provides features for developers working on quantum computers.  I won’t go in to too much detail, but this essentially means working in an environment where objects can be in many different states (possibly an infinite number) and where observation may change the state of an object.  Microsoft has proposed a few options, but I have some additional ideas.

Microsoft’s Proposal

Eilon Lipton, of the ASP.Net MVC team, is proposing a number of new additions to the .Net BCL in 4.1.  The first, is a class called “StringOr<T>” which has the following API:

namespace System.QuantumEntanglement {
    public class StringOr<TOther> {
        public StringOr(string stringValue, TOther otherValue);

        public string StringValue { get; }
        public TOther OtherValue { get; }
    }
}

This class is used to encapsulate a value which may be a string, but may be another value.  This is a common user-input scenario, since almost all user input arrives as strings, but will usually be converted to another data type.  He also proposes a more general class called “SchrodingOr<TDead, TAlive>”

namespace System.QuantumEntanglement {
    public class SchrodingOr<TDead, TAlive> {
        public SchrodingOr(TDead dead, TAlive alive);

        public TAlive Alive { get; }
        public TDead Dead { get; }
    }
}

This generalizes StringOr<T> to support any two types. 

Eilon’s not the only one talking about this, Scott Hanselman (well known Microsoft blogger), and Rob Conery (Author of the .Net Object-Relational Mapper: SubSonic) have also posted on this topic.  So I figured I’d add my comments to the blogosphere.

StringOr and SchrodingOr are great starts, but what if we need to represent objects which may be in 2 states? What about 3 states? Infinite states?  That’s where my proposals come in.  I propose the following additions to Eilon’s library:

Generalizing SchrodingOr

The first is SchrodingOr<T1, T2, T3, T4, T5, … , Tn> (for infinite n).  This allows the developer to represent objects in as many states as they want. 

C# 5.0 Compiler Support

I’m also proposing the following language syntax to help developers work with these types.  Similar to the way the C# compiler converts “int?” to “Nullable<int>” (which would now be replaced with “SchrodingOr<int, Void>” as it more accurately represents the concept of a type which may or may not have a value), the new syntax takes the following:

int?string?bool?DateTime? foo = GetUserInput(...);

And produces output code which looks like this:

SchrodingOr<int, DateTime, bool, string> foo = GetUserInput(...);

Then, we can defer observation until a later time, using the AsA<T>/AsAn<T> method (since Eilon's Alive and Dead properties no longer work in an infinite state environment). If we just want to observe the type and then make a decision, we can use IsA<T>/IsAn<T> methods (of course, both are required, just in case the type starts with a vowel), which returns a boolean indicating if the object is of the type T. For example:

if(foo.IsA<string>()) { return foo.AsA<string;>; }

Probabilistic Observation

Sometimes, we may want to observe an object only if there is a high probability of it being in the right state, to avoid additional quantum variations. To do this, we can use the CouldBeA<T>/CouldBeA<T> methods. These can, optionally, accept a probability threshold beyond which a object is considered in the right state.

Quantum Snapshots

Unfortunately, in between a call to IsA/An/CouldBeA/An and AsA/An, the state of the object may change.  So, we may wish to observe an object and record the state of the object at the time of observation.  Since in observing the object we may change its state, our observations must be recorded in “Snapshots”.  The snapshot is an instance of QuantumSnapshotOf<TSchrodingOr> (where TSchrodingOr must be one of the SchrodingOr<T1, ..., Tn> types), and has a property "Taken", which is a DateTimeOffset (after all, we need precise timing here) containing the exact time that the snapshot was taken.

Here’s an example combining Probabilistic Observation and Snapshots:

if(foo.CouldBeA<string>()) {
	QuantumSnapshotOf<SchrodingOr<int, string>> snapshot = foo.Observe();
	if(snapshot.Taken.Day == 1 && snapshot.Taken.Month == 4) {
		throw new UnreliableObservationException(snapshot, "The data is unreliable");
	}
	return snapshot.AsA<string>();
}

Summary

I think this is really interesting, forward-thinking, stuff from Microsoft. Eilon has done some fantastic work getting the ball rolling, and its up to us to give our feedback! Microsoft has created a section on MSDN for discussion on these new features: http://msdn.microsoft.com/en-US/QuantumEntanglement/Default.aspx

Did you know that the largest open-source project on the Microsoft platform was started in Vancouver, Canada?  It’s true!  DotNetNuke is the largest Open-Source community in the .Net by downloads (at least).  Since moving to CodePlex (Microsoft’s Open-Source hosting platform) in January 2009, DNN has been downloaded over 180,000 times (at time of writing).  This makes it second only to a World Of Warcraft Add-On development studio which has been on CodePlex since Sept 2007 (at least that was the earliest check-in I could find).  Adding that to the all-time download score on SourceForge (the project’s previous host) of 4.3 Million downloads, and you’ve got the the largest .Net open-source project (and one which I am proud to contribute to)!

And here’s the great part for us Canucks, DotNetNuke was created right here (by “here”, I mean where I live :P) in Vancouver!

Microsoft Canada is running a contest called the “Ignite It” award to honour Canadian developers and IT professionals.  DotNetNuke is nominated in the Developer category, and we’re looking for your votes!  There’s only 2 days left, and we’re in the top 5 (which will go on to be judged).  Still, we’d like to be up at number one before voting ends, so here comes the shameless plug :P.  Here’s the deal: You can vote once per Windows Live account per day (though there aren’t many days left :( ).  It only takes a second to vote, and I’ve even created a TinyURL to share with your friends: http://tinyurl.com/dnnigniteit

Let’s push DNN into the top spot!

Back in January, I started blogging more frequently due to a course I was taking.  As part of that, I started using Windows Live Writer to write all my blog posts.  I use the DasBlog engine to power my blog, and it supports one of the many blogging APIs that Windows Live Writer uses (I believe it’s MetaWeblog).  So, I hooked it up to my blog, and everything just worked!

My favorite feature is the ability to create and save drafts and then publish them on demand.  I have inspiration at the strangest times, and often in large batches, so I end up with a couple ideas of things to blog in a day, and no ideas the next day.  So, I just create a bunch of drafts, get them ready to publish and then publish them over a longer period of time (like say… a day :P).  For example, I wrote this post 5 minutes after the previous post, but I thought it might overload my readers to post it immediately :).  So, I save a draft and post it a bit later (when I don’t have anything to blog about :D).

If you have a blog, and it supports one of the blogging APIs, and you’re running on Windows, you really should try Windows Live Writer!

Microsoft’s MIX Web Development conference was held in Las Vegas last week and while I would have loved to go, the cost and scheduling just made it impossible :(.  Despite that, I’ve been spending the past few days “attending” MIX virtually!  Microsoft posts high quality WMV versions of the talks on the MIX website, perfect for catching up on the sessions.  With my Media Center PC hooked up through my Xbox 360, I can browse through my rapidly growing collection of talks and watch them at my leisure.  It’s almost like being there!  A couple of my recommendations are below:

• Day One Keynote – I haven’t had a chance to watch this yet, but it already has two things going for it.  Bill Buxton talking about User Experiences and a live DotNetNuke installation using the Microsoft Web Platform Installer 2.0 Beta.
• ASP.Net MVC: America’s Next Top Model View Controller Framework – I love ASP.Net MVC, and this is a great intro.  Of course, I may be biased since I worked on the team last summer. BTW, version 1.0 was released last Wednesday, and a large chunk of the AJAX stuff is my code (my code is actually in a released Microsoft product! w00t!)
• Microsoft ASP.NET Model View Controller (MVC): Ninja on Fire Black Belt Tips – If the previous talk was MVC 101, this is MVC 201 :P.  Though I have to be honest, I haven’t actually watched this one yet.  I’m sure its chock full of useful MVC tricks though!
• File|New -> Company: Creating NerdDinner.com with Microsoft ASP.NET Model View Controller (MVC) – I know, yet another MVC talk, but if you’re more of a “get to the code” type of programmer, this may be your style.  Plus, Scott Hanselman is an excellent presenter.
• How'd they do it? Real App. Real Code. Two Weeks. Nothing but .NET – Another Scott Hanselman talk, this one only 20mins long.  You hear people talk about “Rapid Application Development” but in this talk Scott shows off a concrete example of a 2 week project that forms part of the Adidas Motorsports portal.
• Building Out of Browser Experiences with Microsoft Silverlight 3 – This is another one I haven’t actually watched yet but intrigued me.  With Silverlight 3, Microsoft is positioning itself to take on both Adobe Flash and AIR.

That’s by no means a complete list of great talks, just my first impressions based on the first few I’ve watched and the abstracts that interested me on the list.  Feel free to post your own favourites in the comments!

Having spent 5 years taking courses in the Computing Science department at Simon Fraser University, I’ve become pretty familiar with the various web applications used to track course projects, submit assignments, etc.  Over the same five years, I’ve seen numerous technological changes, both in the “outside world” and within the University.  For example, not too long ago, SFU switched to a central authentication service aptly named “Central Authentication Service” (or CAS).  It’s a pretty nice service, with a snazzy login screen (below).

It’s not only snazzy, but a pretty useful system.  I even integrated one of my school projects (an online grade tracking application) with it without any external support.  Let’s contrast that with the current login screen for “Gradebook”, an application developed by the CS department and used in most CS courses to track grades

Ok, not as snazzy, but here’s the really frustrating thing:  My account here is NOT the same as my SFU computing account!

The “Gradebook” system also includes an electronic assignment submission server

(BTW: This is only a small snapshot of the page)

Sure, it isn’t snazzy looking, but it’s simple and to the point (+10 points).  However, it comes with a few caveats: I have to use my “Gradebook” account, not my (so-called) “universal” SFU account (-25 points), and ALL submissions must be in ZIP, GZIP or RAR format (-25 points)!  For many of my courses, the electronic submission has been a single file, and the instructor often has to email the students to remind them that they have to wrap their single PDF file (or Word Doc, etc.) in a ZIP file to upload it.  I can understand the benefits as far as storage space, and bandwidth consumption, but wouldn’t that be better achieved by simply placing a size restriction and allowing any file to be uploaded?  Plus, when I do login, I get a page with a drop-down list of courses.  Here’s the contents:

See that scrollbar?  Yeah… I’m not registered in anywhere near that many courses (the one course I’m registered in is a few scrolls away), but it would appear the submission server doesn’t know that.

It doesn’t end with the student interface.  In a course on “Web Information Systems,” we were required to develop a web-based application of some sort, and my group chose to build a grade tracking system (partly out of frustration with the current system).  Before starting the project, we organized a meeting with our instructor to find out what his frustrations were with the existing “Gradebook” system used by the department.  He mentioned that instructors had to rebuild the structure of assignments, exams and their relative contributions to the final grade every time they created a course.  He continued to show us a tool he developed which allowed him to create more detailed marks, give comments, and build an email to send off to the student.  He had to build a custom tool to perform tasks which I would consider essential to a modern grade tracking system.  In a few weeks, we hammered out a “school project quality” system running on Ruby on Rails (ASP.Net MVC wasn’t out yet :P) which supported all the features we discussed in our meeting with the prof.

Granted, I know it’s not as simple to fix as it is to complain.  But, with the tools out there, and the number of open-source and commercial courseware products, I still don’t really understand why we’re using a system with so many annoying issues…

For the CS students (or recent grads) who read my blog, is my experience atypical?  Or are your school services as out of date as these?

My laptop is rapidly becoming obsolete, particularly when it comes to disk space :(.  I want to install my games on it, so I have something to do in class between classes, but I’m running out space.  So, I came up with an idea: Buy a 16GB USB Key, and put a bunch of games on that!  I keep my USB keys in my backpack, so they’re never too far away.  It sounded like the perfect solution, until I noticed that many programs can’t be installed on Removable Drives!

So, I came up with a simple workaround, once again using an awesome tool from Sysinternals :).  I used Junction to create a junction folder called “C:\Program Files\Games” which points to a “Games” folder on my USB Key.  The following command line does the trick (assuming F:\Games is the folder on the USB key, and it already exists):

junction.exe “C:\Program Files\Games” “F:\Games”

Seems to be working so far!  I just install the game into that folder, and all the files go to the USB Key.  Of course, its not quite the same as a portable app, since it will only run on the machine it was installed on, but it takes some of the burden off of my hard drive.  If my laptop supported SDHC, I’d probably use a 16GB SD card and just leave it plugged in to my laptop, but unfortunately, that’s not an option.

There’s been a lot of buzz around the Internet about Quake Live.  I decided to succumb to the hype and try it out and I must say it is pretty cool.  However, a lot of people have heralded this as a unique new way of distributing games, and I have to disagree with that.  Quake Live is no different than any other downloadable game, it just happens to use the browser as a host.  When you go to http://www.quakelive.com for the first time, you log in and wait in a queue.  When you reach the front of the queue, you are prompted to download a plugin (in the form of a Windows Installer MSI file) for your browser.  If the queuing thing sounds very FilePlanet-esque to you, it certainly does to me.  Then you download the game plugin installer and run it (as an Admin).  When it finishes, you have to restart your browser and go back to the website.  After waiting in the queue some more, the game loads up and runs in the browser.

How is this process different from installing a regular desktop game?  You download the installer, run it as Admin, and then start the game.  The only different here is that the game code is running in-process (AFAIK) with the web browser.  It really isn’t that different!  Developing a game like this using an existing plugin like Flash or Silverlight (especially since Silverlight 3 is supposed to include 3D Acceleration support) would be, IMHO, much more innovative.

About the only thing in Quake Live that differs from a regular desktop game is the use of a streaming installer, which downloads a (relatively) small bootstrapper and then downloads the rest as you play a 10minute training level.  Even that isn’t really unique, as Scott Hanselmanpoints out, Guild Wars has included that feature for a while.

11:00AM – I look in my backpack to check that the Project Proposal that is due at my PHYS 192 class at 11:30 is still in there

11:01AM – I realize it isn’t there, I left it at home

11:02AM – I decide to just reprint it on campus, and relax

11:05AM – I fire up Word and open up the Print Dialog

11:06AM – I discover that the campus print server isn’t in my printers list

11:08AM – I locate the campus printing instructions and start setting up the printer

11:10AM – I discover that the printer driver I need isn’t included in Windows

11:12AM – I locate the printer driver online and start downloading it

11:15AM – Printer driver installed, I configure the campus printer

11:17AM – Still reasonably calm, I fire up Word again and send my document to the print queue.

11:20AM – After packing up my machine, I walk over to the printing station in the Laptop Lab

11:21AM – I discover a “Out of Order – Sorry for the inconvenience” sign :(

11:25AM – I walk to the other side of the building to another lab and put my printer card in the reader

11:26AM – Spending the last $0.11 on my card, I print my document

11:27AM – Calmly, I grab the printed document and see the following text:

Error: PCL Protocol Error

11:28AM – Scramble to a PC in the computer lab and log in to the machine

11:30AM – Machine finally logs in, and I fire up Internet Explorer, navigating to my Live Mesh Desktop

11:31AM – Open up the document from Live Mesh and print it

11:33AM – Go back to the printer station, and discover that my printer card is empty!

11:34AM – Walk to the nearby printer card top-up machine and see: “Out of Order – Sorry for the inconvenience”

11:35AM – After discovering I had no cash, walk to the nearby ATM and withdraw some

11:37AM – Head to the nearest cafeteria and buy a bottle of water, getting a twoonie ($2 coin, for my non-Canadian readers) in change :)

11:37AM – Head off to the library on the other side of campus (where the only other printer card top-up machine is… AFAIK)

11:40AM – Reach the library and stick my card in the machine, pop my twoonie in the slot and top-up my card

11:41AM – Go over to the library printer and release the printer job

11:42AM – Pick up the paper and dash over to the lecture hall with my printed proposal in hand

11:45AM – Arrive, late, and take the only remaining seat… at the front of the class, right next to the pile of proposals from the other students

11:46AM – Drop my proposal on the pile and sigh in relief

Seriously… need a way better campus printing system.  Only two top-up machines on campus?  Why can’t I just add funds to my student account online and submit PDFs and DOCs to be printed if I don’t want the hassle of configuring the print server?

Arg…

Here’s part 4 of my infinite part series on developing a compiler from scratch.  See all the posts here.

I’ve decided to change things up a bit on the compiler project.  Instead of writing the tokenizer and parser from scratch, I’m going to check out a new language that’s part of Microsoft’s “Oslo” Project.  Oslo includes a language called M, which is primarily designed for developing data models.  M is actually three languages, MGraph, MSchema and MGrammar.  MGraph is a language for defining abstract graphs, for example:

Universities {
    Canada {
        BritishColumbia {
            SFU { 
                Name { "Simon Fraser University" }, 
                Location { "Burnaby, BC" } 
            },
            UBC { 
                Name { "University of British Columbia" }, 
                Location { "Vancouver, BC" } 
            }
        }
    }
}

MSchema is a language for defining the schema for these graphs, for example

module Universities {
    type University {
        Name : Text#100,
        Location : Text#100
    }
}

Finally, MGrammar is a language for defining custom Domain-Specific Languages (DSLs) which map to MGraph graphs. This is the language that is most useful to this project. After all, a general-purpose programming language is just a DSL where the "Domain" is very broad :). So, I've spent a few hours this week whipping up an MGrammar grammar for Duh, and the results are promising.  I’ll be posting some details on that in the next post, but first we need to explore a key concept in compilers, Abstract Syntax Trees.

The end goal of the tokenization and parsing phases of a compiler is to produce an Abstract Syntax Tree (or AST) representing the source code.  This is probably best illustrated by an example, so consider this expression:

5+6

This is an addition operation, using 5 and 6 as the arguments, which we represent in an AST like this (using the MGraph syntax above):

Add { 5, 6 }

Similarly, more complex expressions can be translated to trees:

5+6*(3+4)

Becomes:

Add { 5, Multiply { 6, Add { 3, 4 } } }

Which represents the following instructions:

• Add 3 and 4
• Multiply that result by 6
• Add 5 to that result

Essentially, we are building up the expression from the bottom of the tree up.  This makes it much easier to convert the expression into code.

I’ll post the MGrammar file for the language when I finish it up in a day or so, then its on to writing the code to do the parsing.

UPDATE 2: PowerKits requires PowerShell 2.0.  If you’re seeing errors regarding the “try-catch” keywords, its because those keywords were added in PowerShell 2.0 and I use them in PowerKits.  Sorry!

UPDATE: It turns out PowerShell 2.0 already contains a feature like this: “Modules.”  See here for more info.  Since it seems to be far superior to PowerKit (which I just hacked together for my own needs), I guess that just leaves this as an interesting exercise :).

I’ve been a huge fan of Windows PowerShell since it first came out as “Monad” (aka “MSH”).  Now that its entering version 2.0, which will be built-in to Windows 7 and Windows Server 2008, I’m getting even more into it.  I’ve written a Podcast Receiver (PowerCast) and an automated process for converting videos for use on my Xbox 360 (PowerCode).

[The following paragraph is a short intro to PowerShell, feel free to skip it if you’re familiar with PoSH]

What is PowerShell?  PowerShell is an object-oriented shell which, IMHO, kicks the pants off of BASH and Perl.  PowerShell is a dynamically-typed scripting language written on the .Net Framework, which gives you full access to every class, method, and property in the framework.  You could write a GUI, Server, heck even a 3D Game in PowerShell (it just might not perform as well as another language).  PowerShell is also an interactive “Read-Eval-Print” loop application which gives you a prompt into which you type commands which are then evaluated and their results printed to the screen (i.e. a standard “Shell” similar to cmd.exe or BASH).  Finally, PowerShell is an embeddable scripting environment which lets any .Net-based application embed the PowerShell scripting language.  However, most people (myself included) are referring to the Shell itself when they talk about PowerShell

Anyway, on to the main purpose of this post.  I started to get frustrated with trying to manage all my scripts and keep them organized.  I was also downloading a lot of useful scripts off of the web, but had to manually place them somewhere in my file-system (let alone managing all the dependencies).  Other scripting environments, such as Ruby, have packaging systems, such as RubyGems, to manage libraries of functionality and publish them for others to download.  So, I thought, why doesn’t PowerShell have something like this?

Thus, PowerKits were born.  The concept is simple.  A PowerKit is a directory on your file-system which contains a manifest file “Kit.xml”.  This file specifies some information such as the paths to various script files, aliases to create, .Net assemblies to load and (in a future version) PowerShell “snap-ins” to load.  After installing a kit (by placing it in one of many, configurable, pre-defined folders), it can simply be enabled using a single PowerShell Command.  For example, to enable the “MyCompany.MyKit” PowerKit:

Enable-Kit MyCompany.MyKit

Enabling a kit loads all the assemblies, script files, etc. into your PowerShell environment, making them available for use.  A Kit can then be disabled similarly using the ”Disable-Kit” command.  Disabling the kit removes all the script files, etc. from the environment (NOTE: .Net assemblies cannot be unloaded without restarting PowerShell, due to a limitation of the .Net Framework).

PowerKit also supports packaging kits into a ZIP-like format, specifically the Open Packaging Convention developed by Microsoft for Office 2007 (since the .Net framework has built-in support for that format). These “Kit Archives” can be downloaded and installed using a single command.  Eventually, I plan to add support for installing a kit directly from the web, so you could use a command like this:

Install-Kit http://www.mycompany.com/MyCompany.MyKit.kit

Or even this:

Install-Kit MyCompany.MyKit

And the framework would go out and download the kit and install it, giving PowerShell a true “gems-esque” packaging system.

To install PowerKit, download the Install-PowerKit.ps1 script from the CodePlex site, more installation details are in the release notes on that page.

I recently used the ‘yield’ keyword in a C# method and ran into a strange issue when trying to verify arguments.  I always try to verify the arguments provided to my methods so that I can throw ArgumentException or ArgumentNullException as necessary.  However, when you use the ‘yield’ keyword to create an enumerator in C#, you can run into issues

The ‘yield’ keyword lets you easily create a method which returns an enumerator (which can then be used in a foreach loop).  For example, if I wanted to make a method that took a DirectoryInfo (representing a directory on disk) and returned file names of all the .txt files in it, I would write this:

public IEnumerable<string> GetTextFiles(DirectoryInfo dir) {
    if (dir == null) {
        throw new ArgumentNullException("dir");
    }
    foreach (FileInfo file in dir.GetFiles("*.txt")) {
        yield return file.Name;
    }
}

However, the C# compiler will do something tricky with this method, because of the 'yield' keyword.  It will create a custom implementation of IEnumerable<string> class that uses "magic" (I'm not going to go into detail as to how it works :P) to jump in and out of the code you wrote. Then, it compiles our method to the following (as decompiled with RedGate's .Net Reflector, a free tool every .Net developer must have :D):

public IEnumerable<string> GetTextFiles(DirectoryInfo dir)
{
    <GetTextFiles>d__0 d__ = new <GetTextFiles<d__0(-2);
    d__.<>4__this = this;
    d__.<>3__dir = dir;
    return d__;
}

Wait a sec, where'd our code go?  It looks like it’s gone into this <GetTextFiles>d__0 class.  If you think that name sounds compiler-generated, you’re right!  It’s the custom implementation of IEnumerable<string> that was created by the compiler.  Cool, eh?  However, there’s a side effect here.  Where did our argument checking code go?  Unless there’s something in the <GetTextFiles>d__0 constructor, the user could pass null in for the dir parameter and no exception would be thrown!  So, let’s take a look at the <GetTextFiles>d__0 constructor (using Reflector again):

[DebuggerHidden]
public <GetTextFiles>d__0(int <>1__state)
{
    this.<>1__state = <>1__state;
    this.<>l__initialThreadId = Thread.CurrentThread.ManagedThreadId;
}

Nope, nothing there.  If you keep checking around the <GetTextFiles>d__0 class, you’ll find it in the MoveNext method on that class.  That means that instead of checking the argument when you call the method, the argument won’t be checked until the first time MoveNext is called (i.e. the first iteration of a foreach loop).  If, instead, we wrap the actual “yield” code in it’s own method, and call it from our original method (after argument checks), we’ll get the desired result:

public IEnumerable<string> GetTextFiles(DirectoryInfo dir) {
    if (dir == null) {
        throw new ArgumentNullException("dir");
    }
    return InternalGetTextFiles(dir);
}
private IEnumerable<string> InternalGetTextFiles(DirectoryInfor dir) {
    foreach (FileInfo file in dir.GetFiles("*.txt")) {
        yield return file.Name;
    }
}

Now, the "magic" is occurring in InternalGetTextFiles and GetTextFiles is compiled without modification and our argument checking works just fine.

One of the most common checks I do is a simple null check on arguments being passed in to the methods I write.  I usually create a static class called “Arg” with the following methods (to help out):

public static class Arg {
    public static void NotNull(object value, string paramName) {
        if (value == null) {
            throw new ArgumentNullException(paramName);
        }
    }
    public static void NotNullOrEmpty(string value, string paramName) {
        if (String.IsNullOrEmpty(value)) {
            // ED: Error_StringArgumentNullOrEmpty is a key in my Visual Studio
            //  project's default string resources file (Properties/Resources.resx)
            throw new ArgumentException(
                String.Format(CultureInfo.CurrentCulture, 
                              Resources.Error_StringArgumentNullOrEmpty, 
                              paramName), 
                paramName);
        }
    }
}

Then, I can use it like this

public void Foo(string arg, object reallyLongArgumentName) {
    Arg.NotNullOrEmpty(arg, "arg");
    Arg.NotNull(reallyLongArgumentName, "reallyLongArgumentName");
}

I was recently playing with lambda expressions in C# and thought of a way to make this a little cooler.  The result is, I can rewrite the lines above like this:

public void Foo(string arg, object reallyLongArgumentName) {
    Arg.NotNullOrEmpty(() => arg);
    Arg.NotNull(() => reallyLongArgumentName);
}

The first obvious advantage is that for longer argument names, its more concise.  The second, is that I no longer have to worry about updating the strings representing the parameter names when I rename arguments, the Visual Studio Refactoring engine will take care of it for me.

Obviously, this is slower than the previous method since I’m diving into the lambda expression at runtime, but its cool.  But if I need the performance, I have a little Regular Expression I can run in Visual Studio to convert the lambda calls back to the string versions (and vice-versa)

How does it work? Well, the core of the code is a static helper in the Arg class

private static string GetParameterName<T>(Expression<Func<T>> paramExpr) {
    LambdaExpression lambda = paramExpr as LambdaExpression;
    Debug.Assert(lambda != null);
    MemberExpression paramRef = lambda.Body as MemberExpression;
    Debug.Assert(paramRef != null);

    // Get the parameter name
    string paramName = paramRef.Member.Name;
    return paramName;
}

Lines 2-5 dive through the Expression tree to find the MemberExpression that represents the parameter (i.e. "foo" in () => foo). Then, we pull out the MemberInfo for the parameter and check the name. With that method, the actual checker is easy:

public static void NotNull(Expression<Func<object>> paramExpr) {
    string paramName = GetParameterName(paramExpr);

    // Compile the lambda (to get the value)
    Func<object> compiledLambda = paramExpr.Compile();
    
    // Run the contract check
    NotNull(compiledLambda(), paramName);
}

Line 2 extracts the parameter name. Line 5 compiles the lambda into an actual function that will return the value of the parameter. Finally, Line 8 uses the value and the parameter name to call my original object/string version. The code for NotNullOrEmpty is nearly identical.

Anyway, if you're concerned about performance, stick to the overloads which take the parameter name directly. I’ve attached the code as a TXT file, just rename to C#, change the namespace as appropriate and enjoy

Here comes part 3 of my infinite part series on developing a compiler from scratch.  See all the posts here.

The first phase of compilation is called Tokenization.  Tokenization is the process of taking individual characters in the source code file and grouping them into more conceptual “Tokens.”  We’re not parsing the language, or checking syntax, we’re just grouping related characters together.  Why do we do this?  If we skipped this step, we’d be passing characters directly to our parser.  The parser doesn’t care that the text contains the characters ‘f’ ‘o’ ‘o’, it cares that the source file contains an Identifier called “foo”.  There’s also a separation of concerns issue.  In theory, if you wanted to allow accented Unicode characters like è, ê, ã, à, etc. (you may see blocks or ‘?’ characters instead of the real characters, if so just pretend they’re there :D) as valid characters in identifiers, you should only have to change the Tokenizer (to accept those characters and use them, along with the regular alphanumeric characters, to build identifier tokens).  The formal name for Tokenization is actually “Lexical Analysis,” and sometimes the Tokens are called “Atoms.”

So, how do we Tokenize text?  There are lots of tools out there, most of which let you define your tokens using Regular Expressions (so an identifier would be: “[_A-Za-z][_0-9A-Za-z]*”, one letter or underscore followed by zero or more letters, numbers or underscores).  These tools build state machines (aka “Finite Automata”) that basically walk through all the Regular Expressions until exactly one of them matches the current text buffer.  Tools like “lex” basically allow you to build a full-featured, efficient, Tokenizer by simply writing Regular Expressions.

However, that would be too easy for this series :).  Instead, I’m using a very simple, hand-coded, Tokenizer which walks through the characters, using “if” and “switch” statements to decide what tokens to output.  However, we can’t just simply iterate through the characters.  Consider the ”->” operator in Duh (see Part 1).  Duh supports the simple arithmetic operators, specifically “-“, and I plan to support inequality operators (i.e “<”, “>”, etc.), so in theory, the “->” operator could be outputted as a pair of tokens: MINUS and GREATERTHAN (I’ll use ALLCAPS to denote the names of tokens).  However, this would be putting a larger burden on the parser to detect the MINUS GREATERTHAN pattern.  Instead, we can take advantage of “lookahead”

The Tokenizer uses the .Net TextReader class, which lets us walk, one character at a time, through the characters in a body of text.  However, once we’ve called the Read method, the TextReader moves on to the next character and the next time we call it, we’ll get the next character.  So, in order to properly parse the “->” operator, we need a way to look at the next character, without moving the reader.  Fortunately, the TextReader also has the Peek method, which does exactly that.

So now, when we encounter a “-“ symbol, we look at the next character.  If it is a “>”, we output an ARROW token, and move to the next character.  Otherwise, we output a MINUS token and leave the reader at the “>” character.  Then, in the next iteration, we read the “>” and output a GREATERTHAN token.

Phew, that was a bit long, and more theoretical than I like, but I’ll post some code in the next part.  Next time, we’ll look at the actual code for the Tokenizer.

Phil Haack (program manager on the ASP.Net MVC team) just posted a blog post about the new Release Candidate of the MVC framework.  Since I got a chance to work on the MVC framework team as an intern this summer (and I’m going back full-time this summer), I’m pretty excited about the news.  When this goes RTM, it’ll be the first time code that I wrote will be part of a full shipping Microsoft product! 

So download the binaries from ASP.Net or check out the source code on CodePlex and have some fun!

Also, check out Scott Guthrie’s post on the new features.  He shows off one of the features that, I think, makes ASP.Net MVC more compelling than Ruby on Rails: Powerful first-party tooling support.

Well, this is a good sign, I’m posting part 2 :).  As I said in Part 1, there are no promises here.  This series may not go anywhere, I may have to drop it due to my other commitments (school, work, etc.).

In the next few posts, I’m going to talk about the Tokenization phase of the compiler.  Before I go into too much detail on that though, I want to talk about newlines.

In Windows, a new line in a text file is indicated by a pair of characters: A Carriage Return (commonly referred to as “\r'”, as that is the C/C++ string escape sequence for it) followed by a Line Feed (”\n”).  However, in Unix-based operating systems, a new line is often indicated by a Line Feed character alone.  To add even more confusion, the Mac OS uses a Carriage Return character alone. 

A compiler needs to track line numbers accurately, in order to report errors, so we need be extra careful around newlines.  We could simply use the current operating system’s default newline characters, but that makes it difficult for multi-platform development.  Instead, we’ll normalize the newlines so that all three different types are properly understood by our compiler.

To do this, I’ve written a “Decorator” class which inherits from the abstract TextReader class provided in the .Net framework.  This “Newline Normalizing” decorator wraps an existing TextReader and does all the work of normalizing new line characters  TextReader provides two methods that need to be implemented, Read and Peek.  Read returns the current character from the text and moves the reader one character forwards (so that the next call to Read will return the next character).  Peek also returns the current character from the text but does not move the reader forward.  The “Newline Normalizing” reader implements these two methods using the following code

public override int Peek() {
    // Get the next character
    int i = Adaptee.Peek();
    
    // If the character is a '\r' newline, just return '\n'.  
    // Unlike Read, we aren't going to read ahead to check for \r\n
    // because that will happen when the user calls Read()
    if (i == (int)'\r') {
        i =  (int)'\n';
    }

    return i;
}

public override int Read() {
    // Get the next character
    int i = Adaptee.Read();

    // If the character is a '\r' newline, we're going to normalize it to '\n'
    // However, if the newline is '\r\n', we need to return it as one character, so
    // we check ahead for that
    if (i == (int)'\r') {
        if (Adaptee.Peek() == (int)'\n') {
            Adaptee.Read(); // Skip the '\n'
        }
        i = (int)'\n';
    }

    return i;
}

Essentially, if the character we read from the source (the “Adaptee” as I call it) is a ‘\n’, we just pass it along.  If the character is a ‘\r’, we are going to return ‘\n’, but first we first check to see if it is immediately followed by a ‘\n’.  If it is, we skip the extra character.  The result is that no matter which newline sequence is used, this TextReader will return it as a single ‘\n’ character.

Next post, I’ll start talking about the Tokenization process.

EDIT: Whoops, wrote the wrong course number (CMPT 376), corrected below.  I’m taking CMPT 376, Writing for Computer Scientists, this semester, must have gotten myself mixed up :)

Ok, I’m going to try something here, and I don’t know if I’ll manage to finish it.  My all-time favorite class in my school career (so far) has been CMPT 379 – Compiler Design.  The class basically consisted of me writing a compiler in Visual C++, with weekly lectures and code reviews from the professor (it was a small class).  Since then, I’ve been trying to think of a reason to write a compiler (i.e. a language that can be ported to .Net, or a useful domain-specific language, etc.).  Then, this morning, as I walked back to the Computing Science common room from the Gym (after my morning workout), I found a reason.  I think compilers are some of the most interesting pieces of software, and I thought that if I wrote a series of blog posts in which I developed a compiler, maybe I could share that passion with others. 

So, here’s the plan:  I’ve designed an, extremely simple, language that I’m going to walk through writing a compiler for.  The initial version will target .Net IL code (since it’s a stack machine system, which is much easier to generate code for).  Once I’ve implemented the simple language, I think it’d be awesome if my readers could jump in and propose some ideas for new language features, and I’ll try to blog about implementing them.

To be honest, this project may well fall flat on its face.  Writing a compiler is not a simple task, no matter how simple the language.  However, I do think it will be fun (while it lasts), so let’s give it a try!

So, step one is: Define your language!  The most essential part of compiler design is having a very clear idea of the purpose of your language.  The language I’m going to design is called “Duh”, because it’s probably about as simple as it gets (maybe a little more complex than Brainf**k (NOTE: link target does include a few four-letter words :D)).  Here’s a sample Duh program

print "Enter your age: ";
ageInput : string;
age : int;
ageInput = readline;
age = ageInput -> int;
print "In 10 years you will be " + (age + 10) -> string + ". Wow, that's old"

Pretty simple, eh?  Line 1 is a simple print statement, which accepts a string and write it to the console.  Lines 2 and 3 declare variables of string and 32-bit integer types (decided to use a more Pascal-esque variable declaration format, just for fun).  Lines 4 and 5 assign values to those variables.  Line 4 uses another built-in function, readline, which reads a line of text from the console.  Note that we don’t even support initializing variables in the declaration!  That’s ok though, this is just a toy language, we can add initializations later.  Line 5 introduces the “->” conversion operator, which takes the value on the left and converts it to the type on the right.  It’s not quite the same as a cast, because it will try to convert the value, if it can.  Finally, we add 10 to the value the user entered and convert it to a string, then we place that string into a large message and print it to the console.

Well, here goes nothing!  Feel free to post your initial comments.  I hope you’ll follow along!  I’ll be posting full source code with every post

I just had my first Windows 7 Blue Screen of Death :(.  However, it was my own fault for trying to use an unsupported driver :P.  I had just listened to an episode of Security Now on a tool called Sandboxie.  Sandboxie is a tool which intercepts Windows API calls made by programs to read/write files and registry keys.  Once intercepted, Sandboxie redirects them to files and registry keys in a special “Sandbox”, so that changes made by programs are isolated from each other.  It’s a cool security solution, and very similar in spirit to Microsoft’s App-V platform (only cheaper, and aimed at consumers rather than enterprises :D).

In order to intercept the Windows API calls, however, Sandboxie has to install a kernel-mode driver and patch the kernel.  In 64-bit versions of Windows, a system called PatchGuard prevents this from happening, thus Sandboxie is not compatible with those operating systems.  However, my laptop is running a 32-bit version of Windows 7, so I decided to try it out.

At first, I got a compatibility message from the Sandboxie installer, telling me that my OS is not supported.  That should have been my first clue :).  I decided to take a gamble and try it out anyway, so I tweaked the compatibility settings for the installer so that it ran in “Windows Vista” compatibility mode.  The installer ran fine, and installed the software.  However, when I tried to run it, BAM, BSOD :(. 

Resigning myself to the fact that it just wasn’t ready for Windows 7, I booted up in Safe Mode.  However, I was unable to run the installer again to remove it.  I tried “Add/Remove Programs” and running the installer I downloaded again (in Vista compatibility mode).  Still nothing.  Fortunately, I was just about to restart for Windows Update when I installed Sandboxie, and Windows Update automatically creates a System Restore point before installing updates.  I fired up System Restore, picked the Windows Update restore point and let it do its thing.  The machine rebooted, and I was back in action, with Sandboxie (and my BSODs) gone.  I had lost the updates that WU installed, but that’s a minor inconvenience.

Anyway, all is well now, and I was able to boot up again (in order to write this post in fact :D).  So, two lessons here:

1. Use System Restore!  Just remember to make restore points before installing software that you are concerned about.  (Though that will NOT protect you from malicious software, just incompatible software)
2. Check out Sandboxie, just not on Windows 7 :(.  My theory is that the PatchGuard technology from the 64-bit OS may have been brought into the 32-bit OS.

So, as an MSDN subscriber (no, I’m not made of money, Microsoft Interns get a free year-long subscription to MSDN for personal use :P), I had access to the Windows 7 public beta a day early.  I decided to go crazy, since I’ve been hearing its really stable, and put the latest OS on both my laptop and my desktop.  (Well, I actually put Windows 7 Server, aka Windows Server 2008 R2 on my desktop).  So, I figured I’d post my first impressions.

Installation

There’s not much to say here, Installation is exactly like Windows Vista, only a little faster.  The only new feature is that Windows 7 Setup prompts you to create a HomeGroup, if you want.  HomeGroups are the new networking construct introduced in Windows 7 designed to make it easier to share files and devices between networked computers.  I haven’t had a change to check that out yet, so I’ll come back to it later.

Initial Impression

Besides a stylish new boot screen, in which four coloured dots dance around before combining to form the Windows logo, the boot process is also identical to Windows Vista.  I did find that it booted up much faster than Vista (though I can’t make an accurate comparison, since my laptop was getting a bit overloaded).  The new taskbar is very cool, and while it is a bit of a knock-off of the OSX Dock, I think Microsoft has (in typical Microsoft fashion) gone above and beyond the OSX experience.  For example, by hovering the mouse over an icon, a list of all the windows belonging to that application appears.  Even better, applications which directly support Windows 7 can add their own “windows” to this list.  For example, even though I only have one IE8 window open, each tab in that window appears as a separate item in the windows list.

By hovering over each thumbnail, that window is brought to focus on the screen, and the rest of the windows become “glass”.

(And yes, I did blank out my Windows Messenger buddies list :P).

Jump lists are another cool feature, but I haven’t had a chance to explore it much.  Essentially, when you right click, or click and drag up on one of these taskbar icons, a jump list appears.

In this case (Internet Explorer 8), my history is displayed.  Applications designed for Windows 7, get a lot of control over this list, but applications which are not designed to support it (PowerShell 2.0 for example) just get a simple default list

I haven’t had much of a chance to explore the rest of the new stuff, so I’ll post more later, but my initial impression is that Windows 7 is just plain awesome :).

One of the courses I took last semester (Fall 2008), was “Software Engineering II”.  In this class, we were required to work in groups to implement a project that the professor specified.  We had to go through the whole process, design, implementation, testing (though we could choose any software process model we wanted: Waterfall, XP, Agile, etc.).  Our group’s project was an application called “Mappr” that would allow users to browse a map.  Well, it was a little more than that, but that’s all the background required by this post, I’ll post more background in future posts.

One of the necessary components in mapping software is called a “Projection”.  The Earth is round, and Latitude and Longitude co-ordinates are spherical measurements representing points on the Earth.  In order to convert those co-ordinates to (x, y) co-ordinates for displaying on a (flat) computer screen, you must project the geographical co-ordinates into screen co-ordinates.  One well-known technique for doing this is called the Mercator Projection.

A quick aside: The Mercator Projection is widely known (in geography circles) for being highly inaccurate.  However, it is the projection used by most road maps, atlases, etc., both physical and digital.

In Mappr, projection is handled by a component called a “Projection Strategy”.  A Projection Strategy is a C# class (Mappr was written in C#) with two methods: GeoToScreen and ScreenToGeo.   Here are the signatures of those methods:

public interface IProjectionStrategy {
    Point GeoToScreen(Point geographicalPoint, int zoomLevel, int tileSize);
    Point ScreenToGeo(Point screenPoint, int zoomLevel, int tileSize);
}

The purpose of each method is straight forward: To take in either Geographical (Latitude, Longitude) co-ordinates or Screen (X, Y) co-ordinates, and convert them to the other.  In order to do this, we must know the Zoom Level, which is an integer N indicating that there are 2^N tiles on the screen.  We also need the size, in pixels, of each map tile image.  This means that the size of the map, in pixels, is given by: 2^zoomLevel * tileSize.

The code to project a geographical point on to the screen is shown below:

public Point GeoToScreen(Point geographicalPoint, int zoomLevel, int tileSize) {
    // Convert to normalized mercator
    double lon = geographicalPoint.X;
    double lat = geographicalPoint.Y;

    if (lon > 180) {
        lon -= 360;
    }

    lon /= 360;
    lon += 0.5;

    lat = 0.5 - ((Math.Log(Math.Tan((Math.PI / 4) + 
                 ((0.5 * Math.PI * lat) / 180))) / Math.PI) / 2.0);

    double scale = (1 << zoomLevel) * tileSize;
    return new Point(lon * scale, lat * scale);
}

This code first normalizes the longitude (X direction) so that it is in the range 0.0 to 1.0 (where 0.0 is the left of the map and 1.0 is the right).  Then it does what I like to call “mathy stuff” (the calculations are taken from similar code written in Java) with the latitude to put it in the same range (0.0 is the top, 1.0 is the bottom).  Finally, we calculate the scale of the map (height/width in pixels, since the map is technically a square) and then we can use the normalized longitude and latitude as ratios of that scale.

The ScreenToGeo method is similar, the code is below.  I won’t describe this, but just provide it for reference.

public Point ScreenToGeo(Point screenPoint, int zoomLevel, int tileSize) {
    int pixelSpan = (1 << zoomLevel) * tileSize;
    double lngWidth = 360.0 / pixelSpan; // width in degrees longitude
    double lng = -180 + (screenPoint.X * lngWidth); // left edge in degrees longitude

    double latHeightMerc = 1.0 / pixelSpan; // height in "normalized" mercator 0,0 top left
    double latMerc = screenPoint.Y * latHeightMerc; // top edge in "normalized" mercator 0,0 top left
    
    // convert top and bottom lat in mercator to degrees
    // note that in fact the coordinates go from about -85 to +85 not -90 to 90!
    double lat = (180 / Math.PI) * ((2 * Math.Atan(Math.Exp(Math.PI * (1 - (2 * latMerc)))))
                       - (Math.PI / 2));

    return new Point(lng, lat);
}

By the way, feel free to use any of the code in this post in your own application. Consider it "Public Domain". However, I would appreciate (but not require) if you would place a comment near it indicating that this blog is the source of the original code.

Hopefully this helps those of you writing mapping applications in C#!  Please post any questions or comments in the comments section!

The Spring semester at SFU is off to a running start (after a day lost to the snow), and I’ve already got some homework to do!  One of the classes I’m taking is a course titled “Writing for Computer Scientists”. The goal is to develop writing skills through practice. Lots and lots of practice :).

Each class (3 times a week), we’re required to submit some “writing”.  I use quotes simply to emphasize the freedom of this assignment.  All I have to do is write a single word, and turn it in each week.  Of course, that’s not really the point of the assignment ;).  One option, provided by the professor, is simply to start a blog (if you don’t already have one) and post 2-3 entries per week.  Given that I already have a blog which I have had trouble maintaining, I figure this is a good kick in the behind to get myself blogging again. 

So, I’ll hopefully be blogging more often (at least while my grades depend on it :D).  I’ll probably stick to the current subject of the blog: observations from an open-source developer on the Microsoft ASP.Net platform.  Just in case I start to wander to different topics, I’ll make sure to tag appropriately, so my normal readers can subscribe just to the posts they’re interested in.

It’s time to start blogging for fun and profit grades!