For the last half a year a group of us (Bil, James, Dave, Terry, Justice, Greg and Kyle) have been organizing the first ALT.NET conference in Canada and today, on Canada Day no less, we are announcing the opening of registration to it. The event will happen on August 15-17 in Calgary.
If you've not been to, or heard about, the ALT.NET conferences in Austin and Seattle, they have drawn many software development luminaries and created great conversations. There are no predefined sessions like you would normally find at a conference. The format follows the Open Spaces principle and is completely self organizing. The topics, conveners and session attendees happen based on the needs of the day, hour or minute. One of the most fantastic things about the conference is that conversations don't stop after an hour. They will carry on in the halls, cab rides, restaurants, and most definitely in hotel lounges.
You can sign up here (http://www.altnetconfcanada.com/registration/index.castle) and review the current attendee list here (http://www.altnetconfcanada.com/participant/index.castle). Note that the conference is capped at 100 registrants, so signup fast. If you don't get into that list, sign up anyways to ensure that you're on the waitlist when people start cancelling.
I personally guarantee that one of the two Canadian delicacies you see here will be available in abundance at your hotel breakfast during the conference. You'll just have to wait to see which one.
The completion of the Alt.NET conference in Austin has created a plethora of conversation on blogs and in the altnetconf Yahoo Group. Some have been critical of the purpose and intent going into, during and following the weekend. Others have begged for further discussion on logos, mantras, mission statements, and governence in general. In some form all have a valid point (with the exception of one, but I'm not going to comment on that one).
I went to the conference fearing some of the worst was going to happen. I thought, with absolute certainty, that there would be at least one, if not more, bitchfest slagging all things MS. I can't tell you how grateful I am that I made the time to spend a weekend with people who were so positive, pragmatic and enthusiastic about any potential tool, technique or solution. I also feared that there would be discussions that degraded into personal attacks and verbal scraps when people's tools were negatively critiqued. Although there were sessions where products were critiqued (Joe Ocampo's NSpec/NBehave comes to mind immediately) with quite a bit of vigour. Not once did anything like this degrade into a pissing match. The critiques were absorbed and I'm sure, although I don't know personally, that the feedback was put to work and the products will become far better due to it.
There were a number of watershed moments both during the event and in the conversations after. The biggest that occurred during the sessions was that Microsoft is there to participate within this community and not fight it. In fact they are openly embracing it on a number of fronts. The most obvious is that the new System.Web.Mvc implementation demo'd by ScottGu is built with a large number of the development principles that many Alt.NET attendees practiced. The open acknowledgement by Microsoft by making their MVC implementation extensible at points such as IoC or the view engine was commendable. Seeing a 'softie go through a demo with tests was another huge step. The less obvious statement made by Microsoft was in the session held by Simon Guest and Howard Dierking. These guys really want to help propogate information on the techniques, tools and frameworks that are often used in the Alt.NET community. If you're a burgeoning writer and you're swing for the Alt.NET team (whatever that means), get in touch with these guys. You never know where your name may appear.
One of the biggest take aways was that you shouldn't wait to be told to spread the message. Ray Lewallen said it best in the wrap up sing along when he stated:
Don't go back to your town and start an Alt.NET group. Take the message to your regular user groups.
Alt.NET is about learning to build better software. It's also about becoming a bit of an evangelist for the techiques, tools and frameworks that we commonly use. Get out and do a presentation for your local user group. Kyle (Justice?) was so inspired that he contacted three different groups right after leaving the conference and they welcomed him with open arms. In September Tom and I took a trip to Phoenix/Tempe for Desert Code Camp to present on topics near and dear to our, and the Alt.NET community's, heart. Don't be worried that people won't be open to accepting the message. I've found that people are always interested in hearing about options. If we can present them with some of the ones we have afflictions for, and do it with passion, we will begin winning developer converts.
Thanks to the folks that setup the Alt.NET Conference. This is the start of something good. Like many said, it will be hard to proceed for a while, but we will influence change for the better both during that time and after. I leave you with one picture of the guy who really sparked the whole thing.
This was a brilliant discussion about what we in the Alt.NET community need to do to propogate our message. The great part was that we had people from the Patterns & Practices group, MSDN Magazine and MSDN Architecture and they were the ones driving the group to be more visible.
The thing that was discussed for more than a minute was that we need to tell the world the things that we learned two, three and four years ago. When we were learning them we weren't good and speaking about what we were learning. We knew what we had learned, but putting it into a cohesive and comprehedable message wasn't our strong point. In the time that has passed we've figured out how to say things better. All you have to do is look through blogs to see this.
Watch for a more consolidated conversation presented through a number of different channels (I feel like I'm in marketing after that sentence).
Interesting conversation on the optimal location for behaviour related to the domain. The discussion was around whether a Transfer of Funds from one Account to another Account should exist in a Domain Service (i.e. AccountTransferService) or right in the Domain entity (i.e. Account.TransferTo(account, amount)).
The real question is where does the ubiquitous language belong? How do we make the code more soluable? Where is readability at it's optimal state?
I think that they pointed out the names for some things that I saw in the last code base that I worked on. Anemic Domain is when you have a thin Domain model (getters and setters only for example). The thing is that it isn't all that bad, IF you keep the logic in the Domain Services. The problem that we had in the last code I worked on was that the business logic was in the Application Services which is an anti-pattern.
There also was a brief discussion about what DDD is. We agreed that it is a model of the business and a method for capturing ubiquitous language (ubiquitrons in David Laribee's world).
Scott Guthrie is showing the yet to be released MVC implementation that will be coming out of Microsoft for preview in the next few weeks, and RTM sometime in Spring 2008. It's pretty exciting to see Microsoft taking this project on. Right now it's looking alot like a MonoRail implementation, but it's using some more of the new language features.
MS has implemented a tonne of hook , integration and extensibility points in the system. Although it comes with defaults (i.e. aspx as the default view engine) you can override them with whatever you need. If you want Brail, you implement with Brail. If you want Windsor, you use that.
The highlight of the presentation was when Scott called Scott Bellware a Mort for wanting to implement without writing tests. I can't wait to get my hands on this in the next couple of weeks to do a comparison of it with MonoRail.
The BDD discussion was fantastic. It was primarily driven by a need for people to understand where it fits into the development process. One of the primary questions was where does it fall in the lifecycle of the development process and where do you go once you have worked with it? I don't know that this was answered.
We've moved onto how this relates to working with the client. Should we be working in code to document the converation when the client is in the room? Should we be exposing them to our side of the world at this point in the process? I would think that I want the client to stay in their sphere of knowledge during the conversation and then move the conversation to the technical realm. We also need to keep the story accessible to the BAs and end users. They need to be able to get to the story when they need or want to, whether that is just to view them or to modify them.
Scott H. points out that specification is nicely forcing the verbage structure within the story. Index cards are dynamically typed. People can write the story in any format that they want. Story cards and specification frameworks are not for traceability and will not stand the test against regulators.
I think that code based story writing is an attempt by the developer to retain control of the process and, most dangerously, the contents. Arguments are being made that this is a tool for bridging the gap between the BAs and the developers. After it is used to gather and "codify" the english language specification it becomes an acceptance test. Before that point it's not a test.
Another valuable and passionate discussion.
The morning came far to early today, but once I hit the first session I started to get pretty stoked and energized. We had a very passionate and, at times, heated debate about how to get more passion into the community about the principles that are Alt.NET.
So how do we get the developer community at large to be more pragmatic? That is what Alt.NET really is...a pragmatic approach to software development. Maybe you choose .NET drag-and-drop in one situation, and another time you may choose Ruby or PHP. The key with Alt .NET is that there is no one "right" answer. Each answer is a product of the circumstances that the question was asked in, plus the question itself.
How do we make pragmatism mainstream? Arguments were presented stating that code samples and blog reading can do it. Others presented that we need to be more evangelical as leaders in this space. A bevy of techniques were presented for specific scenarios. The one that seemed to float to the top was that continuous integration was a low hanging fruit and made a great starting point. Maybe all you do is start with a continuous compilation and then, once you've shown some benefit from that, you move to including test execution. Additionally CI is something that you can do on your own and slowly roll the concept out to other developers without having to convince the whole group in one fell swoop.
In the end the only thing that seemed to be agreed on was that the pragmatic mentality needs to become a daily fact for all developers. It doesn't matter if they're a Mort or an Elvis, we need this way of thinking to become as second nature as opening the development tool that is being used.
Unlike most people I showed up fashionably late to the show. I managed to squeek in 2 double Jose Cuervos with the nerd herd before retiring to the front lobby to discuss geeky topics. We indulged ourselves on the possibility of mbUnit becoming the one framework to provide to them all (unit, integration, system and other types of testing), the state of the world and Tom's fascination with men. Yes, Tom decided to hit on every person in the group at one time. The first statement went something like "At least you guys are good looking, because you sure ain't smart". That was followed by "She's pretty hot....for a girl". It's official, going to Texas has made Tom come out of the closet.
More on Tom's new predilictions and the state of the Justice saga to come.