DevDays 2008 - Impressions

The 2008 Microsoft DevDays are here, and I'm there. An impression of the first day.

The Dave Platt Show

To kick things off, we had Dave Platt deliver the keynote: "Why Software Sucks", adaptated from his book by the same title. This caused quite a bit of sniggering at my company when we first heard it, and I suspect that was exactly the intention: nobody can have missed the irony of a lecture on sucky software being hosted by Microsoft, certainly one of the biggest purveyors (if only because they're one of the biggest purveyors of desktop PC software period).

While entertaining in the best American tradition (keep it light, keep 'em laughing) and while he certainly made his points well, there's no denying that the whole thing felt a bit irrelevant. My boss compared the no doubt well-rehearsed and often repeated presentation to a traveling circus. While I think that's unnecessarily harsh (Platt does not merely entertain, after all), there's no denying that it had little to do with the rest of the sessions conceptually.

Prior to Platt's speech, there were tantalizing videos of Anders Hejlsberg and Scott Guthrie delivering short blurbs specially recorded for the DevDays; neither could actually make it, which is certainly a shame. Given their involvement with all the new features presented, either would have been a much more appropriate choice than Platt.

The Odds and Ends of the Debugger

My first actual session was "Advanced Debugging with Visual Studio", by Ingo Rammer. I managed to arrive 10 minutes late, despite all the friendly staff posted to show idiots like me the way. All the presentations in the big halls are projected on a very big screen with the demo on the left and a close-up of the presenter on the right, so it doesn't really matter where you sit, and it doesn't even matter if you have to stand in the back like yours truly.

In any case, the presentation was exactly what it said on the tin: an exploration of the VS debugger features you might not have known where there. It was mostly wasted on me because I knew almost all the "tricks" presented, and the remainder didn't have a golden productivity booster I happened to overlook. I put "tricks" in quotes because they're not actual tricks, just less well-known features. This despite the fact that most are sign-posted in context menus and the remainder is documented in the help, but many programmers don't take the time to look beyond the immediately applicable (whereas I'm one of those people who will click a button because it's there, and read random help topics when I've got nothing better to do).

This is not to say Ingo's presentation was bad, because it wasn't; it just wasn't interesting to me. I could have anticipated this and gone to another presentation, but I was there with colleagues and we were deliberately spreading out to maximize first-hand experiences. It was either this or learning about what's new in VSTS 2008, which would certainly have been of even less benefit (because I already read up on that). At least this way I learned about the Object Test Bench and how it's integrated with the Class View!


Lunch made me once again marvel at the organization of events like these; the hundreds of attendees were constantly coming for food and drink and they were all served smoothly. I'm always curious to know about the figures associated with this—how much does it cost, and exactly how much sandwiches did they make? On the other hand, I'm too lazy to actually put in the effort to find out, so there you go.

On the actual food, which was a buffet of various lunchy foodstuffs: the warm object with filling of indeterminate origin was distinctly unpleasant and the bun with cheese had some very sharp cheese, but I'll chalk both up to taste. The ham submarine was excellent, and I liked the choice of pears and bananas as fruit on the side. Didn't try the sandwiches, as I was quite full by that point, despite not having had breakfast.

Also compliments on the selection of drinks: coffee, tea, orange juice, water and various soft drinks were all readily available. I have to be less complimentous about the hot water offered for the tea, though: this should really be "nearly boiling", not "pretty warm". You simply cannot brew a decent cup of tea with lukewarm water, no matter how vigorously you dunk the bag. Honestly, when are the Dutch going to take this matter seriously?!

The Other White Meat

Leaving the all-important subject of tea behind, next up on my program was "Understanding the ADO.NET Entity Framework". This one was quite a shocker, because Mike Taulty offered a narrative simmering with intrigue and hints to dark tales best left for the campfire. He revealed that Microsoft has two object/relational mapping technologies under active development! There's LINQ to SQL, which by now I suspect everyone knows, and then there's the ADO.NET Entity Framework, which I'd never even heard about. Surely there is more to this than was immediately revealed...

Alright, so Mike's presentation actually had no intrigue and dark tales at all. He merely pointed out that yes, Microsoft now has LINQ to SQL and ADO.NET EF more or less competing with each other, and yes, this is a bit silly. As time goes by we can expect them to either converge and merge or drift apart further and carve out their niches, but currently there's a big and curious area of overlap between the two.

The most prominent advantage EF has over LtS right now is that it's a provider-agnostic solution, whereas LtS only plays nice with SQL Server. EF is also much more general than LtS in other regards, as it provides an (almost) clean separation between your data model and the actual schema, with very flexible mapping possible between the two (including subtyping through inheritance). LtS isn't quite that advanced yet, and its mappings are mostly one-to-one. On the other hand, for most scenarios that's good enough, or even desirable.

Mike's presentation style was that of the disheartened developer: he expressed worries that people had come to his presentation just to doze off after lunch, made some resigned remarks about how the things he did and the things he was working with at that moment sucked, and was exasperated at the audience when he asked an obvious question and nobody burst forth with the answer. I'm pretty sure this was all meant to be taken in good fun, but the audience was clearly unsure at points whether they were supposed to laugh or whether he was serious. On the technical side of things his presentation was impeccable, so I'd advise Mike to just skip the deprecating remarks altogether the next time. I can assure him people are not going to be dozing off when the subject matter's as interesting as this.

Starts With "W", Ends In "F"

I wasn't done with Ingo Rammer yet, because he gave the next presentation: "WCF and WF: Integrating two key technologies of .NET 3.5". I was already familiar with WCF before coming here, but not with WF. Ingo did a good job of summarizing them sufficiently to understand the remainder, though.

What he actually talked about was a very specific aspect of integration: using WF to call WCF services in a stateful way. More interesting than the specifics of what he ultimately showed was the buildup.

First he introduced a solution with no workflow and using regular services that call on each other. Regular services can have callbacks through duplex channels, but those do not preserve state across process instances: restart your service once and any open transactions are lost. Most workflow-based solutions integrate humans in processes where you can have days between a request receiving a callback, and expecting no restart to ever occur is unreasonable.

So he upgraded the solution to use a new feature of WCF: durable services. These services do preserve state, and in an elegant and (in hindsight) obvious way: WCF simply serializes the service instance, and deserializes it when a request for the serialized service is received. If you think about it, serializing state is indeed exactly what needs to happen to make a service stateful, and the designers recognized that there's already a perfectly serviceable mechanism for that. All that's required is that service requests indicate what instance of the service a request is for, by echoing the instance identifier the service provides back to them. There are multiple mechanisms for this, and they are not WCF-specific, so they're easily integrated with non-WCF clients.

Finally he showed how the new Send and Receive actions in WF 3.5 can be used to leverage durable services to create workflows that can be instantiated and resumed by service calls. This allows you to replace any of the logic behind a service with workflow logic that can be much more powerful than what you would be willing to write by hand, all without you having to worry about the service calls going to the right workflow aside from some plumbing that amounts to just a few lines of code per workflow.

Ingo is a good presenter, which you can tell from the fact that I forgot he had been the one presenting it mere moments after I'd left the presentation. Moreover, I didn't even realize that this was the same guy who had done the debugger presentation! Now, though I am pretty dense that way, I like to think that it was because I had completely focused on the technical content in both cases. It may not sound good to be unmemorable, but it is—how many presentations have you seen where you afterwards remembered more how the guy presenting it was constantly flustered or going over things too fast or too slow rather than what he actually talked about? If your audience can have a meaningful conversation about your topic without involving how you presented it, you delivered a good technical presentation.

My boss happened to be sitting in on this one (at this point he was fluttering from session to session at his fancy). While he thought it was interesting, he didn't see much use for it in the applications we're building. He's mostly right, but I'll try to sneak workflows with durable services in on the next project I'm building anyway.

Obviously, that was a joke. I would never waste the company's time like that. At least not deliberately.

A Sketch for Two Gentlemen

My last session of the day was "VSX: Extend Your Development Experience", a feature hosted by Jean-Marc Prieur and James Lau. They gave a whirlwind tour of Visual Studio Extensibility. After the framing concepts, Jean-Marc hacked together a simple source outliner (after being challenged by James to do so in 15 minutes), showing how the rich object model of Visual Studio makes these things very easy to build.

He then got to "educate" James on the benefits of a DSL (Domain-Specific Language) editor, by making James fail miserably at correctly implementing a simple change request for a graphical designer, and showing how he could implement the same thing in his model with a few clicks (and without errors). This was a very effective self-contained demonstration of something that's easy to leave abstract and boring.

Finally, they demonstrated how the Visual Studio Shell can be used to build your very own Visual Studio derivative that has almost none of the interface complexity and installation prerequisites of the full Visual Studio, allowing you to leverage your designers as standalone specialized applications. This is very interesting for two reasons. First, it gives people a head start delivering their own design applications (which can generate standalone output). Second (and this is what I find more interesting, as a developer) it allows non-coders to contribute to software in such a way that their contributions can be easily integrated with your build process. This is quite an advantage compared to the usual process of non-coders emailing, faxing, photocopying or verbally delivering software precursors that a coder then somehow has to realize—for the coders, but moreso for the non-coders.

These two make an excellent team, almost becoming a comedy duo, and they did a great job of keeping up the pretense of the presentation being ad-libbed (which was of course not the case, and I shudder at the thought of the rehearsals) without having it resemble a home shopping commercial. These "watch the presenters cobble together an application with wizards" presentations always have the potential to go horribly wrong and boring the audience to tears, but there was none of that here. Their antics drew genuine laughs from the audience while still hammering home the message that VSX is worth looking into. As far as presentation style goes, these two took home the prize, as they chose a risky format and made it work.


There was quite a bit of other stuff going on beside the sessions, but I barely noticed any of it. There's only 20 minutes between each session, and while that sounds like plenty of time, it's really not. After an hour of talk I invariably wanted to stretch my legs, grab a cuppa, ponder on the lessons learned and meet up with my colleagues, which combined with moving along for the next presentation left little time to do something else. I considered skipping one of the last two sessions to have time for exploration (and sending some mail), but decided against it. I'm glad I did, because I wouldn't like to have missed either of them.

During lunchtime I did explore around, but somehow still managed to miss the Microsoft Plaza, which certainly sounded like an interesting place to be. This in contrast to the stands of the other companies, which were not interesting places to be simply by the looks of them—the standard collection of stands with an eyecatcher gimmick totally unrelated to the company's daily routine and employees who look like they're only there because it's just where they are right now. Oh well, making software development look exciting was never easy.

The shortage of IT specialists we're currently having was quite comically demonstrated by the fact that almost every company offered a chance for fabulous prizes if you just left your name, e-mail and telephone number. No further details required—we need developers! If you participated in any of these and you happen to receive a prize package in the mail, be wary if the mailman asks you to sign for delivery—there could be a contract underneath the delivery receipt...

One company (whose name eludes me, but I can assure you I'm not trying to protect anyone) even advertised itself as being "100% Microsoft", which just strikes me as laughably bigoted, even for a stand on the Microsoft DevDays. Even if you are currently based on all-Microsoft products, there's no need to advertise it as if it were part of the company's charter. Are you implying you'd never consider non-Microsoft products? I know some great things you're missing out on, then.

I also had a look at the bookstore. The selection was quite limited, although this is understandable, given that they simply can't fit a complete bookstore in there. None of it particularly caught my fancy—"Design Patterns with C#", "Automating Excel 2007", "Basket Weaving with Visual Basic.NET", that sort of thing. The only books that stood out were "Why Software Sucks" (because of the keynote, duh) and Fred Brooks' timeless classic "The Mythical Man-Month" (because it's a timeless classic, duh).

Tomorrow: DevDays 2008, Day Two.

No comments: