Last week, Adam posted the feedback he received from PASS on the abstracts he had submitted for the PASS Summit 2014. I was very happy he did – not only because the post itself was a good read, but also because I had not seen the PASS announcement on making the feedback available (I did see it in a PASS community mail a few days later, though).

I can imagine that not everyone will want to see this feedback, but I do. I love harsh criticism, as long as it’s fair – that’s how I can learn and improve. (The written comments are always my favorite part of the session feedback from conferences where I have spoken). So I have followed Adam’s lead and requested a copy of the feedback on my abstracts. And I will continue to follow Adam, by posting the feedback here – that way, all of the community can learn from my mistakes, instead of just me.

Understanding Execution Plans [full day, level 400] (not accepted)

For troubleshooting long running queries, looking at the execution plan is often a good starting point. Once you know how the query is executed, you know why it’s slow and what you can do to speed it up.
But what if the execution plan is just beyond your understanding? What if it uses operators you have seen before, but do not really understand? What if you look at the execution plan, but just don’t see the problem?
In this full-day workshop, you will learn everything you need to be able to read and understand any execution plan. We’ll start with an overview of execution plans as a whole, and then dive in and look at all the components, and how they fit together. This will increase your understanding on why the optimizer picks a plan, and what you can do to make it pick a better plan.
Whether you have read your share of execution plans or whether you wouldn’t know where to find them, this workshop will teach you everything you need to know about execution plans. Attend this workshop if you want to hone your tuning skills!
Throughout the day, we will have exercises to help you get an even better understanding of the theory. In order to get the most out of the day, attendees are encouraged to bring their own laptop, with SQL Server (any version), Management Studio, and the AdventureWorks sample database installed.

• This sounds a great topic and a good advanced level. I notice it was presented at 300 level in Copenhagen and this time it’s aimed at 400 level. Hopefully it will not start too advanced for the audience. – great abstract. maybe more demo time??
  One of the learning outcomes is “Understand how to read execution plans.” – hopefully at level 400 people who know how to do this already
• Good abstract, very good idea for a session.
• The topic is very important for any developer and looks like the presenter will be very well trained on this session as it is being presented in three other major conferences.
• well written abstratc with good level of details. interetsing topic – but i dont see ay references to updates in sql server 2014. goals are clear. demo % could be higher for this topic.
• Yay for audience participation.
  In the future, when noting this session has been presented at SQL Saturdays, please note if it was presented as a full-day pre-conference or as a normal session as normal SQL Saturday sessions do not match the length of a full session.

Setting the level in an abstract is a constant struggle for me. Is a session only 500 level if only MVPs have a chance of understanding it, and if people walk out with brain damage? If a presenter is able to take the most complex subject matter and explain it in a way that can be understood by everyone, is this a 200 or 300 level session because the intended audience can be relatively new, or is still a 500 level session because the subject matter is deep and advanced? Because of this struggle, I often adjust the level when submitting the same session. In Copenhagen, I got feedback that it was more advanced than the audience expected, so I adjusted. The goal of the session is to ensure that even people who have little experience with execution plans can learn to read them (hence the learning outcome), and then continue to dig deeper where most sessions stop (hence the advanced level). This can be seen as sitting uncomfortably between two stools, or as killing two birds with one stone. I think that the session achieves the latter – but I apparently fail to explain that well enough in the abstract.
Even for a full day session, time is a constraint. I had to choose between more demos and more room for new content, or more coverage of the basic content. I chose the latter (even the SQL 2012 content is just the last 30 minutes or so), and I stand by that choice, but I realize that everyone has their own preferences.
When I put in where I presented the session before, I assumed that is would be obvious that this were pre-cons for SQL Saturdays – otherwise it would not be the same session. But it was apparently not clear at all. I should have been more specific.

Lessons learned:
Make sure the abstract reflects that people can come in with little previous knowledge, but will still leave with advanced understanding.
Be careful with assumptions.

A New Method for Effective Database Design [full day, level 200] (not accepted)

Your databases may be normalized and may perform well … but is the data actually correct?
Hidden pitfalls abound even in seemingly-mature database designs. Complexity, overabstraction, and miscommunication, can create situations where data simply can’t meet expectations.
In this full-day seminar, you will learn how to use a requirements-based methodology to translate you users’ real business problems into a rock-solid database design. You will learn exactly what questions to ask, how to ask them, and how to transform the answers into a fully normalized database that accurately captures all the business requirements.
If you have ever experienced problems due to bad database design, attend this seminar to make sure that never happens again.

• Good outcomes – sounds appealing
• One typo “to translate you” rather than “your”.  I really like this session idea, though I can’t really foresee what the “new” method might be.  Definitely sounds like the only method I know of. Expect it would be quite good.
• This is a very important topic.
• Seems the presenter can pull this off quite nicely.
• Great topic
• interesting topic. decent abstract. clear goals. low % of demos for a full day session
• Abstract is for a full-day session and the submitter notes they have presented the session at SQL Saturdays and SQLBits.  One is not able to compare these due to the massive difference in the session length.

Hmmm, this is a challenge. The abstract apparently fails to make it clear that the method I present here is indeed very different from traditional database design methods. I remember a previous version of the abstract that was rather boring and technical and got rejected all the time. I tried to spiffy it up and make it sound more appealing, but when I now reread it, it does sound a lot like the marketing speak I see and hear from advocates of other methods. I’ll have to redo this one for the next time, find a middle ground between accurate but bring, and spiffy marketing speak.
I agree with the demo remark, and I would love to do more demos, and maybe some classroom exercises, but the subject is simply too big for that. Maybe if I can present both Monday and Tuesday? 😉
And I again caused confusion by including references to previous deliveries without explicitly mentioning that it was a precon at those events as well. Too bad: with the mostly positive other comments, I feel that this is the only reason that this session was not selected.

Lessons learned:
Abstract should contain some “near-marketing” speak to make it sound appealing, but I have gone overboard. I failed to really explain what is new and special about the presented method.
And, again, make very clear that the other deliveries were precons as well.

T-SQL User-Defined Functions, or: Bad Performance Made Easy [general session, level 300] (accepted)

User-defined functions in SQL Server are very much like custom methods and properties in .Net languages. At first sight, they seem to be the perfect tool to introduce code encapsulation and reuse in T-SQL. So why is this feature mostly avoided by all T-SQL gurus?
The reason is performance. In this session, you will learn how user-defined functions feed the optimizer with misleading and insufficient information, how the optimizer fails to use even what little information it has, and how this can lead to shocking query performance.
However, you will also see that there is a way to avoid the problems. With just a little extra effort, you can reap the benefits of code encapsulation and reuse, and still get good performance.

• Should be a good session – I would attend.
• Very good abstract, and a decent idea for a session. I like that it includes positive benefits along with the bad effects as functions aren’t all bad in all cases. I think you have a typo in the notes, as  you say it got a 4.73 on a 15 scale 🙂
• This session looks very good. We always hear how UDFs are bad for performance but never what we can do about it. Having a session that shows that can be very good.
• Well written with clear and concise goals.
• good topic. great abstract. clear goals. exciting to see session with 100% demos

Thanks for the kind words. And yeah, that 4.73 was on a 1-5 scale, missed the dash.
I hope the last reviewer will not be disappointed when the actual demo percentage is about 95% (the PASS submission form has a dropdown for the demo percentage with 0%, 25%, 50%, 75%, or 100%, so I had to round).

Lessons learned:
Looks like this abstract, apart from the typo, can remain unchanged.

Now Where Did THAT Estimate Come From? [general session, level 500] (not accepted)

The SQL Server Query Optimizer makes its plan choices based on estimated rowcounts. If those estimates are wrong, the optimizer will very likely produce a poor plan. And there’s nothing you can do about it. Or is there?
In this session, you will learn exactly where these estimates come from. You will gain intimate knowledge of how statistics are built and maintained and how they are used to estimate row counts. But you will also learn how filters and joins influence those estimates.
Though the focus of this session is on understanding the cause of bad estimates, you will also learn ways to fix the problems and get better estimates – and hence, better performing queries.

• 500 level session and the pre-requisits seem to make it clear that prior knowledge is essential. I hope the presenter can do justice to this – that would be my main concern.
• I wish the title make it more clear that we were talking about the optimizer, but for a 500 level session, perhaps that isn’t needed. “Though the focus of this session is on understanding the cause of bad estimates” I guess I see that, but really the session is about where estimates come from based on the rest of the abstract, and where a bad one comes from is just an offshoot of that.
• The abstract looks solid. The goals are aligned with the abstract and also look solid.
• Abstract gives a clear picture of what to expect.  Goals could be better defined.  Is this truly a 500 level?
• Type-o in Session Prerequisite, “sold” should be “solid”.
• Doubtful if this 500
• interesting title. good topic – revevant for senior dbas or developers interesting in an indepth understanding of execution plans. abstract has good level of depth goals are terse but convey the necessary details. high % of demo is good.

Again the level problem, and I must admit that I was, and still am, in doubt on whether to present this as level 400 or 500.
The “can do justice” remark makes me wonder if this is from a reviewer who got only the abstract, or the abstract and my name. In other words, are these doubts based on the abstract, or based on a perception of my understanding of and ability to explain the subject? I would love to get into contact with this reviewer (mail me, please!). No hard feelings, I am just curious to understand where this opinion comes from and how I can improve.
The remark on “talking about the optimizer” is interesting. That is NOT what I talk about in this session, but I see what part of the abstract results in this misconception. I need to rewrite that. And yes, you are completely right that the focus is on where estimates come from, not just bad estimates, so I will definitely steal those words for my v2 abstract.

Lesson learned:
Focus the abstract on the actual content, not on related content.

Normalization Beyond Third Normal Form [general session, level 400] (not accepted)

Do you believe the myths that “Third Normal Form is good enough”, or that “Higher Normal Forms are hard to understand”?
Do you believe the people who claim that these statements are myths?
Or do you prefer to form your own opinion?
If you take database design seriously, you cannot afford to miss this session. You will get a clear and easy to understand overview of all the higher Normal Forms: what they are, how to check if they are met, and what consequences their violations can have. This will arm you with the knowledge to reject the myths about higher Normal Forms. But, more important: it will make you a better designer!

• This is a good academic session – but not sure about it’s real world application – a totlal theoretical discussion (based on the fact it has 0% demos) may not hold peoples interest for too long.
• Database design is my favorite topic, and one I think db devs need to know more about. My only problem with this abstract is that it feels way overreaching to cover all of these normal forms at a 100 level where 1, 2 and 3 aren’t even going to be understood all that well.
• Looks very interesting. I suppose this is something we all should learn about. Looks the abstract covers a lot of material and while is 100% theory it is theory that must be learned anyway.
• Love the topic. Abstractand Goals tend to “preach” one side of the story.Real-world examples would be helpful.
• Not sure this is 100 level,
• routine topic. abstract and topic dont show anything new or exciting for sql 2012 or 2014. The sessions seems all theory and has no demos. This may not be of much appeal and interest to audience
• Zero demonstration time.
• While the abstract is presented as a 100-level; the abstract description and goals are 200-level.

I always prepare abstracts in a Word document, and then copy the content on the submission form. And in this case I must have made a mistake in the level selection. I intended to submit this as a level 400 session, not as level 100. Oops.
What is a demo? Is it only a demo if the presenter sits behind the laptop, opens Management Studio, and executes T-SQL code? Or can you consider applying normalization rules to a concrete example of a database design, even if it’s on pre-made Powerpoint slides, as a demo too? The reviewers seem to say “yes” to the last option; I thought “no” when I submitted.
The “abstract and topic dont show anything new or exciting for sql 2012 or 2014” comment is the only remark in all the feedback that I can’t use in any way to improve myself. The subject of database design is not related to a version of SQL Server, not even to SQL Server itself. I could present this session on a conference on any relational database and it would be equally useful.

Lessons learned:
When the session submission form is completed, “check, check and check again” is not sufficient; I probably should wait a day and then check three times more (or just learn not to make such sloppy mistakes).
All real-world examples (or made up but realistic examples) are demos. Even if I am still in Powerpoint.

Inside the Nonclustered Columnstore Index [general session, level 400] (not accepted)

You have heard the marketing speak. You may have seen the demos. And maybe you have even played with the feature: Columnstore indexes, the amazing “go faster” switch in SQL Server 2012!
But do you know how they work? Come to this session to find out. We will lift the hood to give you a fascinating in-depth view of how Columnstore indexes are built and read, how batch-mode execution operates, and how these features work together to achieve an amazing performance boost.

• Topic should be well received
• Thanks for the abstract, it’s good to have someone speaking on columnstore Index, also it would be great if we can include some real examples and demo.since there is no any demo.
  Thanks

I must have made another mistake – not visible in the feedback, but in the mail I got with the results this was listed as a half-day session. I entered this as a normal (75 minute) session in my Word document.
No demo (or rather 10%, but I had to round to either 0 or 25) is a result of my choice to cover the internals in depth. Most internals can’t be shown in demos. I love seeing lots of demos in the sessions I attend, so I fully understand the reviewer. But I am also convinced that adding more demos would not improve the quality of this specific session. If that reduces the chance to be accepted, then so be it. I rather present the best possible session at only a few events than a watered down version at more places.
That being said, I probably should not have submitted this session, and I will not submit it anymore to other conferences. The nonclustered columnstore was SQL Server 2012, and is now sort of obsolete. SQL Server 2014 was not released yet when I submitted my abstracts, but I knew it was coming and I knew that it would bring the improved, clustered version of the columnstore index – this session is old news. I love this session and I regret having to decommission it. But this session is now about as relevant as a session on the internals of English Query.

Lessons learned:
Once more: check, check, double check – and then check again.
No matter how much I love a session, when it’s time has come I must no longer submit it.

Powerful T-SQL Improvements that Reduce Query Complexity [general session, level 300] (not accepted)

We’ve all dealt with nightmare queries: huge, twisted monsters that somehow work, despite being ugly and unmanageable. The time has come to tame these beasts, and the solution is available now, in SQL Server 2012.
New T-SQL functions offer out-of-the-box solutions for many problems that previously required complex workarounds. Paging, Running totals, Moving aggregates, YTD, and much more comes at the power of your fingertips in SQL Server 2012. The only thing you need to do is learn the syntax. And that is exactly what this session is all about: a thorough description and explanation of the syntax, and loads of demos to demonstrate how you can use all these new features.
Attend this session to boldly take SQL Server where it has never gone before!

• I like the abstract it informs attendees of some of the things that they can expect to learn.
• The title of the session is kind of vague, since whereas the windowing functions are useful TSQL improvements, they are not the only ones that are available throughout time. Would have gotten a better review if the title was more specific to windowing functions and 2012.
• Looks good. If selected I would encourage the presenter to include/replace some aspects of it with SQL 2014 features that also help to improve how queries are written.
• interesting topic and catchy session name. abstract is very well written and points out sql server 2012 features – relevant and current. good level of details in the goals and good balance of demo %
• The session name is somewhat misleading for what appears to be a “Windowing Functions” presentation.

Thanks for calling the title catchy. I like it too. But the comments of three other reviewers make me painfully aware that this title fails to deliver on the most important function of a title: it does not give the conference visitor an “at a glance” idea of the broad subject matter. Yes, all abstracts are available. But how many conference attendees read them all? I don’t, that’s for sure! I use the titles to filter down to just two or three promising sessions, then read the abstracts (if I have time – otherwise I pick based on title alone!) There were indeed more improvements in SQL 2012, and then there are even more in SQL 2014. Based on the title, I myself would expect to see them covered.

Lesson learned:
I already knew this but failed to apply the lesson: session titles should be catchy, but should also set a correct expectation for the audience.

And that concludes another long post. Thanks to all the volunteers who spent countless hours on the unthankful task of reading through hundreds of abstracts, commenting on them, selecting between sessions that are almost impossible to compare with nothing more to go on than a few hundred words in the abstract. Your hard work is much appreciated; the PASS Summit would not be possible without people like you. So thanks!

And I like to conclude this post with the same words that Adam has at the end of his: Have any additional feedback for me? Post it below!