Welcome to My Nerditorium

Your ASP.NET.* Project is Not Just Your UI Layer

2011-11-30T22:42:00.001-06:00

In this post by Jimmy Bogard about “dealing with non-transactional operations that must happen if some transaction succeeds,” the often embraced, but sometimes criticized, Session Per Request pattern (aka Transaction Per Request), came under fire in the comments.

I’ve had this conversation with other developers who have raised similar concerns before, and the reason brought up against going with this pattern is based off of the notion that the “Web” project must not orchestrate or indirectly know about the other layers of the application because it is the “UI” layer.

The fact is, that the web project houses two conceptual layers:

It houses the UI layer for the application.
It houses the entry point / bootstrapping for the infrastructure of the application. It is the application.

I am perfectly fine with the plumbing of the web project directly managing transactions. Some part of the application must manage this, and I a believe that the it should be pushed as far out to the seams of the application platform as possible.

All Paths to a Sitefinity Image are not Equal

2011-08-08T20:06:00.004-05:00

Recently, while doing a performance pass through a Sitefinity 4 application, I noticed that a public facing page had an unusually slow load time. Of course, the first thing I did was open up Firebug to see where the time was being spent. To my surprise, the majority of the time was spent waiting for the initial response from the server. After a little digging, I narrowed down the time-sink to a custom widget that pulled images from a Sitefinity image album. In particular, the query to figure out which images to display was the source of slothness.

A few things to note:

There were about 250 image albums in the CMS (all but 5 or so of them were empty at the time of discovery, however).
There were roughly 30 images in the album we were querying against.
When the original query was written, there were only a few images in the system, and that is why the issue wasn’t apparent right when the query was written.

Here’s an approximation of the original call to retrieve the images through the Sitefinity API:

In this bit of code, we are querying for all images that belong to the image album named “Foo”. Note that the query is structured in a way where we query through the image object to determine what album it belongs to.

The above query took about 2 seconds to return roughly 30 Sitefinity Image objects. This would not do. Therefore, I took to tweaking the query. I tried several different things while maintaining the original approach, but since Sitefinity’s LINQ provider isn’t a complete implementation, I couldn’t make much headway.

I eventually decided to rethink the approach and query for the images by going in through the album instead of going through the image object.

This reduced the query time down to about .2 seconds.

Matt Chat–The YouTube Channel You Should be Watching if You Played Video Games in the 80s or 90s

2011-05-15T19:36:00.002-05:00

Nerd service announcement:

If you played video games in the 80s and/or 90s and have never heard of, or watched Matt Chat, you you are in for a treat. One of my friends aptly described it as, “Behind the Music for vintage video games.”

Matt Barton (College Professor and Author) debuted Matt Chat in February 2009 with a low-production-quality, but loving, retrospective of SSI’s classic AD&D CRPG, “Pool of Radiance.” Since then, Matt has produced an additional 100 episodes, and has made leaps-and-bounds in production value. In addition to his editorial retrospectives, Matt began doing interviews with game developers around episode 40.

To whet your appetite, here is a listing of the first 101 episodes of Matt Chat :

1: Pool of Radiance
2: Myst
3: Defender of the Crown
4: M.U.L.E.
5: Elite
7: The Sims
8: The Secret of Monkey Island
9: The Oregon Trail
10: Lemmings
11: Civilization
12: Metroid
13: Adventure
14: The Lost Vikings
15: The PLATO Computer System
16: Lode Runner
17: Ultima VII, The Black Gate
18: Summer Games
19: Gauntlet
20: Worms and Artillery Games
21: Super Mario Kart
22: Deja Vu, Uninvited, Shadowgate, and MacVentures
23: Planescape Torment
24: Star Control II and the Spacewar Legacy
25: Knights of the Old Republic
26: David Crane's Ghostbusters
27: Autoduel
28: Maniac Mansion
29: Wizardry
30: Fallout
31: A Rockstar Ate My Hamster
32: Tomb Raider
33: Jade Empire
34: System Shock 2
35: Alone in the Dark
36: Starcraft
37: Syndicate
38: Legacy of the Ancients
39: World of Warcraft Part One
39: World of Warcraft Part Two
40: Sword of Fargoal with Jeff McCord
41: The History of Cinemaware with Bob Jacob
42: Dragon Age Origins
43: Archon
44: Ralph Baer, the Father of Videogames
45: Rogue
46: Choose Your Own Adventure with R.A. Montgomery
47: Quest for Glory
48: Dungeons of Daggorath
49: Nancy Drew featuring Jessica Chiang
50 Part 1: Leisure Suit Larry featuring Al Lowe
50 Part 2: Leisure Suit Larry featuring Al Lowe
51: Interview with John Romero (Early Days)
52: Wolfenstein 3D with John Romero
53: Doom with John Romero
54: Quake with John Romero
55: Daikatana with John Romero
56: Ocarina of Time
57: Tunnels of Doom
58: Heroes of Might and Magic
59: The Settlers
60: X-COM, UFO Defense
61: Sid Meier's Pirates
62: Chris Avellone's Early Days
63: Planescape Torment with Chris Avellone
64: Sean Cooper's Early Days
65: Syndicate with Sean Cooper
66: Fallout with Tim Cain, Pt. 1
67: Fallout with Tim Cain Pt. 2
68: Arcanum and More with Tim Cain
69: Howard Scott Warshaw's Early Days
70: ET and Yar's Revenge with Howard Scott Warshaw
71: The Bard's Tale
72: Deus Ex
73: The Dig
74: Dune II
75: Interview with Megan Gaiser and Rob Riedl of Her Interactive
76: King's Quest
77: Darklands
78: Arnold Hendrick Interview Pt. 1
78: Interview with Arnold Hendrick Pt. 2
78: Interview with Arnold Hendrick Pt. 3
79: Scott Adams' Early Days
80: Adventureland with Scott Adams
81: Questprobe and More with Scott Adams
82: Interview with Rebecca "Burger" Heineman Pt. 1
83: Rebecca Heineman Pt. 2
84: Rebecca Heineman Pt. 3
85: Rebecca Heineman Pt. 4
86: Bard's Tale IV and Wasteland II with Rebecca Heineman
87: Twilight Scene it with Don Kurtz (censored)
88: The Donimator Gets His
89: Bard's Tale and Wizardry with Brian Fargo
90: Wasteland and Fallout with Brian Fargo
91: The Fall of Interplay with Brian Fargo
92: Mail Order Monsters
93: Scratches and Asylum with Agustín Cordes
94: Interview with Agustín Cordes Pt. 2
95: Skylanders and more with Paul Reiche and Fred Ford
96: Star Control and More with Paul Reiche and Fred Ford
97: The Horde and More with Fred Ford and Paul Reiche
98: Scott Miller Interview Pt. 1
99: Duke Nukem with Scott Miller
100: Scott Miller will Live Forever
101: Baldur's Gate

My Sister Always Said I’d Turn Out to be a Nerd

2011-04-12T18:49:00.001-05:00

Today was a good day. As mentioned previously, I’ve been looking for a new career opportunity for the past month-and-a-half or so. My journey came to a head yesterday when I received two fantastic job offers. I’m happy to report that I have accepted an offer to join
the Nerdery as a Software Engineer. I’m looking forward to working with this group of people who are way smarter than I am, and for the chance to grow with this unique company.

Additionally, I’ve been reflecting on the overall job search experience. I am very aware of how lucky I am to have rubbed shoulders with many insanely smart and experienced professionals. I really appreciate the time everyone took to meet with me. Life is good.

Full Stack Interview Coding Challenges

2011-03-25T15:23:00.001-05:00

It’s been seven years since I was last looking for a job, so I’m not sure if this is a new trend or not: Over half the companies I’ve started the interview process with have given me time-unlimited full-stack coding challenges as part of the interview process. I just completed my third one in two weeks and I thought I’d share my thoughts about this practice in general.

Challenge Requirements
Here are highly condensed versions of the requirements for each challenge:

Company A:

Create an ASP.NET MVC application that consists of one page that allows users to add, remove, and rate movies. Movie ratings are to be indicated with a star rating control similar to what Netflix uses.
Create a Javascript widget that a user can host on their blog which pulls and displays their movie ratings from the application.

Company B:

Create an ASP.NET MVC website that allows users to upload and view images. If the image is more than 500 pixels wide, or 700 pixels tall, downsize the image to the maximum allowed size, but maintain the aspect ratio. All images should be stored on the server, including the original image when images are resized.

Company C:

Create an ASP.NET application (Webforms or MVC) that allows users to add and vote on Xbox game titles for the company break room. Users can only vote once a day, and they cannot vote on the weekends. Any user can mark a game as owned, in which case it ends up on a list of owned games. The titles and votes will be stored / retrieved via a set of WCF services that are provided for you. In addition to sending the code in for review, submit a URL to a running copy of the application.

What I Liked About the Process

First off, I really liked that these companies wanted to see code. I think far too many places hire developers without seeing a line of code. True, you can determine what somebody is capable of through conversation (especially at senior / expert levels), but I think it’s a pretty big risk. Some people are really good at talking, and / or look good on paper when in truth they don’t know what they are doing.

Secondly, I really enjoyed doing these challenges. They’ve helped me from getting rusty during this period of unemployment. Additionally, I had to learn at least one thing for each of the applications. For company A’s challenge, I had to learn how to create a widget that used JSONP. For company B’s challenge I had to learn to resize an image while keeping its aspect ratio using only the core .NET framework. For company C’s challenge, I learned how to use the MVCContrib Grid and the jquery.dataTable plugin. I also learned and used AppHarbor to host the application.

What I didn’t Like or was Uncomfortable With During the Process

Finding time to do all three of these within a couple of weeks was a little rough. I did find the time, but part of me was wondering if the companies were wondering why I hadn’t turned the challenge in yet. In reality they didn’t know that I was working on three of them simultaneously. This is something I probably should have communicated to them.

The thing I was most uncomfortable with was that I felt like I had more than enough rope to hang myself with in terms of doing things that weren’t wrong per say, but that the reviewer might frown upon due to personal taste. One thing that I was really torn on was how C# 2/3/4 idiomatic I should make my code. Taking advantage of generics, lambdas, linq, anonymous types, etc… could cause the code to look like gibberish to the reviewer if he or she is still writing code in C#1 style. On the flip side, I felt that I would look like I was stuck in the past if I didn’t write modern C#. I’m not sure that finding the middle ground is the right thing to do in this case either as it could look inconsistent.

Along the same lines, I found it very difficult to decide on the right level of architectural complexity to use. These apps were all a bit more than trivial, so I could have gone either way with the complexity. As with idiomatic C#, I found myself wondering if the reviewer was going to think I was oversimplifying or overcomplicating things. Additionally the reviewer may actually want me to overcomplicated things a bit to show what architectural patterns I know.

These two issues are things that usually get sorted out when you hash over ideas with people in person, but I found it difficult to know who my audience was when given nothing but a set of requirements.

Final thoughts

All-in-all, I thought it was a positive and enjoyable experience. If I’m ever in the position to help with hiring again, I would probably really push hard for code samples to be part of the process. However, I probably wouldn’t give such open ended challenges. I’d probably give multiple smaller and more focused problems.

.NET Dependency Management in a Pre-Nuget World

2011-02-28T21:03:00.016-06:00

This post is an attempt to capture how my previous team dealt with dependency / package management. The team, at its largest point, consisted of about 15 developers. There were roughly 200 3rd party dlls, and roughly 150 internal dlls in the dependency mix. No single app needed all 350 dlls, but groups of these dlls were common to applications in the same domain space of the enterprise. 3rd party dlls were things such as the MS Enterprise Library, image conversion libraries, desktop scanner interop libraries, etc… Internal dlls were things such as common utility libraries, WCF service contracts, DTOs etc…

Until the recent development of projects such as Nuget and OpenWrap, dependency management in .NET has been a big problem. The larger a development group’s topology is, the more of a pain point it is. Because this is the case, a lot of teams don’t even realize they are going to have issues until the pain is upon them. Additionally, I think the complexity of describing the problem has helped to keep package management as an elephant in the .NET room for a long time.

Since there has been abundant discussion on this issue lately, I’m going to skip describing the problems with dependency management and get straight into what we tried over the years, and what the final solution ended up being. It’s important to note that my team used TFS (2008) for source control because some of the steps we took were in response to TFS’ weaknesses.

First attempt ending in Failure:

Manage all 3rd party dlls by putting them in a [sln]/bin folder (tracked by TFS).
Manage all internal dependencies as shared projects across multiple slns.

I’m sure some of you are already cringing after reading the last bullet point, but you’ll have to admit it is the first solution that comes to mind to a lot of developers. Additionally, it is a very simple solution. The biggest issue with this solution is with sharing a project over several slns. Unfortunately, any bit of code in those shared projects is easily changeable from multiple slns; therefore it is very easy to break several slns in one fell swoop. Secondly configuration management goes out the window because every time a sln is compiled, each shared project gets a new version that bypasses any sort of change management.

Second attempt ending in failure:

Manage all 3rd party and internal dlls by putting them in a [sln]/bin folder.

This solution complicates things slightly (in a positive way) by requiring each sln to use a proper release of all internal dlls; therefore you are able to have some degree of configuration management. However, this solution failed for us because of one simple fact: TFS does not track binaries well. We never ran into this weakness with the first solution because all of the 3rd party dlls were set-and-forget. They never changed after setting the initial reference. The internal dlls however, would change daily, or even hourly. At first this seemed like the perfect solution, however all sorts of strange errors started occurring. One person would get latest and everything would work, but another person would get latest and have errors. TFS simply could not tell if you needed a new version of the dlls in the /bin folder. Sadly, even a “clean all" and "get specific version" didn't fix things a lot of the time.

Third attempt ending in Success:

Build a custom package management system.

Our custom package management system worked thusly: We created a network share. For each logical release (i.g. MS EntLib, Internal.Common.Util) we created both a [networkShare]\[package]\LatestRelease folder and a [networkShare]\[package]\Release_[version number] folder. We then created a console EXE with a bunch of options that would: 1) go and grab all of the latest dlls for all projects and dump them into one pre-defined “latest” folder on the developer PC and 2) Recreate the “releases” tree structure on the developer PC. This way, developers have the ability to drink from the fire-hose (the latest folder) or go for set releases (from the releases folder tree). TFS is not tracking dlls at all. Rather, we are relying on an absolute path file reference. Additionally, calling this executable becomes a build task on the CI server.

This solution isn't perfect. Namely, it relies on developers to remember to run the executable from time to time. Additionally, there are potentially some versioning scenarios that could occur between packages that expect a different versions of sub dependencies. However that issue never manifested itself in our environment.

Nuget is not the final answer for teams using TFS
I've been following the Nuget dev list closely, and Nuget is considered to be a development time dependency resolver only, not a build time resolver. This means that if you use TFS to track your Nuget package folders, you could still run into dll versioning issues.

Update (4/17/2011)
Nuget team member David Ebbo has blogged that functionality has been added to allow use of Nuget without committing the packages folder to source control.http://blog.davidebbo.com/2011/03/using-nuget-without-committing-packages.html

Update (4/30/2011)
According to Phil Haack, Nuget is going to be getting official support for non-committed packages: http://haacked.com/archive/2011/04/27/feedback-request-for-using-nuget-without-committing-packages.aspx

I know that many of us have had to face this problem, therefore I'd really enjoy hearing about how you addressed this issue.

Moving On

2011-02-23T12:18:00.004-06:00

Yesterday was a tough day. I resigned from my position of seven years as a Developer / Analyst for the Office of the Minnesota Secretary of State.

Over the past couple of months, the development group has gone through several reorganizations. Yesterday another reorganization happened, including a substantial software platform shift. I did not feel this shift was good for my career, nor was it something I wanted to participate in. Additionally, I think the days of in-house software development for government agencies are coming to an end at light speed. Therefore, with heavy heart, I felt it was time for me to go. Up until recently, it was the most enjoyable job of my career. I wish my former coworkers the best of luck, and I look forward to hearing their war stories as time goes on.

The Case of Web Deploy 2.0 and the Missing MSDeploy.exe

2011-02-16T09:18:00.013-06:00

This week, I decided to install the newly released Web Deploy 2.0 on my machine at work. I already had Web Deploy 1 on my machine, so I decided to uninstall that first before installing 2.0. After the installation I begain getting the following error when trying to execute VS2010 created web deployment packages from the command line:


Error:  The system was unable to find the specified registry key or value
msdeploy.exe is not found on this machine. Please install Web Deploy before exe
cute the script.
Please visit http://go.microsoft.com/?linkid=9278654
=========================================================
=========================================================

Of course the first thing I did was validate that MSDeploy was indeed installed with Web Deploy 2.0. It was. I then tried adding MSDeploy's location to the path environment variable. No dice. I then tried reinstalling Web Deploy 2.0. Still no luck. After trying some other things I cracked open the deployment package's cmd file and found this:


@rem ---------------------------------------------------------------------------------
@rem if user does not set MsDeployPath environment variable, we will try to retrieve it from registry.
@rem ---------------------------------------------------------------------------------
if "%MSDeployPath%" == "" (
for /F "usebackq tokens=2*" %%i  in (`reg query "HKLM\SOFTWARE\Microsoft\IISExtensions\MSDeploy\1" /v InstallPath`) do (
if "%%~dpj" == "%%j" ( 
set MSDeployPath=%%j
))

For whatever reason, Web Deploy 2.0 did not add either of these items during install. I ended up adding the MSDeployPath environment variable, and all was good.

Programming is a Craft

2011-01-11T21:28:00.003-06:00

Here are my initial thoughts after reading: Programming is not a Craft

“craft -noun 1. an art, trade, or occupation requiring special skill, esp. manual skill: the craft of a mason." (dictionary.com)

“In English, to describe something as a craft is to describe it as lying somewhere between an art (which relies on talent) and a science (which relies on knowledge). In this sense, the English word craft is roughly equivalent to the ancient Greek term techne." (wikipedia.com)

In my opinion, on a whole, software development is a combination of craft and primitive engineering (which is slowly emerging as a true engineering discipline). The term craft usually means how something was made, not what was made or the perceived value of the end result by the layman. One of the commenters on the original post mentioned carpentry as a craft that may not always be defined by the value placed on the end product by the layman. In this vein, I will also mention that witchcraft is considered a craft.

One of the hallmarks of craft is that that it is filled with heuristics and folklore. Much of the work of today's software developer is squarely within this realm. More often than not, there is no clear-cut way to solve a problem. We craft a solution based off of our experiences and the folklore we encounter. It is worth noting that I consider blogs, google searches, MSDN, visits at a coworker's desk, irc, and stackoverflow.com to be sources of folklore.

I must say that I do agree with much of the post, but I think the terminology that is presented is incorrect. I think it would have been wiser to say that software development is most often not an art, and ego has no place in it.

I also have to concede that in hindsight, I believe that the software craftsmanship manifesto was a bad idea. I recently learned there was a period of time when it was being debated if there should be clause in it to forbid using anything (tools, languages, etc...) that was not OSS. In my opinion the manifesto only serves to force a definition on something that needs no additional definition.

The Mythology of Commodore Told in about 15 Minutes by Jim Butterfield

2011-01-09T20:48:00.005-06:00

I was cleaning up the data drive on my computer tonight and I came across this gem, which is also hosted on blip.tv:

Click To Play

Many of us owe our career to Butterfield, and the father of the 65XX - Chuck Peddle.
If you are interested in the history of Commodore, please check out Brian Bagnall’s: Commodore: A Company on the Edge.

Getting RVM to Work when GVim is Launched from Ubuntu's Menu

2010-12-26T19:43:00.021-06:00

If you want to use GVim as your Ruby editor in Ubuntu (and most likely any other Gnome based distro), you've probably found out that your .bashrc file is not read when launching GVim from the Gnome menu. This means that your RVM paths are not available in the scope of apps launched from the menu. However, when launching apps from the menu, the launcher can access your .profile file. That being the case, here is a quick work-around for this issue:

1) Add the following code to your ~/.profile file:

# This loads RVM into the session scope of the launcher.
[[ -s "$HOME/.rvm/scripts/rvm" ]] && . "$HOME/.rvm/scripts/rvm"

2) Create a script that you can use to start up GVim. Example ~/Apps/GVim/gvimstart.sh. In this script, place the following:

#!/bin/bash
source ~/.profile 
gvim

3)Right click on the applications menu and choose "Edit Menus". Then find your GVim launcher and point the command entry to your script.

I am, by no means, a Gnome expert, so please let me know if you are aware of a better solution.

Happy coding!

Learn WPF for Free

2010-12-10T00:39:00.004-06:00

In my last WPF related post I spoke a bit about my WPF learning experience. I was fortunate enough to have an MSDN Universal subscription and any book I wanted via my employer as I went down the path. Unexpectedly, I recently received an email from a reader who wanted to learn WPF on a budget of $0.00. After thinking for a bit, I came to the conclusion that WPF can be learned without spending any money (assuming you have a computer that can run the tools). Below is a roadmap on how to do so.

Get the tools for free

Visual Studio Express, which is able to create WPF apps can be found here:
http://www.microsoft.com/express/Windows/

If you need any other tools, such as SQL Server Express, you can most likely find them via the Web Platform Installer here: http://www.microsoft.com/web/downloads/platform.aspx

Learn the Framework

Between MSDN and the community, there is more than enough well-written documentation out there to help one become an expert on the WPF framework itself. In his book, “Advanced MVVM”, WPF expert, Josh “The Maestro” Smith, recommends the following documents to come up to speed with the WPF framework:

Introduction to WPF: http://msdn.microsoft.com/en-us/library/aa970268.aspx
WPF Architecture: http://msdn.microsoft.com/en-us/library/ms750441.aspx
A Guided Tour of WPF: http://joshsmithonwpf.wordpress.com/a-guided-tour-of-wpf/
Customize Data Display with Data Binding and WPF: http://msdn.microsoft.com/en-us/magazine/cc700358.aspx
ItemsControl: ‘I’ is for the Item Container: http://drwpf.com/blog/2008/03/25/itemscontrol-i-is-for-item-container/

A lot of the information in the above links is difficult to absorb, but I think it is very worthwhile to go through the material, and work through the examples, at least once. If some of the documents are unclear, you can always go back to them as you learn more and need more clarification.

Learn MVVM

Many people blow off MVVM as “the latest popular design pattern”, but learning MVVM is essential to working with WPF. This is because MVVM is a natural pattern to use considering the way databinding works with WPF. Yes, you can write WPF apps using tried-and-true code-behind and click event handlers like people did with winforms, but you’ll be doing yourself a disservice.

When learning MVVM, the first place to look is this very simple video by the Jason “The Enigma” Dolinger, where he explains what MVVM is, and what the pattern’s strengths are: http://blog.lab49.com/archives/2650

The next place I would look is the “MVVM In the box” training by Karl “The Educator” Schifflett:
http://karlshifflett.wordpress.com/2010/11/07/in-the-box-ndash-mvvm-training/

As a lesson summary, an in-depth overview of MVVM written by Josh Smith can be found here: http://msdn.microsoft.com/en-us/magazine/dd419663.aspx

Apply what you’ve learned

While there is no WPF “best practices” sample that I am aware of, I think the following can get one to see how WPF fits into an application architecture.

Building a Desktop TO-DO application with NHibernate: http://msdn.microsoft.com/en-us/magazine/ee819139.aspx
Understanding the MVVM Pattern: http://live.visitmix.com/MIX10/Sessions/EX14
Build Your Own MVVM Framework: http://live.visitmix.com/MIX10/Sessions/EX15

Not strictly MVVM, but worth looking at as application and framework samples:

PRISM: http://compositewpf.codeplex.com/
Caliburn Micro: http://caliburnmicro.codeplex.com/
Caliburn Micro Soup To Nuts Series: http://caliburnmicro.codeplex.com/documentation
MVVM Light: http://mvvmlight.codeplex.com/

Keep Learning

Read Blogs! Search out WPF related blogs. There are enough out there to fill your news reader every day. Pete “6510” Brown puts out a Windows Client roundup frequently which is a good starting point.

Read and participate in the knowledge dump at http://stackoverflow.com/questions/tagged/wpf.
At first you may find that some of the questions are the same things you are wondering about. After awhile, you will find that you can answer some of the questions. As you answer questions, you’ll reinforce what you’ve learned.

Software development is still largely a folklore based discipline. It is your duty to share what you have learned in the best way you know how.

Katamari Code

2010-11-22T21:49:00.004-06:00

We’ve all worked on projects where the codebase is a mess. Here are a couple of common messy codebase analogies I’ve heard over the years:

The House of Cards Codebase:

The Jenga Codebase:

Although I can appreciate the above analogies, more often than not, I think Beautiful Katamari is the most appropriate analogy.

Time Until Productivity In WPF

2010-08-10T21:51:00.003-05:00

One of the things I see over-and-over-again when reading about teams that are deciding if they should adopt WPF or not is the fear of the learning curve, and the worry that they will not be productive for a huge period of time. Given that I’ve recently become productive in WPF myself, I thought I would talk about my experience in this area.

A little background about myself: I would consider myself to be your average mid-30 year old ALT.NET developer. I got my start programming BASIC and 65xx assembly as a kid in the early 80s on a Commodore 64, got my first programming job doing Java in the late 90s, and started using ASP.NET in the late 1.0 beta days. Programming is one of my hobbies, but I am not the type that stays up all hours of the night working on my pet OSS project. I am also not a “computer scientist” or language wonk. However, I am passionately interested in software craftsmanship. S.O.L.I.D. is prominent in my tool belt.

My attention was first turned to WPF in the early fall of 2008. My group was facing a large desktop project. The question came up as to if we should go with Winforms or WPF. No one on the team had any practical Winforms experience, so the initial reaction was that we should go with WPF since Microsoft had made it clear that it was the future of Windows desktop development. However, we all had heard rumblings about how difficult WPF was. That being the case, each member of the team created a very small drag-and-drop application to test the waters. The general consensus was that if you ignored the more advanced features of WPF, it was just as easy as Winforms drag-and-drop + code behind development. Mind you, we did not want to do that sort of development, but it became apparent that that style of development would be equally painful using either framework. Note that at this time, I really had no idea how to make a real application using WPF, but I did understand the very basic concept of how XAML markup changed the game from Winforms development.

Estimated time spent learning WPF during this period: 8 hours.

After the initial decision making process, I returned to ASP.NET and WCF development. The WPF project didn’t really get started until spring 2009. I was not slated to work on the project, but I was enlisted to help decide the preliminary architecture. Once I was given that task, I began to look around for application frameworks, or at the very least, some patterns that had momentum behind them. At this time, I learned about the MVVM pattern via the still insightful Jason Dolinger video. It really seemed to click in my mind so I began looking for an application framework to support this pattern. I did not find a mature application framework per say, but I did come across PRISM. There were a few other budding frameworks at the time, but PRISM was way ahead of the game. Therefore, we decided to go with PRISM using the MVVM presentation pattern on the client side of the application. Once that decision was made, I was back off the project and doing other things. I did however start following a few WPF blogs at this time, but I did not do any WPF coding.

Estimated time spent learning WPF during this period: 8 hours.
Total estimated time: 16 hours.

This July, my schedule freed up and I was put on the project 50% of my time. I was tasked with a reporting interface that had to show a list of available reports and then dynamically show parameter UI elements depending on which report was selected.

As soon as I was assigned to the project, I got a copy of WPF in Action with Visual Studio 2008. I read the book half the day during my work week, and then a few hours each night at home. As someone who learned programming through type-in programming, I made sure that I recreated all of the samples myself. Also at this time, I grabbed the latest version of PRISM and took a peek at the examples.

Estimated time spent learning WPF during this period: 30 hours.
Total estimated time: 46 hours.

The first week of actual development was pretty brutal. MVVM was not the problem. PRISM was not the problem. XAML and databinding is where I was banging my head against the wall. It kind of worked like HTML, and it kind of didn’t. That first week was pretty aggravating, but pretty much every problem I encountered was just an internet search away.

Estimated time spent learning WPF during this period: 30 hours.
Total estimated time: 76 hours.

I became productive after that first week. I’ll be the first to admit that I don’t intimately know how WPF works behind the scenes (like I do with ASP.NET). However, I do think that I became productive within a reasonable amount of time.

Looking back, I can safely say it took me about 80 hours to go from expert ASP.NET programmer to productive WPF programmer. That being said, I do not know how long it would have taken me to go from expert ASP.NET programmer to productive Winforms developer. Something tells me it wouldn’t have been a number that would have made us use Winforms instead of WPF.

Should .NET Auto Properties Have Unit Tests?

2010-07-19T21:51:00.001-05:00

Should .NET auto properties be unit tested? It is very easy to argue that testing auto properties falls into the “testing the .NET framework” smell and is a waste of time. However, experience has shown me otherwise. This is something that I’ve gone back and forth on many times since auto properties were introduced. For the time being, I think I’ve reached a conclusion. That conclusion is yes.

I typically do two types of testing: 1) Test Driven Design, and 2) Test while/after unit testing. Let’s consider these two scenarios.

When doing test driven design, there is no question. You should write tests for your auto properties. Test driven design is not about testing; it’s about design. The rule of thumb is that you don’t write any code without a test dictating its need. Case closed (in general).

Things get trickier when doing test while/after unit testing. This type of testing is more about creating a test harness. When writing tests after the fact, I know that the property is implemented using auto properties. Therefore, if I am taking a white box approach, I know that my implementation of the encapsulated property is simply the .NET framework. Following that line of thought, testing auto properties is testing the .NET framework. However, I tend to view test while/after testing as a test harness of the public contract. This is black box testing. A public property is an encapsulation, and therefore it should be tested. It’s not uncommon for an auto property to be converted into a regular property as an application lives on. I’d have to say that I would want a test there to capture any publicly facing change in that encapsulation.

Persistence Ignorant Lazy Loading For Your Hand-Rolled DAL In .NET 4.0 Using Lazy

2010-04-26T20:07:00.008-05:00

This post is a brief update to the .NET 3.5 article I posted about P.I. lazy loading. The only major change I have made to the code is to use the new Lazy<T> class that was introduced in .NET 4.0. This considerably cleans up the LazyLoadingList<T> class from the previous post.

Here is the new LazyLoadingList<T>:


public class LazyLoadingList<T> : IList<T>
{
   private Lazy<IList<T>> _lazyList;

   public LazyLoadingList(Lazy<IList<T>> lazyList)
   {
      _lazyList = lazyList;
   }

   #region Implementation of IEnumerable

   public IEnumerator<T> GetEnumerator()
   {
      return _lazyList.Value.GetEnumerator();
   }

   IEnumerator IEnumerable.GetEnumerator()
   {
      return _lazyList.Value.GetEnumerator();
   }

   #endregion

   #region Implementation of ICollection<T>

   public void Add(T item)
   {
      _lazyList.Value.Add(item);
   }

   public void Clear()
   {
      _lazyList.Value.Clear();
   }

   public bool Contains(T item)
   {
      return _lazyList.Value.Contains(item);
   }

   public void CopyTo(T[] array, int arrayIndex)
   {
      _lazyList.Value.CopyTo(array, arrayIndex);
   }

   public bool Remove(T item)
   {
      return _lazyList.Value.Remove(item);
   }

   public int Count
   {
      get
      {
         return _lazyList.Value.Count;
      }
   }

   public bool IsReadOnly
   {
      get
      {
         return ((ICollection<T>)_lazyList.Value).IsReadOnly;
      }
   }

   #endregion

   #region Implementation of IList<T>

   public int IndexOf(T item)
   {
      return _lazyList.Value.IndexOf(item);
   }

   public void Insert(int index, T item)
   {
      _lazyList.Value.Insert(index, item);
   }

   public void RemoveAt(int index)
   {
      _lazyList.Value.RemoveAt(index);
   }

   public T this[int index]
   {
      get
      {
         return _lazyList.Value[index];
      }
      set
      {
         _lazyList.Value[index] = value;
      }
   }

   #endregion
}

Here are the changes to the invoking code:


public class CompanyDAO : ICompanyDAO
{
   List<Company> _companiesInDatabase = new List<Company>
         {
             new Company(){Name = "ACME"},
             new Company(){Name = "Hardees"}
         };

   #region Implementation of ICompanyDAO

   public Company GetByName(string name)
   {
      // Write to console to demonstrate when loading is happening
      Console.WriteLine("---Loading Company---");

      // Pretend we are calling / mapping from a store procedure
      var company = _companiesInDatabase.Where(x => x.Name == name).First();

      
      // Create / add the lazily loaded collection
      if (company != null)
      {
         var lazyLoader = new Lazy<IList<Employee>>(
               () =>
                     {
                        var employeeDAO = new EmployeeDAO();
                        return employeeDAO.GetByCompanyName(name).ToList();
                     }
            );

         company.Employees = new LazyLoadingList<Employee>(lazyLoader);
      }

      return company;
   }

   #endregion
}

The full source can be found here: http://github.com/dauger/BlogSamples

How to fail at ORM

2010-04-07T10:09:00.005-05:00

Let's face it: if trends continue, some form of ORM will be a fact of life at most .net organizations that develop business / enterprise software. Microsoft isn't playing games this time with Entity Framework. They mean for it to succeed. Additionally, at the time of writing this, NHibernate has been downloaded 391,024 times from sourceforge alone (there is more than one place to download it from). This being the case, I’m going to give everyone a few pointers to ensure that their first attempt at ORM fails.

Here are my tips to insure ORM adoption failure (in no particular order):

Consider the ORM’s SQL engine as a replacement for SQL knowledge. The whole point behind ORMs is so that I don’t have to write or understand SQL right? WRONG!

Consider the ORM’s SQL engine to be a black box. I got back the correct dataset, so this must be the best SQL the ORM can produce right? WRONG! Most ORMs will create drastically different SQL depending on how the object query is structured.

Don’t get more than a skin deep understanding of the ORM. If you run into a brick wall with a bit of behavior from the ORM, you can follow two paths. You can A) learn about the finer points of the ORM to resolve the issue, or B) rip the ORM out of your application. The latter is the outcome I’ve seen more often than not. A classic example of this is the N+1 select issue where the app calls the database in a loop. ORMs have things such as eager loading, multi-queries, and future queries to avoid extra trips to the database. However, it’s best to ignore the existence of those features if you want to fail at ORM.

Use ORM generated schema without manually tweaking it. Many ORMs will happily create a schema for the developer just how they specified it, and index free. Ideally you shouldn’t use generated schema at all once you are up and running. A DBA should be creating a schema using relational theory. However, if you want to fail, it’s best to just used that generated schema.

Use the ORM for 100% of your data access.
Most ORMs allow for dropping into prepared SQL, stored procedures, and even db function calls. However, it’s best to ignore this functionality if you want to fail.

Maintain OO purity at all costs.
Does fetching your aggregate root cause an 11 table join? So be it.

Cut the DBA out of the development process.
The whole point of ORM is to cut out the DBA right? WRONG! The DBA should be just as active with helping to craft the data access strategy as they would with a hand rolled data access layer. Cutting the DBA of the picture is a recipe for failure.

Don’t profile your application.
If you want to fail, it’s best to find out if you have have created a SQL nightmare once you hit production. NHProf, EFProf, L2SProf, and SQL Profiler are your friends. Ignore them to fail.

I hope you find these tips helpful. I’d like to hear about any other tips for ORM failure you might have.

Possibly The Most Important C# Interview Question

2010-03-12T15:45:00.012-06:00

The Problem

Recently I was reviewing some code at work that was written by a senior developer that had left the organization. I saw something along these lines that set off a huge red flag in my head:

Address newAddress = customer.Address;
newAddress.LineOne = "122 SongbirdLane"; // more changes etc...
customer.Address = newAddress; // RED FLAG!

Although the above code technically works, I took it as a warning sign indicating that the developer probably didn’t understand how references work. Sadly, my suspicions were confirmed after I dug through some more code. Even worse, the application was littered with hacks to fix areas where this misunderstanding manifested problems.

Yes ladies and gentlemen, there are people out there that have been doing C# development since .NET 1.0 that don’t have a functional mental model of how the language works. I wish I could say this was the first time I’ve run into this. Sadly, I’ve run into it several times over the years.

The Solution

It is very easy to weed these people out during the interview process by asking a very simple interview question. That question is:

What does the following program output to the command line?


public class Person
{
   public string Name { get; set; }
}

class Program
{
   static void Main(string[] args)      
   {
      Person joe = new Person();
      joe.Name = "Joe";

      Person tim = joe;
      tim.Name = "tim";

      Console.WriteLine(joe.Name);
      Console.WriteLine(tim.Name);

      int myNumber = 666;

      DoSomething(myNumber);

      Console.WriteLine(myNumber);
   }

   private static void DoSomething(int someNumber)
   {
      someNumber = 777;
   }
}

The trick is that you have to ask it to every developer, no matter how many years they have under their belt.

Speeding Up Cassini In Vista And Windows 7

2010-02-20T19:59:00.001-06:00

I was doing some ASP.NET MVC work this evening on my new supa-fast Windows 7 machine using the built-in Visual Studio Cassini webserver. For some odd reason, it was taking a few seconds for my tiny pages to resolve / render. I was using Chrome, so I decided to try Firefox. Firefox was just as slow. I then tried using IE and it performed with the speediness I was used to on my old XP install. I did some digging, and I came across the solution to the problem in two places:

http://www.wagnerdanda.me/2009/12/asp-net-development-server-slow-on-windows-vista7-with-firefox-or-chrome/
http://stackoverflow.com/questions/1416128/my-local-host-goes-so-slow-now-that-i-am-on-windows-7-and-asp-net-mvc

It turns this is an issue with ipv6 and resolving localhost on Vista and Windows 7. The fix is very easy – you simply need to uncomment the localhost entry in your C:\Windows\System32\drivers\etc\hosts file by changing this:

# localhost name resolution is handled within DNS itself.
# 127.0.0.1 localhost

to:

# localhost name resolution is handled within DNS itself.
127.0.0.1 localhost

You may need to run your text editor as administrator in order to save the changes.

Practical Persistence Ignorant Lazy Loading For Your Hand-rolled DAL

2010-01-31T22:08:00.022-06:00

Introduction – A Word Of Warning

First off - I do not recommend you write your own hand-rolled data access solution for an OO .NET application. Ayende has a great post that should convince you to use something like NHibernate, LLBLGen, Entity Framework, or Linq2Sql. I strongly agree with him. I’ve worked on several projects which had a hand rolled, stored procedure based DAL. All of the DALs that were of a medium-to-large-size eventually turned into a huge mess, or something with tons of friction and poor performance. That being said, I am not allowed to use an ORM at my current employer, and I know that many others are not as well. That being the case, I think this post may be of use for other people in the same situation.

Secondly – I specifically used the word “practical” to describe this strategy. Although there are ways to do this sort of thing with code gen and/or reflection, I am going to assume that most places that don’t use ORMs will find those techniques to be too complex.

Thirdly – This article is focused on the lazy loading aspect of the sample code. The implementation / organization of the data access layer is not to be taken as best practices. It is organized in a way to be easily understood, and so it does not get in the way of the topic at hand. I am also ignoring many other features of a robust data access layer (change tracking, transactions, etc…) as I think they do not need to be understood in order to put this concept in action. However, there is nothing about this implementation that would exclude it from being used with other ORM concepts.

Terminology

As far as this article is concerned, here are the operational definitions of the core terms:

Entity: An object that is persisted to the database that has business related behaviors.

Data Access Object (DAO): A DAO is a data access layer (DAL) object that has the responsibility of calling the database and mapping the results to entities. The Repository Pattern is a relative of the DAO pattern.

Persistence Awareness (PA): An entity that is persistence aware is one that is responsible for its own persistence.

Examples:

var myClass = MyClass.LoadByID(id);
myClass.Save();

A PA entity is either directly or indirectly aware of its data store and is responsible for coordinating the persistence of its children. When the persistence methods are called, it news up the appropriate DAO and gets the results back.

Persistence Ignorance (PI): An entity that is persistence ignorant relies on other classes to handle the responsibility of persisting it.

Example:

var myClassDAO = new MyClassDAO();
var myClass = myClassDAO.GetByID(id);
myClassDAO.Save(myClass);

The coordination of persisting and retrieving child entities is also handled by the external class.

Lazy Loading: Lazy loading is a term that refers to delaying the retrieval of a child collection until it is accessed. This is done to save trips to the database and to reduce application memory consumption. Consider the following code:


var userDAO = new UserDAO();
var company = userDAO.GetByName("Hardees");

Console.WriteLine(company.Name);

foreach(var employee in Company.Employees)
{
 Console.WriteLine(employee.Name);
}

If we are using lazy loading, the employee collection would not be loaded until we hit the body of the foreach loop. If we were using eager loading, the employee collection would have been loaded when the company was loaded.

Why should PI be preferred to PA?

There are two reasons which are a bit related. First off, persistence code tends to be tricky and long winded. Often times there is more persistence code in a PA class than business logic. Secondly, you always want to give your class as few responsibilities / reasons to change as possible. The code in your entities should focus on business behavior rather than infrastructure concerns such as persistence.

If PI is preferred, why do most hand rolled data access layers use PA?

In my experience, people usually prefer PA because it makes lazy loading extremely easy. The typical pattern is to hit the database when a property is accessed and its backing field is null. This is a very easy pattern to understand, but unfortunately it sticks our entities with all of the overhead and complexity of persistence concerns.

Less Talk, More Rock!

Now that we have all the background out of the way, let’s take a look at an implementation I’ve tried recently that seems to work well and is very easy to understand. It comes down to two classes which are coordinated by the application's DAO classes. These two classes are:

LazyLoadingList<T> - This is a wrapper around List<T> which triggers a load whenever one of its methods is called.
LoadDelegate<T> - This is the delegate that is executed when a LazyLoadingList<T>’s load method is triggered.

Here is the code for the LazyLoadingList<T>:

public class LazyLoadingList<t> : IList<t>
{
 private List<t> _list;
 private LoadDelegate<t> _loadDelegate;

 public LazyLoadingList(LoadDelegate<t> loadDelegate)
 {
    _loadDelegate = loadDelegate;
 }

 public void Load()
 {
    _list = _loadDelegate().ToList();
    Loaded = true;
 }

 private bool Loaded { get; set; }

 private void LoadIfNotLoaded()
 {
    if (!Loaded)
    {
       Load();
    }
 }

 #region Implementation of IEnumerable

 public IEnumerator<t> GetEnumerator()
 {
    LoadIfNotLoaded();
    return _list.GetEnumerator();
 }

 IEnumerator IEnumerable.GetEnumerator()
 {
    LoadIfNotLoaded();
    return _list.GetEnumerator();
 }

 #endregion

 #region Implementation of ICollection<t>

 public void Add(T item)
 {
    LoadIfNotLoaded();
    _list.Add(item);
 }

 public void Clear()
 {
    LoadIfNotLoaded();
    _list.Clear();
 }

 public bool Contains(T item)
 {
    LoadIfNotLoaded();
    return _list.Contains(item);
 }

 public void CopyTo(T[] array, int arrayIndex)
 {
    LoadIfNotLoaded();
    _list.CopyTo(array, arrayIndex);
 }

 public bool Remove(T item)
 {
    LoadIfNotLoaded();
    return _list.Remove(item);
 }

 public int Count
 {
    get
    {
       LoadIfNotLoaded();
       return _list.Count;
    }
 }

 public bool IsReadOnly
 {
    get
    {
       LoadIfNotLoaded();
       return ((ICollection<t>)_list).IsReadOnly;
    }
 }

 #endregion

 #region Implementation of IList<t>

 public int IndexOf(T item)
 {
    LoadIfNotLoaded();
    return _list.IndexOf(item);
 }

 public void Insert(int index, T item)
 {
    LoadIfNotLoaded();
    _list.Insert(index, item);
 }

 public void RemoveAt(int index)
 {
    LoadIfNotLoaded();
    _list.RemoveAt(index);
 }

 public T this[int index]
 {
    get
    {
       LoadIfNotLoaded();
       return _list[index];
    }
    set
    {
       LoadIfNotLoaded();
       _list[index] = value;
    }
 }

 #endregion
}

Here is the code for the LoadDelegate

public delegate IEnumerable<t> LoadDelegate<t>();

The Demo

I’ve put a demo up on Github that ties this altogether. The project is organized as follows:

The Employee load delegate gets wired up in the Company DAO like so:

public class FakeCompanyDAO : ICompanyDAO
{
 List<company> _companiesInDatabase = new List<company>
 {
    new Company(){Name = "ACME"},
    new Company(){Name = "Hardees"}
 };

 #region Implementation of ICompanyDAO

 public Company GetByName(string name)
 {
    // Pretend we are calling / mapping from a store procedure
    var company = _companiesInDatabase.Where(x => x.Name == name).First();

    if(company != null)
    {
       company.Employees = new LazyLoadingList<employee>(
          () =>
             {
                var employeeDAL = new FakeEmployeeDAO();
         
                // To demonstrate when loading is happening
                Console.WriteLine("Loading Employees");

                return employeeDAL.GetByCompanyName(name);
             }
       );
    }

    return company;
 }

 #endregion
}

The Demo program code:

class Program
{
 static void Main(string[] args)
 {
    ICompanyDAO db = new FakeCompanyDAO();

    var company = db.GetByName("Hardees");

    Console.WriteLine("Company Loaded: " + company.Name);
    Console.WriteLine("About to iterate Employees");

    foreach(var emp in company.Employees)
    {
       Console.WriteLine(emp.Name);
    }
 }
}

The output:

Possible Improvements

There are many possible improvements to this strategy depending on how far one is willing to go. It would be very easy to auto wire up everything with one generic delegate if DAO semantics were uniform across DAOs etc…

Source code: http://github.com/dauger/BlogSamples/tree/master/LazyLoadingCollections/

UDPATE: This technique has been reworked for .NET 4.0 here.

Gnome Evolution’s Missing Feature

2010-01-09T21:43:00.001-06:00

Here is a screenshot of the Windows Live Email account setup:

Here is a screenshot of Thunderbird’s account setup:

Here is a screenshot of Gnome Evolution’s account setup:

Notice anything? Evolution does not give you the option to leave email on the server until you delete it. This will lead to an inbox management nightmare for those of use who multi-boot. Evolution is very nicely integrated into Ubuntu, but sadly I cannot use it because of this missing feature.

Having Ubuntu 9.10 WIFI Problems?

2009-11-01T00:15:00.001-05:00

Apparently the new version of Ubuntu broke compatibility with a lot of wifi adaptors, including some relatively new USB adaptors. If you have upgraded to 9.10 but are having problems seeing and/or connecting to your wireless network you may want to try the following:

1. Open the update manager
2. Click the settings button
3. Click the updates tab
4. Check the “Unsupported updates (karmic-backports)” checkbox
5. Open a terminal and type (and reboot):

sudo apt-get install linux-backports-modules-karmic

NHibernate 2.1.1 GA Released!

2009-10-31T14:37:00.001-05:00

Fabio Maulo has announced the release of NHibernate 2.1.1 GA via Twitter.

Get the bits and/or code here:
http://sourceforge.net/projects/nhibernate/

Reactions to the Legacy Programmer Boss

2009-10-25T22:59:00.001-05:00

There have been a couple blog responses to my “Legacy Programmer Boss” post. The first was by Krishna Kumar and the second was by Mike Marshall. Both bloggers really ran with the idea and came up with some very thoughtful and constructive posts. I’m very happy that neither of them reacted to the term as if I meant it in a pejorative way. Although I was a bit miffed at Joel, I didn’t mean it to be a pejorative. A person’s focus and expertise shift as they advance in their career. That being the case, it’s up to each and everyone of us to use our brain when assimilating advice from our peers and superiors. We are all responsible for thinking critically about any advice we take, no matter who it is from.

Grow Your Shop’s Maturity by Managing up via New Blood.

2009-10-22T23:48:00.002-05:00

I work with a great team of people. Both of my managers used to sling code which is a godsend if you ever had to report under a person who hasn’t. I don’t have to convince them about the vagularities or the particulars surround about my craft etc… They inherently pad my estimates, or instinctually know what I mean when I say “this will be a hack that needs to be fixed in the next maintenance cycle” However, since they don’t code anymore, they can be skeptical (rightly so) of anything that happens in the industry post when they had their feet in the fire and may veto ideas that were out of reach when they were fighting the flames.

When I joined the organization about 6 years ago, I took a look at the build process, I said: 1) All builds need to be done from the same machine (not individual developer machines) and 2) the builds and possibly the deployments need to be automated.

When I joined and espoused these ideas we had severe build / deployment pain due to the manual process, but from management’s perspective, automated builds and deployments seemed too bleeding edge or too costly to implement.

Time went on; the pain continued for years. I repeated my opinion several times a year.

Eventually the economy tanked. We were in the position to hire new blood (both consultants and full-timers). I was fortunate enough to be either a part of the interview panel or have input on the “desired skills” of the want ads. Each time we interviewed new full-timers or consultants I specifically looked for people who had skills we required AND skills we didn’t have as an organization but I thought we needed.

Over time, more and more people said: “we should automate the build!” Many voices are louder than one voice.

We are now trying to automate the build.

Thank you new blood.

In Response to: “Where is C# in the Programming Language Lifecycle?”

2009-10-22T22:04:00.002-05:00

K. Scott Allen raises an interesting question when he asks “Where is C# in the Programming Language Lifecycle?”

The nearly 8 year production life of C# has been very interesting. As a former Java 1 / Java 2 developer I can honestly say that C# started out looking a lot like Java. However, it has evolved into its own over the years. Point in case: I recently wrote a framework that heavily leveraged the things introduced in .NET 2 and beyond (generics, lambdas, linq to objects, nullables, anonymous types, etc). Looking at the code, it barely resembles the C# we all wrote in the past and what the majority of C# coders are still writing. In fact it is rather illegible if you only know C# 1.x and semi-legible if you know C# 2.0. It seems that C# managed to become something else without bothering anyone who didn’t care to notice.

Although C# has successfully managed to be a shape-shifter in the ever evolving world of language trends, I think K. Scott Allen is onto something when he questions whether or not C# will continue to thrive in the multi-threaded / multi-CPU world. I have a hunch that C# may remain a first class language if the single threaded / parallel language interop pans out in an easy fashion. I think C# (and VB) will remain to be the best way to model a domain and perform OOP in the Microsoft world, but perhaps other languages will advance to be the main application control / host languages. If the interop story goes South, people will choose something else.

All that being said - how much change can a language go through before it falls under the weight of shims that allowed it to grow outside of its initial design? Eventually the need to implement a hot feature to keep the language popular could undermine the language. I do have to admit however, that the C# team seems to have managed to truly extend the language rather than shim it or fake it to get new features in. The way generics were introduced really allowed the 3.0 / 3.5 features to be added in a way that isn’t dissonant with the original base language. Anders and co. basically put in the the genetic possibility of growing another limb of indeterminate descent without disrupting the body.

So what is my answer to the original question? C# has definitely hit maturity. Based off of the trends I am seeing in online code samples and forum questions, I think C# as it was in .net 1.0/1.1 timeframe is on the verge of decay as 3.5# semantics are probably just past the adoption/acceptance stage.

The State of Spolsky or: How I Learned to Ignore the Legacy Programmer Boss.

2009-10-07T22:33:00.026-05:00

If you don’t know who Joel Spolsky is, you can probably pass on this blog entry. I have a ton of respect for Joel. I’ve learned a lot from his posts over the years, and I still consider him to be a guru in the business of software. I’m sure I'll continue to learn from him yet.

In recent weeks, Joel has made some controversial posts regarding what many people think are the hallmarks of modern programming (design patterns, TDD, IoC, etc…). In this blog post, Joel espouses the ethic of the “Duct Tape Programmer”. In this stackoverflow.com answer he has this to say about IoC:

IoC containers take a simple, elegant, and useful concept, and make it something you have to study for two days with a 200-page manual.

I personally am perplexed at how the IoC community took a beautiful, elegant article by Martin Fowler and turned it into a bunch of complex frameworks typically with 200-300 page manuals.

I try not to be judgemental (HAHA!), but I think that people who use IoC containers are (A) very smart and (B) lacking in empathy for people who aren't as smart as they are. Everything makes perfect sense to them, so they have trouble understanding that many ordinary programmers will find the concepts confusing. It's the curse of knowledge. The people who understand IoC containers have trouble believing that there are people who don't understand it.

The most valuable benefit of using an IoC container is that you can have a configuration switch in one place which lets you change between, say, test mode and production mode. For example, suppose you have two versions of your database access classes... one version which logged aggressively and did a lot of validation, which you used during development, and another version without logging or validation that was screamingly fast for production. It is nice to be able to switch between them in one place. On the other hand, this is a fairly trivial problem easily handled in a simpler way without the complexity of IoC containers.

I believe that if you use IoC containers, your code becomes, frankly, a lot harder to read. The number of places you have to look at to figure out what the code is trying to do goes up by at least one. And somewhere in heaven an angel cries out.

I see two things happening here:

Joel continues his (very worthwhile IMHO) crusade against the “Architecture Astronaut” who is so far into the clouds that they aren’t writing code anymore but think they should tell people how to code, and the “shiny new toy” developers who have a solution looking for a problem. I’ve had very painful experiences with both of these archetypes.
Joel inadvertently enters “Legacy Programmer Boss” territory as he discounts mainstream changes in programming that have happened since he stopped coding as his primary job.

The Legacy Programmer Boss is the manager who had a successful programming career in the past but sees many modern concepts as language baubles, academics, and anti-patterns because they are out of the loop. The fact that they once had a high degree of expertise gives them confidence in making mis-judgements.

There was a point in time where “design patterns” where purely academic. However now-a-days many design patterns have become as ubiquitous as the FOR loop (that was the idea behind defining these patterns). IoC is not difficult to understand by any developer who can understand the factory pattern. Frankly, the average developer can go to 0 – 60 with IoC by watching a 22 minute video from David Hayden. If a developer cannot understand the factory pattern, then they are doomed to be a duct tape programmer. I’ve worked with many duct tape programmers, and over time their code requires more duct tape.

Joel is justified in his efforts to decry the Architecture Astronaut, but his Duct Tape Programmer is just as bad. After years of experience in the field, I think Uncle Bob’s Clean Coder / Software Craftsman is the happy medium.

If you write software for a living, you should keep up with the current practices and use them as you see fit. If you see your opinion in the minority, you are either a genius, an early adoptor, or wrong.

This blog will be a’changin’

2009-10-03T00:14:00.008-05:00

Until now, this blog has been primarily focused on retro-gaming / retro-computing. I plan on expanding it in the very near future to include .NET development, slice of life, and some music / media related content.

Things in the works:

~~Rework the theme to be wide enough for code.~~ (DONE 10/3)
~~Reorganize tags~~ (DONE 10/3)
~~Add RSS feeds based on tags so people can ignore the topics they don’t care about.~~ (DONE 10/3)
Possibly move to a hosted Wordpress install on my Webhost4life site. I really haven’t made up my mind about this yet.

Vectrex

2009-10-01T23:41:00.007-05:00

I finally got my hands on a Vectrex via ebay complete with 12 games, manuals, and overlays. My neighbor had one of these when I was a kid, and I've seriously been lusting after it ever since. I spent many hours playing Scramble and Star Trek on one of these in my youth.

The Vectrex has to be one of the most unique early 80s game systems. It's a vector graphics based console that came with its own CRT monitor. It had one built-in game (Minestorm) and a cartridge slot for purchased games. The screen displayed black and white vector graphics but used transparent overlays that were placed on the screen to add color and other graphical elements. In my opinion, it remains the best way to recreate vector graphics arcade games at home. Emulation is great, but nothing can beat seeing these graphics on a CRT.

Here is the system I acquired:

My camera's autofocus had a hell of a time dealing with the CRT's refresh rate. It tended to snap some trippy pictures. Here is the cleanest picture I could snap of Minestorm in action:

Here is one of the trippier interpretations my camera made of Minestorm:

If you are a fan of vector graphics, but are unfamiliar with the vectrex, you owe yourself a peek at the following video from Classic Game Room:

Here is a great retrospective video of several classic Vectrex games. This video is done via an emulator and I'll think you'll see that quite a bit of sparkle is missing. It's still cool nonetheless.

Finally, just to prove that the Vectrex was the shizzle back in the day:

Autoduel

2009-08-31T16:58:00.015-05:00

For those who aren't familiar with this game, Autoduel is a classic computer strategy/RPG conversion of the Car Wars table top game. I've been hunting for an affordable good condition copy of Autoduel for quite some time now. One with a decent BIN price showed up on ebay late last week. I couldn't resist. I used to have this as a kid and I wanted to get a physical copy back into my collection. The awesome box art and cool map that comes with the game make this worth having.

Coincidentally, this week's episode of Matt Chat is on none other than Autoduel!

The Mouse's Reprieve

2009-07-08T22:23:00.004-05:00

When I arrived home from work this evening, I was greeted by an odd clickety clack sound. A quick glance around the kitchen revealed this:

Apparently a mouse had got itself caught in a trap I had set out, but only by its arm. The mouse then ran around the side of the refrigerator (pooping several times apparently) and squeezed inside the refrigerator's vent cover. I initially tried to pull the mouse out of the slot it crawled into, but it emitted a pitiful squeak. I ended up taking the cover off and letting it go outside. It took off ok, so I'm sure I'll be seeing it in my kitchen again soon. Next time it may not be so lucky.

Hello C64 From Ebay. Will You Be My PAL?

2009-06-15T22:46:00.007-05:00

I finally managed to get my hands on a PAL C64. It came with a light gun, tension adjustable joystick, Datasette, and several games on tape. I have a NTSC/PAL S-Video to VGA converter box, but unfortunately the results were pretty horrible. I'm going to have to get myself a PAL capable monitor ASAP.

Breadbox64 - The Commodore 64 Twitter Client

2009-06-12T00:13:00.011-05:00

As unbelievable as it may sound, there is now a Twitter client for the C64. It is called Breadbox64 and it was written by Johan Van den Brande. It is built on top of the Contiki network stack and requires a RR-Net compatible Ethernet card.

I have sent my first tweet from my C64 and it was good.

If you don't believe me, see for yourself. Here is a video from the author of the software:

Did You Know That New Games Are Still Being Released For The Commodore 64?

2009-05-14T23:52:00.007-05:00

It may surprise you to read this, but the venerable Commodore 64 is still getting new commercial game releases in this day and age. Although 99.99999% of the software industry left the C64 behind in the early 90s, there are a few independent developers and publishers here and there that still put out releases. One such label is Psytronik Software. Psytronic specializes in creative conversions and re-releases of classic 8 bit hits, and the development of new titles. Their most recent project, "Knight'n'Grail" has been getting a lot of positive buzz in the C64 community, and all indications point to the possibility of an instant classic. Check out this pre-release video:

More information about Knight'n'Grail can be found here:
http://psytronik.blogspot.com/2009/04/quest-for-holy-grail.html
http://www.binaryzone.org/retrostore/index.php?main_page=product_info&products_id=473

I've Got Pac-Man Fever

2009-05-11T21:56:00.009-05:00

If you grew up in the Atari age you'll undoubtedly remember the top-ten hit Pac-Man Fever. Pac-Man Fever was a single (1981) and album (1982) by recording artists Buckner & Garcia.

My fiancee happened to have a copy of the 1982 album which I've become rather reattached to since I recently got a Technics SL-1200MK2 Turntable. If you like Weird Al, you may find this album to be liquid crack. Unfortunately her copy has all signs of being owned by a child back in the day, so I set out on a hunt to get an archivable copy. Of course, the first thing I did was look to see if it made it to CD. I found it had been released on CD as a rerecording. Sadly the rerecording just doesn't do it for those nostalgic memories as the voices have aged and the original sound effects were not able to be re-licensed. Luckily I was able to import a "sealed" copy via gemm.com. It arrived from a record shop in Italy still in its wrap, but the seal was not 100% unbroken. Therefore, it had some mold/mildew on it that creeped in over the years, but otherwise it was untouched. I've managed to clean it up and I hope to digitally archive it ASAP.

Track listing

"Pac-Man Fever" (Pac-Man)
"Froggy's Lament" (Frogger)
"Ode to a Centipede" (Centipede)
"Do the Donkey Kong" (Donkey Kong)
"Hyperspace" (Asteroids)
"The Defender" (Defender)
"Mouse Trap" (Mouse Trap)
"Goin' Berzerk" (Berzerk)

Yes, I'm a Cultist.

2009-05-05T22:08:00.005-05:00

According to Infoworld.com, I'm a member of one of the biggest tech cults of all time:
http://www.infoworld.com/d/adventures-in-it/true-believers-biggest-cults-in-tech-433?page=0,4

New Goodies

2008-10-24T18:31:00.006-05:00

A few new goodies have shown up over the past few weeks.

First up is a copy of Elementary Commodore 64. This book is very unique because the book is littered with some very trippy 80s artwork interpretations of computer language concepts. I may devote a future post to the artwork in this book since I didn't have time to take many photos today.

My 1541ultimate with Ethernet arrived last week. This is an amazing cartridge which offers full 1541 emulation while reading/writing to a SD card. It even has an audio out which sends audio that mimics the sound of a 1541. It also has a flashable cartridge ROM and many other very cool features. The current feature set can be found here. Apparently SuperCPU emulation is coming soon too, which is something I am very excited about.

Other notable recent items include a pleather dust cover for my main 1541 and JiffyDOS sets for 2 of my C64s, 1 1541, and 1 1541 II.

The Kindness of Strangers Near and Far

2008-10-24T17:04:00.006-05:00

Last night I received a private message from a fellow lemoner who lives in the Toronto area that the Peggy Kelly Media Arts Studios had a Commodore 64, Commodore 1702 monitor, Commodore 1541 floppy drive, and a Star SL-10C printer that they were trying to find a home for. The manager of this arts center had posted to a mailing list that my internet acquaintance reads. Thankfully he remembered that I live in Saint Paul, MN.

I left a message with the arts center last night to let them know that I was interested. I received a call this morning that I could come and pick it up. Since I had the day off, I decided to make the drive across the metro area to save these retro goodies from ending up in a landfill. While I was there, I was shown around the the studio. The studio has a training area for electronic media production, a photography studio, a media conversion room (photos/VHS/Film to DVD, PAL to NTSC conversion, etc...), and a sound booth/audio recording facility. The art center that houses this studio also has an art gallery, coffee shop, and a shop with jewelry and other crafted items. The center is located in Edina and I recommend any readers in the area to check it out.

My thanks go out to both Golan and Phil for their kindness.

... and of course, the obligatory photos:

As you can see, both the printer and the drive appear to have never been used. The monitor is lightly used and in good condition. The tube appears to be in better shape than the 1702 that I've been using over the past year. The C64 is in good cosmetic condition, but unfortunately it boots to a blank screen. This is a very common issue with C64s that can be caused by several different failures that are usually easy to fix. I have a stack of dead C64s that I can use for parts, so I am pretty sure I can bring this one back to life with a chip swap or two.

The History of the Commodore 64 VH1/I Love the 80s Style

2008-08-25T19:14:00.011-05:00

I stumbled across the following rather entertaining video via the following blog post: http://www.bebizzy.com/blog/?p=233

Asheron's Call 100th Update Goes Live August 26th

2008-08-25T17:26:00.008-05:00

As reported in June, August brings the 100th content update to the venerable MMO, Asheron's Call. The game servers will go down on August 26th at 7am Eastern time for the update. When they come back up at 2pm, users will be greeted with a slew of new content and functionality which is outlined in the update's release notes. In a recent video interview, AC Community Manager Andy Cataldo revealed that this update will be about the size of a retail expansion pack.

Highlights include:

Three lore-related player/creature factions (Good/Neutral/Evil)

PvP/Faction land control over two new PK Towns

New Loot Tier

Level 8 Spells

A new landmass called Freebooter Isle, a new area called the Moarsman City, and the expansion of the already existing Graveyard area.

More information can be found at: http://ac.turbine.com

My Unfinished PC Game Wall of Shame

2008-07-25T01:01:00.013-05:00

My top three hobbies are currently the following:

1. Playing Guitar
2. Computer Programming/Software Development
3. PC Gaming

All three of these are time consuming hobbies, which unfortunately means that I don't have a whole lot of time to devote to gaming during the average work week. This became all too obvious to me after I beat Bioshock two days ago. I began playing Bioshock on 3/2/2008 and finished it on 7/23/2008. It took me nearly 5 months to make it through a 40 hour game. Oddly enough, I plowed through the 2nd 20 hours of the game over the span of three days this week. I'm currently on a two week staycation at the moment so I have a lot of extra time to burn on video games.

Since I had finally finished Bioshock, I began looking for the game that I would tackle next. Finding a game to play from my current collection is not a difficult task. Apparently over the years I've become very good at buying games and either never playing them or never finishing them for various reasons.

Ladies and Gentlemen, I offer to you my unfinished PC game wall of shame:

From left-to-right and row-by-row starting at the top:

Oblivion/Shivering Isles/Knights of the Nine
I began playing this but quit early on because my previous computer was not quite beefy enough.

Call of Cthulu: The Dark Corners of the Earth
I made it about halfway through this. My save games were lost in a hard drive crash.

Diablo II: Lord of Destruction
I recently found this in the bargain bin for $10. However, I'm not really sure I want to play all the way through Diablo II again to get to the expansion material.

The Orange Box (Half Life 2 + Episodes 1 & 2, Team Fortress 2, Portal)
I have not played this yet except for taking a quick peak at Portal. I should note that I have not played Half Life 2 before either.

The Witcher
I made it through the first couple chapters of the game, but I immediately quit playing when I heard about the enhanced edition patch that is due out in September.

Unreal Tournament III
I'll be frank. I think the single player campaign is laughable. I quit after about 5 missions.

Unreal II
My PC was a little too weak when I originally tried this one.

Neverwinter Knights
The single player campaign was pretty bad. I quit about 20 hours into it.

Fallout 1/2/Tactics
I just bought this recently and I have not started it yet.

Wheel of Time
My PC was too wimpy when it came out.

Deus Ex
I don't remember why I never finished this one. I remember liking it quite a bit.

Vampire the Masquerade
I think I ran into a show stopper bug, but my memory is a little foggy here.

Doom 3
PC was too wimpy.

Morrowind/Tribunal/Bloodmoon
PC was too wimpy.

Thief
This came with a video card. I have never given it a fair shake.

Baldur's Gate/Tales of the Sword Coast
I never finished this game due to a really stupid blunder on my part. I spent roughly 200 hours playing Baldur's Gate. I purchased the expansion when I was in the last battle of the game. I installed the expansion without backing up my saves. Unfortunately, the expansion just adds some more material to the original story line and raises the difficulty of the last battle quite a bit because they expect that your party will be at a higher level due to the expansion. Unfortunately where my saves were, I could not exit the final battle to go get more experience. Therefore I was trapped in an impossible battle.

Rune
I lost my save games in a hard drive crash.

So the question becomes: what should I play next? I'm leaning towards Oblivion.

Infocom Aquisitions Round 4

2008-07-10T23:25:00.007-05:00

I'm getting fairly close to having a complete collection of Infocom titles excluding the later years after the brand was purchased. I hope to have a more comprehensive post about this soon, but in the meantime here is what arrived since my last post on the subject:

Round Three
Round Two
Round One

Infocom Aquisitions Round 3

2008-06-25T23:54:00.007-05:00

It turns out that I am still collecting Infocom titles. Here are the recent arrivals.

I managed to get my hands on another "big box" package like I did for Sorcerer.

Unfortunately, like my copy of Stationfall, Planetfall turned out to be a bit of a dud as the box is in poor shape and it is missing some feelies.

I'm pretty excited about this one because I never played it back in the day and I am a Sherlock Holmes fan. Also, as an added bonus, it is sealed.

Random Acquisitions

2008-06-25T23:01:00.006-05:00

I've collected a few notable items over the past couple weeks, all of which are a lot of fun.

I'm still working on building up a comprehensive C64 book library. Here is my latest addition:

The second Commodore 64 related item this week is a game that is near and dear to my geek heart. This is the first game I ever played that attempted to translate the pen and paper experience to the computer screen.

The third Commodore 64 related item that arrived is a HardSID4U device. This is a little usb device that houses four Commodore 64 sound chips which are known as the Sound Interface Device. This unit can be used to give you authentic sound when using an emulator, however it's primary design is to be a synth device that can be controlled by modern recording software and can be used in music production.

Finally, here is something to help me ramp up for Fallout 3.

Infocom Acquisitions Round 2

2008-05-31T18:08:00.008-05:00

Here's what I've accumulated via ebay and Amazon on the Infocom front since round 1.

I am especially fond of this last one. I purchased it used on Amazon and had no idea it wasn't going to be the standard grey box edition. Heck, I didn't even know there was a folio version.

Infocom Acquisitions Round 1

2008-05-14T23:22:00.005-05:00

New In box 1541 II and Other Goodies Arrive

2008-05-14T23:14:00.009-05:00

What better to match my NIB C64C than a matching drive?

New Old Stock In-Box C64C Arrives

2008-04-28T22:03:00.017-05:00

As stated in my previous blog, I always wanted a C64C when I was a kid. Someone on ebay happened to be selling one that had never been used. I was a little skeptical of that claim when I purchased it, but from what I can tell upon inspection, it does seem to be 100% mint. All of the cables were still wrapped in original plastic with aged looking tape. The manuals were all sealed, and the computer itself did not have a spot of dust on it or in it. All connectors and slots appear to be virgin.

Without further ado:

Needless to say, while I was opening everything up, I felt like a kid on Christmas day.

Raymond Computer, St Paul, MN

2008-04-26T01:11:00.011-05:00

I've driven by the place probably 1000 times in my life because I've been in various bands that have rented rehearsal spaces near his shop. Finally a few months ago I noticed the Commodore logo in the window. Today I decided to peek my head in there since I'm currently on the prowl for a few things.

OH MY GOD! This place is a Commodork's dream come true. Here's a photoshoot of the place thanks to Lemoner Brian Day:
http://www.flickr.com/photos/24965817@N02/sets/72157604224011802/

Those photos only do the shop partial justice because they can't really capture the full glory and size of the space. I think there are 3 rooms total. The entry way is roughly 12x12ft, and then there is another room roughly the same size. Then there is a much larger space in the back (20x 20ft?) which appears to be the workshop area. That is also where the point of sale terminal is (a c64 and dot matrix printer). Every square inch of this place is covered in goodies.

As the photos show, there is way too much stuff to take in, but I did notice ample amounts of commodores (vics, 64s, 128s, and Amigas), plus all of the displays, printers, and other peripherals you could care to shake a stick at. Also, there was a ton of software (opened and unopened), plus a good shelf of books, and a magazine rack filled with gems.

I was in a little bit of a hurry, but I was able to spend some time talking with the owner. He seems like a really interesting fellow who obviously has a vast knowledge of Commodores. He has most of the common stuff you'd find on Ebay, oldsoftware.com, and cmdrkey. His pricing seems to be pretty fair as well. I doubt he can keep his website in check with his inventory so if you are ever looking for something and it's not on his site, fire him off an email. He ships internationally and does repairs.

Let me tell you, going into that place was much more fun than scrounging ebay. I left there with a 1702 and a geek buzz.

http://www.raycomp.com/
raycomp@visi.com

Commodore 64 Tax Refund Revival

2008-04-20T22:55:00.006-05:00

I am 32 years old at the time of writing this blog. I make my living as a computer programmer. I got my start at programming when my father purchased a C64 at a COMBS outlet store (COMBS became LeBelle's, which became Best Buy) after a coworker had informed him that their POS terminal was mismarking a full C64+Monitor+1571 Drive at $19.95. My best guess is that this was around 1982 or 1983. My C64 was my best friend from 1982 until 1992 when my family eventually got with the times and bought a PC.

Thanks to the 2008 IRS economic stimulus package, I've decided to whole heartedly reclaim my love for the c64. Here is what I have purchased over the week via the interwebs:

Books:
All About the Commodore 64 Volume 1
All About the Commodore 64 Volume 2

I also picked up THE c64 programming guide:

Media:
The C64 uses double-sided, double-density 5.25 " disks which aren't in production anymore, so I'll have to start stockpiling them. I've got my eyes on a large unopened stock on ebay, but here is what will get me by in the meantime:

Hardware:

Of course I'm going to need a C64 and Disk drive right? That being the case I picked up a classic C64

I was always jealous of my neighbor who eventually got the C64C with the improved ergonomics and sound chip, so I got one of those too, which happens to be a never used new in box find (oh yeah!!!):

And of course, there is the mandatory FastLoad cartridge:

Here's a little device that will allow me to hook the c64 drives up to my PC so I can transfer software I download from the internet to the c64 floppy drive:

Finally, a little something to turn my girlfriend's head: