This post was originally published here.
The ALT.NET Conference is over, and I’m exhausted. I’ve never been to a conference that consistently challenged my assumptions about software development. The amount of dialogue and debate that occurred was quite staggering, considering that most involved were birds of a feather, and the possibility of echo-chamber issues would seem to be fairly high.
Open Space Format – Day 1
The conference was run in an Open Space format, which I’ve never been involved with before. No agenda was set before the first day, and no one was obligated to stay for an entire discussion. The conference started with a few ground rules and an explanation into Open Spaces, along with a short roundtable about the direction and purpose of the ALT.NET conference.
Between five and seven chairs were placed in the middle of the room. If you wanted to address the audience, you got up, sat in the chair, and said your piece. If you sat in the last available chair, someone else in the panel sat down. One chair was always available for someone to claim, and no one could talk in the audience. This provided a great continuous discussion for which anyone in the room could participate. Great questions and discussions centered around “What is ALT.NET?”, “Is ALT.NET divisive?”, “Is ALT.NET negative?”, and many others.
After this initial dialog, we proceeded to create the agenda. Those who wanted to talk about something wrote it down on one of the many post-it note pads scattered around the room, walking to the center of the room, and telling everyone what they wanted to convene about. Then they would put their post-it on an open space in the schedule at the front of the room. A long line formed for those proposing discussions next, and each put their post-its in an open slot in the schedule. When the spaces were filled, these post-its were put below where they could be sorted later. After all those that wanted to convene a discussion were through, all audience members were invited up to the schedule to initial post-it notes they found interesting. There around 6 or so rooms to convene discussions during each session, and all were filled by the end of the night.
Quite frankly, it was a astonishing that we went from no agenda to a very compelling one in about an hour with little or no planning or contention. But then again, this was my first Open Space conference.
The next morning, the schedule had gone through an iteration where many topics were consolidated, some were moved and some were removed based on the voting the previous night. Scott Guthrie’s MVC presentation was pushed back to accommodate the most audience members. No one needed to commit to any one topic per session, as they could use their own two feet to go to a different discussion.
First Session – Spreading passion and DSL’s
During the first session, I mostly attended a discussion concerning the problems of spreading passion and learning throughout the organization. Jean-Paul had some insight on inspiring passion, while Scott Hanselman mostly talked about making ALT.NET tools accessible. Dave Laribee talked about the importance of instilling values, but there was still a lot of negative vibes around the Morts. Mort’s shouldn’t be shunned or disdained, they should be embraced and included. The rest of the discussion concerned how to include Mort in the ALT.NET community.
Next, I headed to the DSL conversation that had folks like Martin Fowler, Scott Guthrie, Jeremy Miller and others. I only caught the tail end of the conversation, but Martin talked a little bit about the difficulties of fluent interfaces, the reasons behind them (no one knows yacc), and Scott mentioned that debugger visualizers can work around many of the pains of fluent interfaces. Fluent interfaces (as I ran into with NBehave) run into the issue where a continuous chain of method calls, no matter how you format it in the code, still turns into one line of executing code. If something fails and throws an exception, you don’t know what line it happens at and you can’t step into a specific method call. You have to step in and out of each fluent interface method call to get to whatever problem you have somewhere down the chain.
Martin again pointed out that this wouldn’t really be an issue if we just used true external DSLs and used tools like yacc or Boo to create them. Once you do that, however, you do lose much of the debugging support from Visual Studio.
Second Session – Intro to Boo and the BDD gauntlet
I hadn’t used a lot of Boo, and was very interested in the parsing and extension platform Boo provides. I’ve seen some work done on a Boo build system (BooBS, and don’t search for that one). That looked very intriguing to get rid a lot of the executable XML we have around in NAnt, MSBuild, XAML, Spring, and so on. Unfortunately, the discussion mostly covered the language features of Boo and not some of the more interesting core features of the Boo compiler, so I moved on to another session.
One of the newer topics in our space was BDD, which Scott Bellware convened a session on. However, when I walked into the room (with about 80 or so people in it), I saw Joe Ocampo in the center of the room and NBehave story definitions up on the projectors. Joe was taking a lot of heat from those in the audience questioning whether stories were BDD, whether executable stories were a good idea, and so on. I felt pretty rotten about the situation, as I was not around to help Joe explain our goals with NBehave. But I bought him a couple of beers that night, so I guess it evened out. I understand and even embrace Scott’s (Bellware) concerns that executable stories can hamper the conversation that a story is supposed to represent. But Hanselman came to the rescue to explain to Scott that these types of requirements and traceability are critical to many people, and those concerns shouldn’t be dismissed out of hand. Personally, I think if NBehave doesn’t provide value, it doesn’t have a reason to exist. However, what’s valuable varies widely from team to team.
I would have rather this discussion concern BDD than NBehave, since BDD is a new an interesting topic that isn’t widely understood.
Again, sorry Joe, my bad!
Third Session – Scott Guthrie is an MVC ninja
The third session mostly consisted of Scott’s presentation on a new MVC framework in development at Microsoft, due to be released as a beta in the next couple of weeks. Much has already been discussed about the specific architecture, so I won’t go into that. My specific impressions were:
- I’ve never EVER heard “Rhino Mocks”, “StructureMap”, “NUnit”, “Spring”, or any other major OSS tool that the community uses mentioned in a presentation about MS technology.
- I’ve never EVER seen an MS presentation actually USE one of these tools. Scott used NUnit to write tests for the controller before he ever created the view, which made me shed a single tear.
- The first points always brought up were support for swappable, testable, mockable architectures, which the new MVC framework supports inside an out. There wasn’t a scenario that was brought up that wasn’t already available.
- For the first time in .NET, it seemed that MS listened, engaged, and adapted to feedback from the community to influence its decisions and core architecture of the framework. Testability, mockability, and embracing other OSS alternatives were first-class citizens in this brave new paradigm. Bravo!
Fourth session – Hanselman knows IronPython (kinda) plus some DDD-jitsu
The next session mostly consisted of Scott Hanselman showing IronPython and IronRuby running on the MVC framework. Questions kept coming up about “will MS run RoR?”, but the answer was always “if the community wants that, they can do it, the tools are there.” Scott showed IronRuby on ASP.NET MVC, not RoR … on CLR … on IIS. It was all very interesting how he was able to get IronPython running on the MVC framework, and he showed us that it didn’t really take that much to get it up and running. Most of the talk was about the differences between the dynamic type model of the DLR and the static Type object of the CLR, and how to resolve the two. In the MVC framework, you specify that “I want to execute this view of Floogle type”, but Floogle type doesn’t exist yet since it’s a dynamic type.
I popped into a talk about MbUnit and xUnit.NET, got bored, and checked out another on DDD-jitsu. The DDD talk was interesting, as the core concepts were laid out and much discussion talked about how to introduce and implement these ideas. Dave Laribee stressed the importance of the later chapters talking about large-scale structures and bounded contexts. This pretty much ended the day
Later activities – Hanselman is a rock-jockey
I went to dinner at Chuy’s (love that Tex-Mex) with about 20 folks including Jeffrey Palermo, Martin Fowler, Scott Guthrie, Scott Hanselman, about 10 other people. It was rather strange to eat next to the voice of Hanselminutes, which I’ve listened to for so long. Scott Hanselman gave me a great tip on mapping directories to shares, to make my life easier with Windows Home Server. Scott doesn’t seem to like cats too much either… I also realized how much diabetes can affect someone’s daily life as Scott had to stop what he was doing and self-administer an insulin injection at the end of the meal. That was a good time for Scott to mention his Diabetes Walk 2007. It was amazing to me that Scott can be as successful as he is, even though this disease consumes so much of his daily life.
After dinner, most of the group headed to Main Event, which is similar to Dave and Busters or Jillian’s. Main Event has rock climbing, which all of us were eager to prove our mettle on. It was cool to see Scott Hanselman coach several of us up an intermediate course and ring the bell at the top. What was even weirder was it was only Scott’s first or second time to try rock climbing, and he was a complete natural. The rest of the night was spent at the pool tables with a few beers and a lot of great conversation.
It was a very long day, compounded with the fact that most of it was spent learning, debating, absorbing, arguing, and just trying to keep up. It proved very hard to sleep with so many conversations still buzzing around my head.
The final day started with some breakfast and a meeting outside to remind us all of the rules. Outside was a good idea, because no one looked very alert.
First Session - Bringing ALT.NET to the masses
This one was more of a continuation from the previous day’s “passion” talk, but with some folks from the MSDN magazine and architecture journal from MS. It was another great discussion with lots of ideas to bring ALT.NET to the masses, including:
- Expanding the ALT.NET website to include a wiki, videos, and more introductory material with links to more detailed information (mostly to Ayende’s blog)
- Creating demos or a starter kit that installed NHibernate, NUnit, CC.NET, and the full OSS stack locally. Basically, rewrite the PetStore starter kit to use ALT.NET ideas to provide a nice introduction and example application
- Aligning the PnP group with the other events. We all know that agile stuff is happening inside MS, but we never hear about it at the MSDN events.
There were several other ideas, but I realized afterwards that a nice bound notebook is a great note-taking tool, better than “maybe I’ll remember”.
Second Session – Executable requirements nirvana – StoryTeller and NBehave
This talk started with Jeremy Miller discussing the problems and difficulties of FitNesse, such as:
- Great for tabular data-driven tests, but not great for complex models
- Difficult to integrate with source control
- Breaks often with refactorings, as everything is string-based (similar to the problems with NMock)
He showed StoryTeller, along with some tests. It made running and authoring FitNesse integration tests much easier, but still had the issues that FitNesse has.
Next, Joe and I gave a demo of NBehave, as well as a good discussion on where its value is. Mainly:
- It gets the language right
- It integrates well with automation
- It runs complex objects well
- It has a very grokkable interface
However, there were some shortcomings in that NBehave doesn’t do well with tabular data, and much has to be copied and pasted to do so. Jeremy suggested an integration with StoryTeller and NBehave, or FitNesse and NBehave to allow users to run story-based integration and acceptance tests. At one point, Joe thought it was a good idea to show the code behind NBehave. It was too late to take the beers back that I had bought him the night before.
Closing the space
At the end of the conference, everyone gathered in the main room, and all had a chance to give share their final thoughts. It was an amazing experience, and even Scott Bellware got a little choked up at the end. We went to lunch afterwards at Saltgrass Steakhouse, where Roy Osherove and Rod Paddock shared a story about a dirty joke, which we found could be applied universally to any situation. The story itself is NSFW, so I’ll just have to relate it later.
This was by far the best conference I’ve attended, I can’t wait for the next one. I left excited and energized, glad to be around so many people with so much passion. The conversations were always engaging and inviting, and never closed or exclusive. Any one could jump in to any talk at any time, and challenge any assumption of the discussion. I think the ALT.NET community (if that name does indeed stick) proved that there is a vibrant community in .NET that can provide conversation and feedback to MS, and not just a lot of external, negative noise. While I mentioned a lot of names here, I wasn’t trying to name-drop but to show that this community is accessible and eager to engage with others. This was an important first step in creating a healthier, more inclusive community, and I hope it isn’t the last step.