I sometimes struggle with finding a catchy title for a blog post. It has to grab the attention, and clarify what the post is about. If you decided to spend time reading my words, I do not want you to finish ending “if I had known this was the content, I would have done something better with my time”.
For this post, I think the title just sums up the entire post. If you are short on time, you can stop reading now. Seriously.
Feedback from SQL Server Days
Last week I received the feedback from my presentation at the SQL Server Days conference in Belgium, three weeks ago. That was quick – which is great! My kudos to the organization for this very fast turnaround.
As always when I receive feedback for a presentation, the first thing I do is read the comments that attendees have written on the evaluations. I am very happy to say that a lot of people took the opportunity to explain their marks or to give me some tips. Some of them were very positive. One was about the chilly room temperature (and I can only agree to the comment). Some were very sweet. But there were also several comments that I consider to be pointers to me as to where I can improve. Allow me to share a few.
“The session itself was very good however I expected other content.”
By itself, I would consider this a cue to revisit the abstract. But some of the other feedback changes how I interpret this. In this case, I think I spent too much time on content that was not advertised.
“Unfortunately, the time was too short for this session to cover all the speaker wanted to share with us.”
I get that a lot, and I know. I always either run over or have to speed up near the end, no matter how much time I am given. But in this case, again, the other comments put a different perspective on the feedback – they show me clearly where I go wrong and what causes me too run out of time.
“The first part showing the old stuff was too long. One or two of the worst examples was probably enough.”
And this one was followed by four other comments basically saying the same thing. Yes. That message is very clear. When five out of thirteen comments tell me the same thing and two other comments are probably a side effect of the same root cause, I would be a very lousy presenter if I did not take it serious.
“The subject was different from the one announced. This session was a part of the precon I followed some years ago with Bob Beauchemin. I didn’t learn anything new in this session.”
Okay, this comment has nothing to do with the previous one, but I just have to single it out and comment on it. I do not understand the first part; the session title and abstract were all on the web site and on the printed overviews – but I did replace a speaker who had to cancel about a month in advance, so maybe this attendee used a very old version of the schedule?
The rest of the comment is nice. I never attended any precon by Bob, but I do know him, I have attended some of his sessions, and I deeply admire his technical knowledge and presentation skills. If a session written entirely by myself is sufficiently similar to Bob’s material that attendees think I copied it, then that is one of the best complements I can get. I’ll take it!
(For the record: I have never copied other people’s sessions. I de sometimes copy bits and pieces – always with permission of the original author, and I always attribute the material to the original author.)
To understand the comments, you need to know the session. In the session, I show how the OVER clause enables us to solve certain problems. The outline of the session is that I first present the problems with their solutions in SQL Server 2000 (before the OVER clause), then give alternative solutions for SQL Server 2005, 2008, and 2008R2 (where the basic version of the OVER clause is available) and finally present the simple and clean solutions that have become possible in SQL Server 2012, when the windowing extensions to the OVER clause were introduced. In between those demo blocks, I introduce the syntax of the OVER clause.
After reading the comments and with the benefit of 20/20 hindsight, I have to agree. I think I spend about half the available time on SQL Server 2000, 30% on SQL Server 2005-2008R2, and 20% on the SQL Server 2012-2014 stuff. That is not good. There are only very few people left who support SQL Server 2000, and I waste a lot of people’s time by going over syntax and solutions for that version for half an hour.
Root cause analysis
When I need to fix a bug in my code, I do not just dive in head down and start fixing. I have learnt to first step back, analyze the situation, and find the root cause of the problem. Otherwise I end up wasting time fixing a symptom, rather than the problem.
I do the same here.
Obviously, I never set out to make this a session on writing big and ugly queries for SQL Server 2000. I wanted to demonstrate the strength of the OVER clause. And I must also admit that I have been struggling with this session from the first time I did it. The first delivery of this session had a different order – I presented the problems one by one, and kept jumping between SQL Server versions each time I moved to the next problem. After that first delivery I left the stage with an unsatisfied feeling; I never got into the flow while presenting, felt awkward all the time, and knew I had to do some serious rewriting or remove the session from my portfolio. I did actually get some fairly decent feedback to that session, but my own mind told me it was no good, and there’s no point in arguing with my harshest critic.
The version I delivered in Belgium is already the 2.0 version, and a version I have delivered a few times before. When presenting I did feel the flow I normally feel, and I was convinced that, while not my best session, this session is good enough. Until last week. 🙂
So how did a session that I designed to highlight functionality introduced in SQL Server 2005 and enhanced in SQL Server 2012 end up spending (wasting) half the available time on SQL Server 2000? Now that the attendees of SQL Server Days have forced me to think about it, I think I can tell. I wanted to convince the audience of the strength of the OVER clause by demonstrating just how much easier some common problems are solved now, as compared to before. That choice was what drove the session design, both the 1.0 and the 2.0 versions. Take a common problem, show the ugly code that was needed to solve this problem back when I was still a young Adonis (“cough”), then show how OVER makes the world a better place. But the problem here, is that the queries for SQL Server 2000 are very complex, and very convoluted. To me, it felt wrong to show complex code without giving any explanation. So when presenting the demos, I take the time to highlight how the queries are built, why they are built that way, and why they could not be simplified.
With very complex queries for four different problems, all those explanations add up, and end up taking way too much time. Time spent on explanations that benefit nobody. What a waste!
Fix it (Felix)
Now that I know where I went wrong, I can set out to fixing it. One option is of course to retire the session, but that is not an option I ever seriously considered. The OVER clause is a great feature, and I have a good story to tell about it. I just need to find the right way to tell it.
My first plan was to do another total overhaul, create a version 3.0 of this session. I already had some rough ideas forming in my head. Not a total new session yet, just first thoughts – more time is needed before this will evolve into a new session.
And then I realized that I have no time for this. In just a week from now, I will be in Portland, at SQL Saturday Oregon, and I will present there. The chosen session? You got it: “Powerful T-SQL Improvements that Reduce Query Complexity” – the same session I did at the SQL Server Days. One week is not enough time for a full overhaul. Plus, I have to deliver a session that matches the abstract (and hence the expectations of the attendees) next week, and a full overhaul cannot guarantee that.
So instead of a 3.0 version, I will update my existing version to a 2.5 version. The rough outline will remain the same, but I will severely cut back on the “old” part. I will not show all the demos for that, and definitely not explain as much as I did before. I will only briefly outline why the queries needed to be so complex, without going into details. I will then spend more time on the SQL Server 2005 stuff, because this is still relevant to the large number of people still working on 2005, 2008, and 2008R2. But I plan to spend way more time than before on the enhancements that have become available in SQL Server 2012. In the next week, I will go over my slides and demo code and see what I need to change there in order to support the 2.5 version – probably not much (it’s just a point release, after all), but I need to make sure that slides and demos will help me keep the pace just right, not get in my way.
A complete rewrite may still be needed. That depends on the feedback I receive next week, both from my harshest critic (that little voice in the back of my head), and from the attendees. I don’t know if there will be official feedback forms in Portland, but I accept feedback from all sources: conversations, emails, comments on my blog, twitter, and whatever other means you can think of. If the gist of the feedback is that the session is great, I will it as is, but if attendees think it is still not as good as it should be, I will definitely start working on that 3.0 version.
I started the blog by saying that you don’t need to read it – just the title is enough. If you ignored me and did continue to read until here, you will probably see that I am right.
Giving speakers feedback does make a difference. Your feedback has opened my eyes to the flaws in my session on the OVER clause, and has convince me that I need to change it. And it will again be your feedback on the updated version that will tell me whether my changes were sufficient, or more work is needed.
Speakers give you a lot. They sacrifice their time (a lot of it – only those who ever created a presentation from scratch will really know just how much time that takes!) to share their knowledge with you, often for no more reward than a free entrance pass to the conference. The least you can do as a reward is to give them your feedback. Be positive when they deserve it. And be constructive when they can improve. If you don’t tell us, we will never know!
Great feedback processing, Hugo.
I attended that session and enjoyed it very much.
Whatever you do and however you rework it, please keep the last comparison of the queries as they used to be (especially the SQL2000 one !) and how the over-clause(-evolution) simplifies it all !
Thanks for your comment, Johan! I am glad that you liked my presentation!
I can promise that the 2.5 version will still have the comparisons between old (2000 and before), in between (2005 – 2008R2), and new (2012 and up).
Not sure about the 3.0 version, if there is going to be one. I, too, like contrasting the queries (especially the one at the end that combines all techniques). But it has to fit in the flow and the buildup of the total session. If I am going to rewrite from scratch, I have to be prepared to, as I’ve heard book authors call it, "kill my darlings".
Good to see someone showing how they use feedback!
I’m nowhere near on your level Hugo, and I think you have courage to publicly discuss where a presentation you gave went off the rails a bit. Congratulations!
It sounds formulaic, but one way I’ve dealt with situations like this — where you have a lot of messy, complicated subject matter that is relevant in its entirety, but not in the details — is to say exactly that beforehand:
"These queries used to be ugly to write and slow to perform in SQL 2000. I’m going to quickly flash a few examples up on the screen for you, without walking through the logic of them specifically. I’ll highlight major code sections, then quickly move on to how windowing functions do the job better."
That way you can walk them through the history, give them the details in the slide deck if they want to reproduce it themselves later, but not get mired down.
If this is appropriate, you could even brightly color-shade or somehow annotate various blocks of the T-SQL (not with SSMS, using bold color backgrounds or arrows or something) the main 2 or 3 sections of the SQL 200 queries. Maybe you could color the background of a correlated subquery in bright blue with a note: "This gets the top 2 rows for each group and joins back to the main query."
Just brainstorming here. I ALWAYS learn something from your posts on SSC — thank you!