PhatBoyG.com

After a great weekend in Seattle for the ALT.NET Open Spaces event (aside from a slight error in judgement on Friday night as depicted in this blog post), the two coworkers and I discussed how we could bring the experience of Open Spaces back to the team in Tulsa. We decided that instead of just giving a few talks about some of the things we took away from Seattle, we would bring the experience itself to the team.

At the end of our team meeting on Monday, we laid out some paper and pens and asked members of the team to write up topics that they wanted to discuss. It started a bit slow, but within minutes we had eighteen topics on the wall. The variety of topics was excellent, most of which targeted a different subset of the team. It was great to see the team come up with such a nice list of things for the team to discuss.

We then drew a grid of time slots on the whiteboard and asked the team to put their initials on the topics they wanted to attend. As the papers filled up, we started aligning them into the grid based on popularity and expected duration. We tried to keep all of them to an hour but some of the topics were given ninety minutes based on the content.

We had to negotiate on some of the topics to fit our time slots, and combined a couple of similar discussions into the same time period so that we could maximize our coverage over the next few days. Some topics were brought up that are timely to an upcoming release of our software, so those were given a slight priority in the schedule.

Overall, I was very impressed with the contributions by the team. Topics included things like “maximizing the use of Resharper”, “What are unit tests”, and “How can we test better?” With the large number of topics on the schedule, we’re hoping that we can set aside a couple of days a week (maybe Tuesday and Thursday over lunch) to continue with more discussions. I’ll be sure to post a follow up as things unfold over the next week.

While I’m trying to keep my posts at pace with the event here in Seattle, it gets harder as more attendees arrive. Yesterday, Evan Hoff showed up and we took another trip down to Pike Place Market for some food and festivities. After an afternoon of good conversation, we went to Kells Irish Pub to meet up with Ayende and Udi (along with some other folks) to talk about software architecture.

The variance in perspective between different architects is always interesting, and this meeting did not disappoint. Recognizing the strong points in each design style was helpful by understanding the background of each approach. I’m looking forward to more of that this weekend.

The weather turned completely crappy today (technical term, sorry), as it is cold and wet. We still managed to run about and snag some chow before things get fired up tonight. A pretty solid crowd is overflowing the lounge in the hotel and you can tell there is some energy building.

We’re about to head that way to get the final things wrapped up and organized. Look for more later tonight (or tomorrow if the talks get deep)!

I arrived in Seattle today to get warmed up for the ALT.NET Seattle conference this weekend. I came up a couple of days early to meet with a few people before the event started on Friday.

Once we landed, our first trip was to the Pike Place Market, which is right on the shore of the Peugeot Sound. We had lunch at a great chowder house, followed by a coffee at the original Starbucks coffee shop. After the food and drink stop, we walked around the market and stopped at an REI outfitters (like a Bass Pro without all the hunting gear) since Dru forgot his jacket in Kansas. As we left the store, the sun came out and it was really too warm for a jacket — such is luck. So we got back in the car and drove to a mini-mart to get some Monster to fuel the next few days, after which we parked downtown and walked to the Westin to meet up with some guys.

When we got to the Westin, we met up with Nick Parker to talk about various open source .NET projects that are active. After a while, Greg Young joined us and shared his understanding of how messaging applications should work and gave us some tips from his experiences using various forms of message transportation. The discussions started off general and got more specific as we talked about particular scenarios within our applications.

Since Dru Sellers and I both work on MassTransit and both use it in our commercial applications, it was very helpful to get feedback on this key infrastructure component. What we found is that while we have a pretty solid start, there are a few clarifying points that will help elevate the platform to be even less complex while adding new functionality. We came away with a lot of good ideas (and some diagrams, which David Laribee never actually witnessed being drawn) that we will probably explore over the next day or two.

After a few beers and some good discussion, the MVPs kicked over to the evening party that MS had arranged, so Dru and I went to dinner and drove out to the hotel.

Tomorrow should be an interesting day as we try to lay down some of the things we talked about tonight into code. We also have a very exciting dinner planned for tomorrow night, but I’ll save that for another post later in the week.

While the MVPs descend upon Seattle for the 2008 MVP Summit, I’m getting ready to head to Seattle for the ALT.NET Open Spaces Conference this coming weekend. Many of the people attending the ALT.NET conference are also MVPs, so there are likely to be some tired folks by the end of this week(end).

Based on the experience I had in Austin at the first ALT.NET conference, my company has agreed to send me to Seattle along with a couple of coworkers. A fellow developer and our agile project manager are going along to share in the experience and join the conversation. As an organization, we’ve seen many improvements since converting to agile development (XP-style) and I’m hoping the conference will help identify some new ways to help us grow and educate the rest of the team.

From a project perspective, Dru Sellers and I are trying to wrap up a 0.1 release of MassTransit in time for the event. We’re hoping to be able to share some of what we’ve done with others who are approaching a distributed application architecture, and even more importantly learn from others with similar experience so that we can improve MassTransit and add some new routing and management features. We’re getting there a couple of days early to have some time to pair up and knock out a few last minute tweaks before calling it good.

I’m looking forward to seeing a lot of the friends I met at the first event, as well as making some new friends. I’m excited to have “Doc” facilitating the event, his coordination of the first event was an inspiration at the start of each gathering (regardless of how many beers were consumed the night before).

As the event unfolds, I’ll be adding pictures to a web gallery for the event. Be sure to check it out (or add a subscription to the feed) if you weren’t able to attend in person. I’m sure there will be plenty of tweets as well, along with an RSS feed overload after every gathering.

I came up with this a month or two ago, but finally decided to share it. While working on Mass Transit, I was joking with Dru Sellers about how nice it was to have really good test coverage when making design changes to some all-new development code. I’ve had very limited opportunity for a completely new projected started purely from unit tests, so I was just impressed at how easy it was to make code changes knowing that a passing set of tests meant all was well in the world.

You see, not all parking lots are paved with quality asphalt, generally flat, and void of any obstructions like islands and lights (see my other hobby). At work, our application is a lot of vintage C++ code, a ton of stored procedures packed to the hilt with domain logic, and nearly zero percent unit test coverage. Since adapting agile development, it is something that has been missing from our process. In our latest iteration, we’ve started using unit tests (with NUnit) to design our interfaces and classes. At the same time, we’re integrating Mass Transit to support the loosely coupled layer of application services (which include object translation, communication with high-latency remote systems, and lazy auditing of transactions). Aside from a few basic web services to support remote client application support tools, this is the first C#/.NET development that is being done as part of the main application.

So back to our story, my first project with really good test coverage exposed me to a lot of new things. From a TDD perspective, I’d read about it, used it to build some basic tests for various classes, and thought I had a pretty decent understanding of it. In this new project, I also learned how to use Rhino.Mocks (which took the test run time from 40-50 seconds down to 1.83 seconds on average), a very powerful tool for making an interface behave as you would expect an implementation of that interface to behave. The use of mocks has really helped me focus on actually writing tests and building a single class at a time. Prior to using mocks I would jump around creating additional classes as I defined new interfaces just to be able to continue writing my unit tests on the original class. By using a mock, I’m able to simulate the behavior of the other class without losing focus.

As my appreciation for TDD grew, I jokingly dropped a slogan into a chat window (using Skype, of course, aren’t you?):

I got a few chuckles, and thought it would make a great t-shirt to wear to tech events like code camps. So I threw together a quick online store so that I could order one for myself. I showed it to a few others (like Joe Ocampo, who suggested the slightly less offensive, yet subtly more suggestive variant) and decided to make it available to anyone that wanted one. So if you like it, grab one for yourself and maybe I’ll see you wearing it at ALT.NET Seattle!

It seems the MVC (model-view-controller) framework being added to ASP.NET has been released as a CTP.

There are a ton of posts about how to use the MVC, including a great series on Scott Gu’s Blog.

There, now I’m one of the thousands who probably blogged this today.