Monday, April 21, 2008

ALT.NET Seattle Summary

I attended the ALT.NET Seattle event this weekend. I had mixed emotions about attending and didn't have very high expectations. I am fairly new to ALT.NET (3 months). My first couple of weeks on the ALT.NET discussion list just about soured me on the group. There were a bunch of petty, uncivil discussions and there wasn't a lot of useful information coming out of the discussions. Luckily, I was patient and the signal-to-noise ratio has improved recently. The ALT.NET Seattle event greatly exceeded my expectations. There were a lot of intelligent, passionate people who attended. Also, a couple of the ALT.NET leaders spent a lot of effort working to keep everyone civil. I think those efforts made a huge difference. Thanks to the organizers for making this a memorable event.

Friday evening started with individuals proposing topics. The heavy posters on the ALT.NET discussion list and prolific ALT.NET bloggers dominated this activity. That wasn't surprising nor is it a criticism. I just found it interesting to watch. Next, there was a fishbowl conversation on polyglot programming. Fishbowl conversations were new to me, so it was interesting to observe. I think it was the right thing to do because there were some people who would of and could of dominated the conversation. The result is that a lot of people got to say a little bit about polyglot programming, but no one dominated the conversation. The downside is that there wasn't a lot of substance to the conversation. That's OK because it set the mood for the weekend, civil conversations where everyone gets an opportunity to be heard.

The first session that I attended on Saturday was led by John Lam and was about IronRuby and the DLR. He talked a bit about IronRuby progress. They have a ways to go. He mentioned they are using the Rubinius tests as one measure of done-ness and they have passed 89% of the tests. He talked about working with code at the meta and meta-meta level and how quickly things can get complex and hard to maintain.

The second session that I attended on Saturday was led by Dustin Campbell and was about functional programming. Most of the people in the room had very little experience with functional programming so the conversation didn't go very deep. Functional programming conversations very quickly get into how much better suited FP languages are than non-FP languages for handling concurrency. I understand how FP languages have the possibility of handling concurrency well, but I haven't seen a lot of real-world examples to prove it. Concurrent computing is complex. FP languages may help with the complexity, but they aren't going to eliminate it any time soon and they certainly aren't going to push concurrent computing into the hands of junior/intermediate programmers any time soon.

The third session that I attended on Saturday was about ASP.NET MVC. Many of the attendees use ASP.NET MVC. Phil Haack and Brad Abrams from Microsoft attended and fielded a lot of questions. We talked a bit about Microsoft's 5% adoption of MVC comments. The number was just pulled out of someone's butt and Microsoft has no idea how much MVC will be used. I think Microsoft is also very nervous about upsetting their ISV's and large corporate partners. If MVC is widely adopted then it will be very disruptive to the web control vendors. Microsoft is always fearful of incurring the wrath of large corporations who will ask "Why am I building applications with X when you are moving to Y?". The attendees asked Microsoft to stop using the 5% adoption number because it will scare a lot of managers away from adopting MVC. Some attendees also asked Microsoft to make it as easy as possible to leverage open source Javascript libraries and client-side controls. They seemed receptive to the message.

The fourth session that I attended on Saturday was led by Scott Bellware and was about Behavior Driven Development (BDD) / Context Specification. Part of the discussion was about BDD and whether Bellware had hijacked the term to push something else. He admitted that may be the case. He presented an interesting way of testing software against specifications. While I liked some of the things I saw I doubt that what he is proposing will gain any traction. While his ideas were interesting I don't think he presented a strong case for improving anything. His approach was different, not better.

The fifth session that I attended on Saturday was led by Scott Hanselman and was about whether the .NET community innovates or contributes anything back to the open source community. It seems to me that a fair amount of ALT.NET'ers are very bothered by the image that all of the innovation is happening outside of the .NET platform or only in the open source community. I don't understand the insecurity. Why does it matter where innovation happens? I contributed two comments to the conversation. First, I think open source is not as prevalent in the Microsoft space because there is a rich ecosystem of commercial companies whereas in the non-Microsoft space there isn't. Many of these commercial companies provide source code with their products, but they aren't open source companies. Second, while the .NET community didn't invent something, they have a long list of things they greatly improved. I used JUnit vs. NUnit as an example. Scott Hanselman translated my point into "innovation doesn't necessarily equal invention" which accurately summarizes my point. Someone else made the point that much of the innovation claimed by the open source community happened some time in the past. What innovation has there been recently?

I skipped the two Sunday sessions. My son and two of my grandchildren live in Seattle, so I decided to spend the morning with them instead. There were a couple of sessions that looked interesting, but nothing I couldn't live without.

The best part of the event was the socialization. Unlike a conference, user group, or Code Camp where people are expecting to be passively taught, most people came to this event to talk/socialize. I had a number of interesting conversations with people in between sessions, at dinner, and at the bar.

Saturday, April 05, 2008

Devscovery April 2008 Conference Summary

I attended the Devscovery Conference last week. Overall, it was a good conference and I recommend attending it in the future. I think it is one of the best value-for-the-money conferences.

Scott Hanselman kicked off the conference with a discussion on ASP.NET 3.5 Extensions. Usually Scott's presentations are very good, but I walked out of this one somewhat disappointed. He started off by asking a couple of "How many of you use X?" questions. I don't remember what he said, but he made some comment that came across to me as the attendees were a bunch of dopes. This completely shut down the audience participation which in turn threw off Scott because he likes to engage the audience. Also, I thought Scott's material was a bit dated.

There really wasn't anything that excited me for the first session so I sat in the "Translating Architectures to Technologies" presentation by Roger Dahlman. This was supposed to be about design patterns and .NET. This presentation was horrible. Dahlman was a very poor speaker, his slides were littered with spelling mistakes, and he came across as not knowing design patterns at all. I got nothing of value from this presentation. At this point I was starting to think that I wasted my money and time attending this conference.

The second session was "C# 3.0" by Jeffrey Richter. Since I feel like I have a pretty good grasp of C# 3.0 I was expecting to maybe get a couple pearls of wisdom out of this presentation. I really liked this presentation. Jeffrey told a nice story about all of the C# 3.0 features that concluded with why all of the new features were necessary to enable LINQ. That was fine, but I knew that already. What I didn't know was that this presentation provided the foundation for the next day's threading presentation.

The third session was "Performance of Every Day Things" by Jeffrey Richter. This was an excellent presentation about how different .NET programming constructs and techniques can affect performance. I already knew most of what he presented, but there were a couple of new things that I learned about measurement that I will use immediately.

On day two I attended the "Day of Threading" presentation by Jeffrey Richter. This was four sessions on threading. I was expecting this presentation to be a refresher for much of what I already knew about threading. I was pleasantly surprised when it wasn't. Jeffrey spent most of the day discussing the Asynchronous Programming Model (APM) that he wrote about in CLR via C#, Chapter 23 and the MSDN Magazine March 2007 and November 2007 issues. One of the issues that he discussed was how difficult the APM was for most developers to use. During the presentation he knocked down the obstacles to using the APM. By leveraging the new features in C# 3.0 he greatly simplified the APM. Throughout the day he ran a number of tests to measure the performance of different threading techniques. His final implementation provided substantially better performance, lower resource utilization, and lower code complexity. He said to expect another MSDN article in the June 2008 timeframe that completes the discussion on APM. He mentioned that the Microsoft Robotics team tried to prevent this article from being published because it provides a vastly superior solution to the Concurrency and Coordination Runtime (CCR). Also, he mentioned a couple of teams in Microsoft that are using APM and are seeing major improvements in scalability. Some of the tests that he ran showed the scalability improvements and they were substantial. I didn't fully appreciate the APM, but I have the religion now. This will play a major role in my development from now on.

The first session on day three was "The Microsoft AJAX Library" by Jeff Prosise. This presentation focused on the client side entirely. He said that he presented the server side of AJAX the previous day. He did a good job presenting the internals of Microsoft's AJAX libraries and discussed how to extend/modify them.

The next three sessions by Jeff Prosise were on Silverlight, "Building Great Applications with Silverlight 1.0", "Building Great Applications with Silverlight 2.0", and "Silverlight Tips, Tricks & Best Practices". All of these presentations were good. I was a little leery about sitting through a presentation on Silverlight 1.0, but Jeff did a good job on focusing on the features that remained in 2.0. Jeff provided lots of sample code that will be helpful in further use of Silverlight.

I was a little disappointed that I couldn't attend any of John Robbins' sessions, but since I did a day of training with him back in December 2007 it wasn't a big deal. I didn't attend any of the non-Wintellect sessions since they seemed to be more focused on the mechanics of basic things. I would have been OK if Wintellect didn't co-host with Infragistics. I think the audiences that both attract are completely different.