Boku is an application designed to introduce kids to computer programming. Using an entirely icon-based programming language, Boku lets your build your own game consisting of different elements that you can program to interact with each other.  It’s really hard to really describe just how cool this is in words so I encourage you to check out this video.

I may just be rationalizing my own biases, but I like to think that teaching kids to program isn’t just about producing the next generation of nerds, but actually teaches some useful life skills as well: critical thinking, problem solving, etc. And I love the idea of exposing kids to programming concepts in a form that they’re likely already familiar with: computer games. In fact I was having a conversation with one of my co-workers just the other day about how to get kids interested in engineering and this seems like an awesome tool for sparking that interest.

This reminds me a lot of something I played with awhile back called Scratch from the MIT Media Lab. I think the primary goal of Boku and Scratch is probably the same (i.e. create a kid-friendly programming environment), but Boku seems far more polished and sophisticated.

Scratch is available now (for free) while I think they said that Boku would be available early next year — I can’t wait to get my hands on it and start programming with my kids.

At the other end of the programming spectrum, I also attended Anders Hejlsberg’s session on the Future of C#. There was so much interest in this session that it was one of the few that was actually scheduled to run twice during the week. I’m not sure if people are really excited about C# or if they just wanted to see the father of C# in person — either way, it was a great session.

There’s lots of cool stuff coming in C# 4.0 like optional parameters and better COM interoperability but the thing that really “wowed” the crowd was the support for dynamically typed objects. Through the use of the new dynamic keyword you can ask C# to resolve names at runtime instead of compile time. This opens-up a bunch of very interesting scenarios like the one that Anders showed in his demo where he was able to invoke methods on both Javascript and Python objects from C# just as if they were native C# classes.

Apparently, this capability is being built on top of the same Dynamic Language Runtime (DLR) component that they put in place to build the dynamic CLR languages like IronPython and IronRuby.

That final thing I want to mention from day 3 was an interesting session entitled “How HP Built Their Magcloud Service on Windows Azure“. This one caught my attention cause I had initially dismissed Azure as something that HP (my employer) would not be interested in. Given that HP has been making a big deal about how great they are at building and operating world-class data centers it seemed kind of strange that we’d take one of our applications and host it on Microsoft’s infrastructure.

Well, after sitting through the session it became apparent that we didn’t build our Magcloud application on Windows Azure as much as we took a portion of the existing Magcloud application and ported it to Azure as a proof of concept. No part of the production Magcloud app is actually running on Azure. Looks like this may have been nothing more than a way to keep Microsoft (an important partner of HP) happy while also getting HP some visibility at PDC.

It’ll be interesting to keep an eye on this relationship and see if anything really happens here. Perhaps HP is hoping to persuade Microsoft to run the Azure platform in one of its “next generation data centers”.

That’s all from day three. Looking forward to wrapping up tomorrow and heading home.

• Steven Sinofsky (SVP of Windows and Windows Live) pretty much admitted that Vista didn’t really deliver. They made a big deal about learning from the mistakes of Vista. We’ll see.
• Big improvements to the task bar with regard to the way that you launch applications and interact with running applications.
  • The ability to pin applications to the taskbar. No more stupid Quick Launch area.
  • Multiple windows from the same application automatically folded into a single taskbar icon.
  • Complete control over the junk in the notification area (AKA the tray). By default no icons get placed in the tray — users must explicitly request that an icon by placed in the tray. Additionally, for items that are in the tray, you can specify that those annoying balloon pop-ups are completely suppressed.
• Support for VHD files (the virtual hard drive format used by Microsoft’s virtualization products) built directly into the OS. Apparently, a VHD can be mounted as if it were a physical drive and the boot manager has been augmented to give you the ability to boot directly from a VHD at startup.
• They were really encouraging developers to deliver 64-bit apps. I’d love to think that I’d have a 64-bit version of every app I use by the time that Windows 7 ships.

The other exciting part of the day was getting to talk with Phil Haack from the ASP.NET team. I wanted to ask Phil about his ASP.NET MVC presentation. If you read my post from day 1 you’ll note that I had some concerns about the use of some pretty ugly C# code in the view layer of the framework. I asked Phil what sort of plans they had for enabling developers to create codeless views. He was quick to point out that there’s no rule stating that you can’t have code in your views — I completely agree with that (after all, what is a JSP tag library but a fancy wrapper on some Java code) but from a readability and aesthetic perspective it still seems wrong to have raw C# code in your view.

Phil did seem to agree that the aesthetics of inline C# code in the ASPX left something to be desired (hope I’m not putting any words in your mouth here Phil) and said that they were looking at creating some declarative wrappers around the HtmlHelper class. Turns out that these “declarative wrappers” are really nothing more than good ol’ ASP.NET server controls. The one thing that I didn’t really grok until I talked with Phil was that WebForms server controls will work in the MVC environment . . . as long as they aren’t dependent on any WebForm-specific concepts like ViewState or the page lifecycle.

Turns out that I’ve done some server control development so I might just take a crack at creating some of my own wrappers just to see how it works. Stay tuned for more on this.

The other thing to point out is that you aren’t limited to using ASPX pages as your view engine — since all of this stuff is loosely coupled you’re free to plug in whatever engine you like. At the moment, there are a handful of alternative engines available including Brail, NHaml, and NVelocity.

Thanks to Phil for taking the time to talk with me — much appreciated.

I guess the big announcement of the day was Microsoft’s new Windows Azure cloud computing platform. This is their answer to things like Amazon’s EC2 or Google’s App Engine. The technology seemed pretty cool and may be something I use for future side-projects, but I didn’t dive into it too deeply today since HP (my employer) is unlikely to be outsourcing their datacenters to Microsoft anytime soon (HP fancies itself to be quite the datacenter expert these days).

For me, the most interesting session of the day was Phil Haack’s talk on the new ASP.NET MVC framework (session replay). This is something that I’ve been interested in for some time now, but haven’t yet had the opportunity to play with. As someone who splits his time pretty evenly between Java and .NET programming, there’s always been a major mental context switch that I have to go through when moving from Struts or Spring MVC in the Java world to ASP.NET Web Forms in the .NET world. The programming models are radically different.

On the other hand, ASP.NET MVC now brings to the .NET platform all of the things that I know and love about the MVC development model:

• Clear separation of concerns.
• Complete control over the structure of my URLs with a robust routing framework.
• Complete control over my generated markup (some people may lament the lack of support for WebForm-style server controls, but I’m happy to be rid of ViewState).
• Unit-testability.

I’ve looked at a lot of the ASP.NET MVC sample code that have been released and the one that I did find disturbing was the amount of code present in the views. MVC is able to leverage the good ol’ ASPX page as a view layer and you’ll often see things like this is the samples:

<p>Please fill out the following form:</p>
<% using(Html.Form("Home", "Index")) { %>
	<input type="text" name="firstname">
	...
<% } %>

In the Java world we’ve been told for years “keep Java code out of your JSPs”, yet here we’ve got some pretty strange looking C# code mingling with our HTML markup (this is actually a pretty clever use of the IDisposable pattern to create a form-scope within the page, but really this sort of code has no business in the view). In Java, this sort of scenario is typically handled by using things like the Java Standard Tag Library (JSTL), the JSP Expression Language or a custom tag library. These things don’t have any counterparts in the ASP.NET MVC world . . . yet.

I was very encouraged to hear Phil say that one of the things they are going to work on is a set of “declarative helpers” that will serve as an alternative to inline C# code within the ASPX view. If true, this would eliminate the one reservation that I currently have about using the ASP.NET MVC framework. Phil is supposed to be in the expo hall this afternoon answering questions and I’m hoping to talk to him about their plans in this area.

Great stuff!