It was about 7 months ago when Scott Hanselman and CodingHorror built the Ultimate Developer Rig.

Let's see what the saving are for late adopters...

There is enough headroom now to pick up an extra 2GB of RAM and still put out less than $1500. I call this configuration the Ultimate Developer Rig +2***.

  * Price includes mail-in rebate
 ** Drive is now deactivate, but comparable 500GB drives are still ~$120.00
*** Not to be confused with the Ultimate Rod of Dexterity +2 by you D&D nerds.

Igor emailed me for my thoughts about his SMTP server built with Windows Workflow. A link for the source code is at the bottom of his post. As Igor points out, WF is well suited to solve more than just business problems, and I think his project is an excellent and practical demonstration of building state machines in WF.

Matt Winkler is looking for feedback on refactoring workflows. Personally, I'd like to see some additional renaming support at the property and activity level that can auto-magically patch up declarative activity bindings.

Many moons ago I wrote a post on unit testing custom activities in WF. I've stuck to this approach over the last year, and I'm still looking for something better. A couple new posts on the topic have come up recently. YooT – Unit Testing custom Workflow Activities. Damir Dobric – Unit Testing: How to create activity type from XOML. Andreas Erben's – Unit Testing: Simple approach to Activity testing and improving the XOML loader.

Finally, Michael Scherotter has built a custom activity for Expression Encoder, and has a webcast to prove it. All we need now is a direct link to the source code, Michael...

Internet Explorer has no problem creating an array of 65,536 elements.

However, IE does have a problem eval-ing an array of 65,536 elements.

The code produces an out of memory error on the eval statement. The limit for eval appears to be 65,535 – a number that harkens back to the dark, dismal days of programming in a segmented memory architecture.

Of course, if you came here looking for the upper limits of eval – you might be doing something wrong!

Not surprisingly, the year 2007 started with January. Microsoft and Ford launched SyncMyRide.com during the Detroit auto show. SYNC now has the commercial that always makes me chuckle - the one with the "Play artist Tiffany" line.

Voice recognition made headlines again in early February as Sebastian Krahmer's idea for a remote Vista exploit began to circulate. The idea is to record spoken, malicious commands into a media file on the web and see if an unsuspecting user will play the file while Vista's speech recognition is running. I think the biggest threat is from the inside, though. Picture a disgruntled contractor sprinting through the maze of cubicles shouting "FORMAT CEEE COLON".

In March I won an XBOX 360 at the MVP summit edition of Party with Palermo. I'd say my favorite games this year included Command and Conquer and the games inside the Orange Box.

April was a busy month – three months jammed into one, really. Microsoft dropped bombshells about Silverlight running managed code on the client, Moonlinght running on Linux, and the DLR running Ruby and Python code. Meanwhile, Paul Graham said Microsoft is dead and Charles Petzold said prose is dead.

In May, Microsoft went from the Tablet PC to the Table Sized PC, and then released the legal hounds on TestDriven.Net.

In June, Bill Simser named his daughter Vista just as a microscopic photograph is found on retail Vista DVDs.

In July, the rumors started that Microsoft would buy FaceBook for $6 billion.

August brought good news – Microsoft settled a patent infringement suit with Eolas that gets rid of "click to activate this control" in Internet Explorer. No more silly workarounds.

September –Fellow co-author Phil Haack joins Microsoft. Halo 3 launches to near riots.

October – Rob Conery joins Microsoft. MSFT invests $240 million in Facebook. The first Alt.Net conference is held.

November – Zune 2 updates hit the street. If only the phone companies could work this same magic.

December - Emacs.Net is all I can say.

Jean-Paul Boodhoo's post on MappingEnumerable<T> reminds me how DTOs sometimes require an inordinate amount of effort for the simple jobs they perform. You need to define them, instantiate them, map them, groom them, and take them for walks twice a day. It always felt to me that the language should help to reduce the DTO tax, somehow.

In JP's post, he is using the following interface to define a mapper responsible for transforming domain objects into data transfer objects (screen bound DTOs, I'm assuming).

Where a simple implementation might look like:

LINQ takes some of the grunge work out of mapping DTOs. For example, if you aren't injecting a mapping strategy at runtime, LINQ can transform a Department object into a Department DTO in place:

Alternatively, when there is a mapper in play for more convoluted mapping logic:

... which is equivalent to:

I think LINQ eliminates the need for JP's MappingEnumerable<T> (a DTO tax), while keeping the advantage of deferred execution (an item isn't mapped until it is enumerated).

Pete Brown is a local guy with a great deal of Silverlight content on his blog, and some cool wallpaper downloads. Pete pointed to the Expression Encoder White Paper today. The document describes itself as providing the "best practices and methods for providing integrated and branded media player skins for Microsoft Silverlight".

After a quick read, I'd say the document does a fine job describing how to build custom skins and templates for the Silverlight media player. The techniques described in the document will also work with the ASP.NET Futures <asp:Media> control. Both of those controls provide additional features (like the standard VCR controls) on top of the Silverlight <MediaElement/>.

The document gets confusing, however, when it describes the class hierarchy behind the player. For instance:

_Button

Players generally require buttons. This is javascript functionality bound to XAML elements and handles mouse events and animations.

The _Button class handles binding the events and animations to the XAML. The intention is for you to handle the events you are interested in.

See the example above in "Roll your own controls" for details on how to implement your own buttons making use of _Button.

Cognitive dissonance comes into play several times in the document when the text describes how to consume underscored type like _Button. By convention, ASP.NET AJAX prefixes private fields, methods, and types with an underscore. When adding a new button to the player that is not one of the "well known" buttons (like the PlayPauseButton), it feels like a hack to instantiate or derive from an underscored class.

Personally, I've been a bit frustrated at the lack of extensibility in the player control provided by Expression. There are no public methods available to override the behavior of the Next, Previous, and VideoWindow button clicks, for example. I hope the ASP.NET Futures version of the control will flesh itself out a little more in the future.

Here is an excerpt of the schema for the top level of OdeToCode:

The Community_ContentPages table carries all of the data needed by every type of content – like moderation flags, published date, and owner ID. Community_Articles carries just the extra information needed for a published article – like the article text itself.

Inside the code, Article and Book classes derive from ContentPage. Inheritance simplifies the implementation, because a great deal of the business logic applies to all the different types of content objects. For instance, the moderation and approval rules apply to articles, book reviews, comments, images, and other entities that all derive from ContentPage.

Mapping to Objects

Inheritance mapping is one good litmus test for the capabilities of an ORM product. LINQ to SQL, for example, only handles one of the three common strategies for modeling inheritance in an RDBMS – the "table per class hierarchy" strategy, which doesn't help me in this scenario. Most full featured OR/M products, like NHibernate, support multiple strategies, including the "table per subclass" strategy I need.

The Entity Framework documentation includes some pointers on table per subclass mapping (known as "table per type" or TPT in EF terminology). Although the EF designer is easy for getting tables and columns spit out into a mapping file, I found working with the designer a bit tedious. Trying to model inheritance using the designer created build errors, so I did most of the XML editing by hand. The key to TPT mapping is:

• Use a BaseType attribute when defining EntityTypes in the conceptual schema.
• Define a single Key column only on the base EntityType in the conceptual schema.
• In the mapping specification, combine the EntityTypeMapping tags for all derived types into a single EntitySet:

Querying

Once the XML work is done, it's relatively easy to pull out persisted entities.

Given the following DTO:

I can use the following LINQ query to pull out only Article objects. The trick is the OfType() operator:

Although I still have some reservations about EF, I'm warming up to the framework...

*If the naming convention strikes you as odd, then remember the schema was designed to work in a shared hosting environment where a single database might need to support multiple applications. The Community prefix helps to avoid naming collisions. An equivalent design today could use schemas in SQL 2005.