Mad, Beautiful Ideas
Boise Code Camp 2010

This last weekend marked the third year I've been able to attend the Boise Code Camp, an excellent developer-focused, community run event help each spring in Boise, ID. This has, in the past, been the largest code-camp event of the year in our region, but it's numbers were down this year, probably in part because of the Utah Code Camp (link is to their HTML version, the Silverlight Version hangs my machine. Unsure if that's an issue with moonlight, or my box) was held on day one of the event, which prevented some people who may have come up to Boise before from coming up this year.

We've noticed that this year is really heavy with Code Camp events in the Spring, with Boise's having just finished, Seattle's the weekend after next, and Portland about five weeks after that. For this reason, our own Palouse Code Camp, won't be held until September, though we'll need to work with Utah to ensure we don't schedule for the same weekend.

Despite the lower turnout than in years past, it was still a fantastic event. With some fantastic sessions. As usual, if I have any complaint with Code Camp, it's simply that they do tend to focus on Microsoft technologies (though they don't have to), and Microsoft stack developers tend to be really focused on what exists within that stack. Or, at least, they mostly only know much about what's in that stack. Of course, I didn't put together my YUI3 talk, so I can't complain about all the jQuery talks too loudly, but I will have such a presentation for the Palouse event in September.

Some of the sessions I went to, I didn't get as much out of as I would have liked. I began my first day, hoping to learn about using CouchDB in C#. Unfortunately for me, the talk was more an intro to CouchDB in general, but I did learn a bit, and was able to contribute to some discussion about the benefits of NoSQL (though we didn't touch on the possible harm). Then, I went to a talk live-demoing web application vulnerabilities, which keyed me in to a few tools, but ended up being more basic than I had hoped. Also on the first day were a few talks on Progressive JavaScript by a person who didn't seem as keyed into the topic as I had hoped, even going so far as to claim that 'there are no JavaScript-only developers'. Admittedly, most developers don't get to focus solely on the JavaScript side of front-end engineering, but there are plenty who do, and they spend a lot of time working to promote professional-grade JavaScript practices. I do think others got stuff out of the talk, but for me, it was two sessions almost entirely wasted.

The best talk I attended on Saturday, was, by far, Chris Billson's "Powershell for Production Programmers" presentation. Powershell is basically a UNIX-like shell for Windows, where commands (and commandlets) can return .NET objects instead of just strings. Imagine a shell where you can pipe the output of ls to another program to easily filter out things based on file attributes, while being able to access those attributes as object properties instead of parsing strings by hand. I really want a python-based UNIX shell that can pipe around python objects instead of just strings now.

Powershell has some warts, which I'll expound upon at a later time, but for the most part, it's an awesome technology.

Sunday, I learned about Django, and some of what's been added since 1.0, and about the south module, which provides truly awesome schema migration. South alone was enough reason to attend this presentation, and I really need to find something to with Django soon.

Finally, the last session I attended was from Microsoft MVP Craig Berntson, on what to do now that you've got Continuous Integration up and running. Namely, he wanted to discuss setting up StyleCop and FxCop, both of which I've looked at to integrate into our own CI build process (though I'm likely to use Gendarme instead of FxCop).

Automating things in your build to tell you about potential code 'smells' is possibly even more important that running automated unit tests, but most people just stop about the unit tests. Admittedly, StyleCop and Gendarme have a lot to complain about in our codebase right now, but that's largely because we haven't identified which rules we want to ignore. By integrating this into our build, we'll be forced to start taking action (whether to ignore or fix), and then we can make these issues actual errors, instead of being too afraid to apply these tools.

I've got some posts coming on some of this tech that we covered, and how we're integrating it into our environment. And there were some awesome sessions I wasn't able to go to, like on the new version of Entity Framework, which might actually get us off of LINQ-to-SQL.

Our next code camp will most likely be the one in Portland, but Seattle is a possibility as well (it's just so soon...). If you're in a region that has a code camp within a few hours, I absolutely suggest going. There is a lot to be learned.