Went to Hanselman’s Nerd Dinner last night and must say, it was well worth it. A lot of folks turned out for it, including Omar Shahine, Adam Kinney, John Lam, Jason Haley… oh, yeah, and Lutz Roeder. A great social event and a piroshky? Hellz yeah.
Oh, I bugged Lutz about it again, and he’s letting me releaseCR_Documentoras open source. Apparently there was some political hoopla going on before that would have been bad had I released it, but that seems to have passed so it’s cool now. All you folks wanting new features and wondering why I’ve been stagnating - now you can contribute. I’m going to finish up my refactor of it so it’s stable and get it out there. This definitely gives me a renewed interest in finishing up the next release. Yay!
The topic of Day 5: Applications.
Keynote - Scott Hanselman
Yes, you’re reading that right - Hanselman keynoted two days in a row. This time the presentation tended toward the humorous and sort of tied things in with a message to the community that was basically the end of Bill and Ted’s Excellent Adventure: “Be excellent to each other… and party on, dudes!” You know, in so many words.
There was a snap-on demo of some more MVC, but generally that was it. I like Scott - he’s a friend - and I thought the presentation was hilarious, but I had a little difficulty tying it in to “patterns and practices” or to the theme of the day - “Applications.” That said, if he posts the video of the presentation to his blog, watch it. It’s a crack-up.
Future of Patterns and Practices - Rick Maguire
Maguire discussed the challenges that the patterns and practices team faces and talked about where things are headed. Challenges they see are things like technology changes (so many changes so quickly), increasing complexity of software, and compliance with standards and regulatory issues.
What the future boils down to: They’ve focused previously on tools. They’re switching focus to developer centers and documentation - helping people find which tools will help them get the job done.
Evolving Client Architecture - Billy Hollis
Hollis discussed some of the recent changes in client technology - specifically around WPF and Silverlight. He gives the impression that WPF is the Way and the Light. I think it’s interesting stuff, but somehow I don’t think it’s the End All Be All. At least, not yet.
The basic idea, though, was that it’s a good thing if you’re looking at XAML. It’s got a good programming model and will allow you to get some of the reuse that you weren’t previously able to achieve before. (But it’ll be better when Silverlight 1.1 is done.)
Introduction to the Microsoft Client Continuum - Kathy Kam
This was almost a continuation of the talk Hollis gave, talking about the variety of clients you can target with .NET technologies. The discussion here was more on the variation between having wide reach with your app - standard HTML via ASP.NET - and having a rich experience - using WPF in a native app.
The interesting thing here was an illustration of how you can reuse components across some of these. For example, say you have a straight HTML app. Not rich, but very client-accessible. In a basic Silverlight app, you can take the same HTML app you had and add richer interactivity in select portions of the app (like replacing an image with a XAML content block). In your native app, you can take the XAML that you used in the Silverlight/HTML app and use it in your WPF app. Very cool.
The technologies she reviewed, on the scale of “reach” to “rich”:
- ASP.NET 2.0
- ASP.NET 3.5
- Silverlight 1.0
- Silverlight 1.1
- WPF 3.0
- WPF 3.5
Fresh Cracked CAB - Ward Bell
This was one of the talks that I think I can take back and immediately start using some of the ideas from. Bell showed how he uses the Composite UI Application Block to better architect applications. (There’s a Composite Web Application Block as part of the Web Client Software Factory… but I don’t know how applicable this was. Still, this was an interesting thing.)
There was some explanation about how the CAB works, which was good, but it got really good when he started talking about some of the patterns used. Of particular interest was a slight addition he made to the MVP pattern - MicroViewControllers (yeah, it’s “MVC,” but not in the sense we normally think about “MVC”).
Think about this - how many times do you basically have what amounts to generated code where you…
- Data bind model information to controls?
- Set error provider information?
- Set control visibility/editability?
- Format data in the view?
- Localize control text?
All that just fattens up the interfaces and makes code cumbersome. The idea of the MicroViewController is that it’s a facade over all of these things - a single object shared between the view and the presenter to handle all of that.
Think code like:
Very cool stuff.
Wrap-Up - Billy Hollis
A fantastic and entertaining rant from Hollis about how, frankly, there’s just too much out there to learn. You’ll never know everything you need to know, especially with the changes coming at us fast and furious. And it’s not just technology - it’s even IDE features. Which just goes to show we can’t solve this problem with more features - that just adds to the complexity.
And we have no one to blame but ourselves.
The question now is - how do we fix it? Maybe some ideas here…
The Simplicity Manifesto v1.0 (per Billy Hollis):
- Stop adding features.
- Make help helpful.
- Fix the bugs.
- CRUD for free.
- Hide the plumbing.
- Get better names.
The topic of Day 4: Software Factories.
Keynote - Scott Hanselman
Hanselman’s keynote was a demonstration of the upcoming web MVC framework that Phil Haack et. al. are working on.
Much of this can already be seen via the videos posted over on his site
- we saw a pretty basic CRUD interface for working with customers and products against the Northwind database. I’m interested academically in this, but the demos always sort of go for “super simple.” How many people actually only do basic CRUD? Where’s my input validation? Where’s my localization? I need some more meat in my demos before I’m sold.
Domain-Specific Development with VS DSL Tools - Gareth Jones
At this point in the conference we really started hitting what, I believe, David Trowbridge referred to as “meta-moments.” Jones showed us how the Visual Studio DSL tools allow you to model your own doman-specific language and generate a Visual Studio designer and toolbox set that allow you to get developers modeling and generating code right from your DSL.
The problem we had was that nothing ever ended up being concrete. I recall hearing things like, “Okay, say we have a class that refers to our model. We’ll call that ‘ModelClass.’ It has an attribute. We’ll call it ‘Attribute.’“ That sort of thing. It would have hit home a bit more had it been a little more concrete. Model me an ordering system or something. This didn’t actually make much sense to me until a later talk in the day about the web service software factory.
Patterns of Software Factories - Wojtek Kozaczynski
This was a discussion of how the current set of software factories work and the design patterns you can see used in each one. It was interesting to see it all from an academic standpoint and see all of the patterns work together (as well as how you might make a huge enterprise application using all of the software factories together) but I’m not sure how much of this I’m going to be able to take back with me and use immediately. Definitely one of those presentations I’ll keep around and when I’m trying to solve a problem I know appears in one of the software factories, I’ll check back to see how they solved it.
Introducing the Aikido Project - Andres Aguiar
A thinly-disguised Infragistics sales presentation on the Aikido AJAX web control framework built on top of ASP.NET AJAX. Looks like it might make some of the ASP.NET AJAX stuff easier to work with, but come on - another framework?
That said, I may have just been grumpy and unreceptive - we got “boxed lunches” so we could watch the presentation during lunch and, fast as I tried to get up to the lunch line, all that was left when I got there was a choice between turkey and tuna, neither of which I’ll eat. The ham and the roast beef disappeared, as if by magic. I ended up eating chips and a cookie for lunch and getting a headache later on. Note to conference organizers: Catered boxed lunches are always a bullshit cop-out. If you’re going to do that, at least give folks enough time to go out and get something else if they don’t like what you’ve pre-packaged.
Sevice Factory: Modeling Edition - Bob Brumfield, Ade Miller
As mentioned earlier, this is where the Visual Studio DSL Tools started becoming concrete for me. This presentation showed a designer for modeling services and generating service code (including the request/response and domain objects) that was actually the output of the Visual Studio DSL Tools. Aha! Now I get it!
This looked like a pretty compelling way to get services jumpstarted. While it doesn’t have the full functionality of schema, you can use schema to augment it so the flexibility exists, albeit not all in the designer. Definitely something I can take back and use.
This one I was really into because it was very obviously directly relevant to what I do. It was a great walkthrough of the Web Client Software Factory - what’s there now, what’s on the way. Showing some of the stuff they have - role-based UI, Composite Web Application Block, easier stories for management/deployment of apps - was really interesting because it’s not something you can just “pick up and use” - it takes time to get these things hooked up, so seeing it working and the possibilities available was nice so you can justify that time.
Some of the things coming up in the future include:
- Suggestion pattern (autocomplete).
- Live form pattern ( validate data as the user enters it into the form).
- User controls that can be used cross-module via dependency injection.
- More focus on formalizing the MVP pattern.
- Page composability - build a single page view out of multiple components.
There was also a valuable compare/contrast of the MVC and MVP patterns.
MVP vs MVC
- Integrates well with WebForms (able to use existing controls/services for WebForms)
- Highly decoupled
- Testable out of the box
- More maintainable, extensible
- Fewer moving parts
- Part of Microsoft platform (soon)
- Extra classes and code (view/model interfaces, forwarding functions in views)
Steep learning curve
- Most of the controls and services you’re used to now won’t work. (They’re still working on the control story)
Combine that with the fact that MVP and MVC fit at different architectural levels - MVP picks the view for you, MVC lets you pick the view - and it boils down to just picking the one that works best for you.
Another interesting item: they use WatiN to do their UI automation tests. Not necessarily that being an endorsement, but it surely says something.
Team Factories - David Trowbridge
This was an investigation on how teams can use software factories to work together and more easily come together and work on a well-architected system.
An interesting situation, but it occurred to me how very high the level of discipline in your team would have to be to get this working. I have a feeling it might fail in most environments because, when it comes down to it, a feature needs to be created and someone is going to feel time pressure and just hack the thing together to get it to work. That sort of seat-of-the-pants development, which I do not endorse but acknowledge exists, sort of throws a wrench in the works here.
This was a discussion of what it would take for you to create your own software factory - tools, recipes, etc. - based on the experience of building the Web Service Software Factory.
At a high level, you should expect creating a software factory to take two to three times longer than it would take to create a one-off product. You can expect return on your investment somewhere around the third to fifth instance of factory usage.
If you’re going to do this, they recommend starting with the Web Service Software Factory and customizing/changing from there. Building the Web Service Software Factory took about three and a half months over an eight month period and if you start from the Web Service Software Factory, you can save yourself ~60% of the effort, which goes into software factory platform: model extensions, validation, code generation framework, etc.
Recommendations if you do decide go to this route:
- Have a VS extensibility expert on the team.
- Have an installation expert (WiX) available to the team early on.
- Work with domain experts up front to minimize model changes. Changing the model is expensive.
- Provide drops to your user community early and often.
- Reuse as much of the Web Service Software Factory as you can.