Last Thursday (6/23/2011) I had the privilege of delivering my new talk, “CQRS: Crack for Architecture Addicts or an Idea Whose Time Has Come?” to the Philadelphia-area ALT.NET user group. This was my first delivery of this new talk in my repertoire and overall I think it was pretty well received (at least based on the feedback from attendees that night). For whatever reason, Philly ALT.NET has become a sort of a test-bed for some of my new talks – about 18 months ago the Philly ALT.NET group was venue in which I first delivered my “Domain Driven Design Implementation Patterns in .NET” talk in its single-session format (prior to that I had only delivered it as two separate talks, the first talk all theory and concepts and the second talk almost all code).
Perhaps there’s something about Philly ALT.NET that makes me want to experiment with new content…or maybe its just that I can high-tail it out of there to drive back to NYC afterwards so if a new talk is a complete failure I can safely head for the hills and avoid the mob of pitchfork-wielding developers demanding my head on a pike if my talk sucks .
All kidding aside, I’m not really certain just exactly why I seem to have a history of testing new content on Philly ALT.NET, but in a sense they benefit from my willingness to experiment with them.
Man, Can I Talk for A Looooong Time!
Since this was a completely new talk for me, I’d not really had any past experience with how long it would take to deliver this content. But one thing that I did know for certain was that with 50+ slides there was no way it was going to fit into an hour . I’d rehearsed the delivery of the content (both the slides and the code walk-through) beforehand and came up with about 2 hours for the talk. When you folded in Q+A both during and after the content, it ended up taking about 2.5-3 hours to deliver the talk.
This is (of course) significantly longer than most (all?) user group presentations and it almost entirely rules it out as a talk that could ever be delivered at any event with a pre-defined time-slot (i.e., CodeCamps, etc.) unless 2 back-to-back session slots were allocated for it but if you’re in the mood for what is basically almost a half-day seminar on CQRS, then this talk might be for you!
This is in fact the very same problem with the aforementioned Domain Driven Design Implementation Patterns in .NET talk – its just infeasible to try to fit it into anything shorter than about 2.5 hours. To the credit of most of the attendees, nearly all of them stuck with me until the bitter end (9:30pm or so!) so I’m not quite ready to conclude that the talk is too long, just that its longer than a ‘typical’ talk. I suppose that after sitting through my 3-hour Domain Driven Design Implementation Patterns in .NET talk and now this one, Philly ALT.NET attendees are probably starting to understand that asking me to come speak means surrendering about 3 hours of your life to learning about new things . I’m probably starting to be known down in that area as “the 3-hour talk guy”, but I suppose that so long as that’s also “the 3-hour valuable content guy”, I think I can live with the reputation. Fortunately, the comments I received from attendees seem to imply that they got a lot of value out of the talk and weren’t disappointed by losing three hours of their lives, so I’m thinking that on balance this talk was a success.
Beta Presentation: Room For Improvement
I began the talk by telling the room that this presentation is still very much a work-in-progress. Of course, I like to think that every time I deliver a talk I learn about something else that can be tweaked to improve the next delivery of the same content, but in the case of this being the first delivery, things were much more in flux than for a talk I may have given multiple times prior. Overall, the feedback was very positive, but there were also some comments that pointed out areas for improvement.
One comment that I took to heart was that the content is too front-loaded with slides and back-loaded with code. Anyone who has seen most of my talks knows that I usually prefer to flip back and forth between slides and code during the entirety of my presentation rather than the often more common approach of “all slides up front followed by all code at the end”. I find its more engaging (and effective!) for the audience to see slides that introduce a concept and then flip to explore code that demonstrates the concept in practice before returning to the slides to introduce the next concept.
With this talk, I abandoned that tried-and-true approach of intermingling code with slides and went with all-slides-up-front followed by all-code-at-the-end. My reasoning for this was that I felt strongly that there were enough new concepts to introduce with CQRS that it would be important to lay a solid foundation of understanding them in their entirety before trying to fully grok parts of a code sample. I still feel this to be a challenge with explaining CQRS to audiences, but I’m not convinced that solving it as I did here by massively front-loading the presentation with slides is really the right answer.
As developers, we are probably hard-wired to want to see code ASAP and I think that too many concepts introduced before we see this code probably risks losing our interest and our focus (though I give the Philly ALT.NET audience big props for sticking it out with me as we plugged through the 50+ slides up front!). I definitely need to rethink a way to have a sample with small subsets of the code that we can explore to reinforce each of the concepts as they are explained rather than trying to ramp up on all the concepts and then exploring a comprehensive sample that demonstrates all of the concepts at once. Its pretty clear to me that my present choice of ‘CQRS Sample App’ probably isn’t the right choice to show people individual discrete CQRS concepts one at a time so this is an area where I feel I probably need to rethink things a bit in re: what I use as my sample as we move through the slides.
Live and learn – the Agile tenet of Continuous Introspection and Improvement is alive and well in this process!
Slides, Code, and other References
For those interested in the slides from this talk, they can be downloaded here.
The links in the final reference slide (which also include the code sample(s) used in the talk) are reproduced here for convenience:
Central Hub for All Things CQRS: http://www.cqrsinfo.com
Udi Dahan’s on CQRS (et. al.): http://www.udidahan.com/2009/12/09/clarified-cqrs/
Simple CQRS Sample Application: https://github.com/gregoryyoung/m-r
Comprehensive CQRS Sample Application: https://github.com/MarkNijhof/Fohjin
Jonathan Oliver’s Post on his Event Store project: http://blog.jonathanoliver.com/2010/07/cqrs-event-store/
Rinat Abdulluin on Getting Started with CQRS: http://abdullin.com/cqrs/
Greg Young on Testing Your Domain Using Events (video): http://skillsmatter.com/podcast/design-architecture/talk-from-greg-young
As mentioned, if you attended this talk and have constructive feedback to offer, I’d be very appreciative if you visited http://spkr8.com/t/7876 and provided a rating, comments, or both!
And if you’re going to be in the area, I am scheduled to (re)deliver this same presentation several times:
- New York City Domain Driven Design User Group July 6th, 2011
- Central New Jersey .NET User Group on September 8th, 2011 (not listed on their site yet, but stay tuned as the date approaches for the RSVPs to open up)
I’d love to see you there at one of these events if you’re interested in the content but missed the Philly ALT.NET meeting (but bring a comfortable chair since it’s a 2+ hour talk!)