For the rest in the posts in this series please see the series index.

Today was a very busy day which started off with touching up the slide deck with a little more content and adding touches of animation to the slides. One thing I have learnt is that every time a change happens on screen, be it slide change or animation, the audience looks at that and since people can’t multi-task, they stop listening to you. So while animations and transitions may look flashy they must be used with care or you risk having long pauses or the audience ignoring you.

For this presentation there are a few slides where I want to take the audience step by step through a process as I narrate it to them, however for the rest of the slides there is no animations. Often on very wordy slides people will bring in the content, line by line so that the audience doesn’t get ahead of the speaker. For me I have text, I dump the entire text on the screen at once, which may seem odd since everyone will start reading it. However I would rather have a 5sec pause between slides while people digest the new slide over ten 1sec pauses during the slide as they switch between me and the new text that just appeared courtesy of some animation.

Slide deck at the end of day 5

The next stage is to get my demo script written. To do this I take the demo shell and step by step write out exactly what should occur.

Part of the demo script for one of the demo’s

Normally I do not need this guide, as I will have practised a the demo’s few times and will have it almost memorised, but it is worth creating for five reasons:

1. If I need to present in the future, I do not need to try and remember what I did. I just read the script, practise and I am ready to go.
2. When I hand out the presentation, people who look over it can read the script and recreate the demo’s themselves if they choose.
3. I use a tool to help me with my text (which I will discuss in a future blog post) but if something goes wrong with that tool then the code I need is backed up in the demo script.
4. In preparing the script I need to run through my demo’s, this gives me my first chance to catch bugs and resolve issues in the demo’s before I get to my dry runs!
5. Finally it also acts as a sounding board for the demo’s themselves. For example during creation of the script today, I took one demo and split it into two demo’s because it was just getting too much to do all at once.

For the rest in the posts in this series please see the series index.

What a day, when I said yesterday that I could feel it coming together, I did not expect that it would be so fast and now at the end of day 4 the fundamental slides are done! Changes to point out for those who are watching the slides evolve:

• The slides I mentioned on day 2 that were in danger of going away, are gone.
• I moved the demo’s after the explanations – I have done this because this is such a complicated topic and so I need to do the explaining upfront so that I do not lose people in the demo. Normally I prefer the opposite as it adds more excitement to the presentation.
• Another demo has been added – the slide on debugging I just can’t explain well enough in words so that will be a demo now.
• Added 5 slides with code in, these are a great alternatives to demo’s because they don’t break (like demo’s can), can keep the session moving forward and not getting bogged down in too many demos and animation can help illustrate the code. I am not using animation here but it is an option. The risk of these code slides is that if you only have them, it may bore the audience. For them I am using them to illustrate alternatives to the demo I will do earlier in the presentation, this seem to be the nice trade off between entertaining demos and getting through it all.
• References is hidden now, if people need to see it they can ask or download the slides. No one will be able to copy that many references down during a presentation anyway.

Slides at the end of day 4

I am very excited that at midnight we shipped the latest Rangers solution the VM Factory!

What is the Visual Studio 2010 and Team Foundation Server 2010 VM Factory?
The purpose of this project is to build prescriptive guidance around the virtualization of the Visual Studio 2010 and guidance for full automation of the creation of virtual machines. The goal is to help users with the installation and configuration of virtualized environments with least effort and maximum automation.

You can download it from Codeplex

What is in the package?

The download package consists of two ZIP package downloads:

• Rangers Virtualization Guidance
  • Focused guidance on creating a Rangers base image manually and introduction of PowerShell scripts to automate many of the configuration tasks.
  • Virtualization guidance looking at the “why” and “how” to use virtualization for Team Foundation Server and Visual Studio, including planning, pre-requisite software, use of non-Microsoft virtualization technologies and introducing use case scenarios.
• Rangers Factory Package and Guidance
  • Reference walk-through documentation on how to install, configure and support a Microsoft internal or an external factory to automate the installation of Team Foundation Server and Visual Studio environments.
  • Microsoft Deployment Toolkit metadata and PowerShell scripts used to create a Rangers factory.

The two little secrets of this is that the guidance, while targeting specific products on VM’s can actually be used as a base for non-VM scenarios and as since products like TFS use a lot of core services, for example SQL, there is a lot that can be used to build on for working with other products. The other secret is that a lot of the PowerShell scripts here are my own work, so I am very excited to see them get used and get some feedback on them!

For the rest in the posts in this series please see the series index.

Today’s work focused on the final reference demo for my presentation. For this presentation I need two, first a simple one to get the basic concepts understood and then a second which is much more complex and tougher for me to code. This is not quick task as just this reference demo took me almost 6 hours to get it to the point I was happy. Often during the building of the reference demo’s two side effects occur. The first is that I am learning, so I get the chance to find solutions and blog about them.

The second side effect, is that it makes me think of what sort of questions will be asked during the presentation. It is very important to spend time thinking about this, because while things may seem obvious to me they may not be to other people. Remember that your presentation doesn’t end with the slides – questions afterwards are part of it too and you need to prepare for them.

One of the ways I research is to post questions to StackOverflow

Once I have the reference demos built, I can then take that and build a new application from it – this new application will be the core for the actual demos. This is a tough exercise because I need to separate out the important code from the the bit’s that are needed but do not help enlighten the audience. For example if I had a WinForms app as a base for a demo, I will often have the UI built but I will not have all the events hooked up.

The next step is to figure out the the best way to explain the important code, that could mean typing it in during the demo, copy and paste or even simple un-commenting of code – what ever works best for the scenario as each has various trade offs. After I have done this exercise, I will have one fully developed application and one shell of an application for each demo.

What the reference demo code looks that I built earlier

What the demo shell for the same code looks like – note much less code, not comments etc… a clean slate.

Once I had finished my application base today I went back to the slide deck again. It is quickly changing from being a story board to becoming a slide deck as I work on the content and flow more. For this presentation I can feel I am over the big hump of “what” and starts to come together quicker.

Slide deck at the end of day 3

For the rest in the posts in this series please see the series index.

So today marks the first full day on this presentation, yesterday I only invested about 4 hours work into the solution. Most of today was spent on building the reference for my demo’s. This is a functioning demo system that includes many ideas and concepts and is something I build on. This code won’t be the actual demo code because once I have this I can break it down and  build my actual demo’s off it.

The reference demo gives me an opportunity to take my ideas, try them out, learn a lot about the issues and enables me to cherry pick scenarios for actual demos. For this presentation the core idea for my demo’s is working what prime numbers are there below a specified ceiling number. To start I coded the solution without any threading, then figured out various different ways of using threads and thread pools to enable threading.

Coding demo’s away in Visual Studio 2010

Once I had those first few done, I went back to the slide deck and started thinking about the order of the slides, where I want demo’s and what the flow will be and finally there is also a bit of cleanup of the slides. One of the things is that this is a process, and so changes occur. Some are small but have big impact like changing the title from Threading to Multi-Threading because that reflects the core theme better and will help people decide if they want to be attend the session. Some may seem more radical, like dropping a few ideas from this already because as the timing and theme seep out they do not fit well anymore. This is to be expected – a lot of this creative work is destructive and this screen shot of the slides at the end of the day, doesn’t tell you how many slides I created to just delete 15min later.

This brings me to another tip, which is always find out when the last possible date is to submit the title and description for your session is. Often your original presentation title/description will change and being stuck with the old ones will either force you down the wrong path or will annoy your audience when they arrive to find the session is not what they expect.

The slides at the end of day 2 – those on the bottom row are in danger of “being voted off the island”, but I am trying to hold on to them because they look so good.

Seems that in the last week, and just in time for me to be in Canada where they have bandwidth, that a bunch of things have become available for download which deserve your attention:

VS 2010 Quick Reference Guidance is now out!

Plus hotfix 1 for it

Visual Studio Team Foundation Server 2010 Upgrade Guidance is now out!

The new Nokia 5800 firmware (40.0.0.5) is out – which brings it up to the level of the X6 in features now!

Lastly, and sneakily at the end of this post, my latest open source tool is out. Now I am not going to tell you what it is, but it is for presenters (mostly) and requires .NET 4.0 Beta 2 and Windows 7. Hopefully the name will entice you to check out Rule 18!

For the rest in the posts in this series please see the series index.

I tend to do a lot of presentations for work and in my free time too, and over the past few years though trial and error and presentation courses, I have had to learn a bunch of tricks to prepare for a presentation. What I am hoping to do with this series of posts, is to catalogue, each day, what I have to do in preparation for a specific session. The hope is that through this maybe my tricks can be help you in the future.

The first tip I can impart is that I never get up in a morning, prep a presentation and give it the same day. Why? because to properly prepare, even a short presentation can take days to get right and the more technical or complex the topic the longer it can take. The presentation I will build over this series ended up as a two hour presentation, however it took me almost SIX days of preparation for it.

Currently our team is using Basecamp for task management.

The easiest part of preparing a presentation is getting a topic, because all I need to do is go to my task list and see what has been assigned to me, in this case it is .NET Threading. Based on the type, this case it is a Technical Readiness (TR) session, I know what type of audience to expect and what level but I have no other ideas of how long it will be, will I present using demos, slides, both or neither or anything else, this will all seep out of the process.

The way I start with an presentation is to fire up PowerPoint and start dumping ideas on to slides. What I am doing here is NOT creating content, although some of it will remain as content in the finished presentation.What I am actually doing is setting up a story board for my thoughts. PowerPoint works great as a story board system and it has the benefit that later on, the content that remains does not have to be recreated. At this point there is no spell or grammar checking or animations.

However there are three things in the story board at this stage:

• Thoughts, these are slides with just titles or a few words. They represent something I think I should bring up but have not got content for it yet.
• Basic content, while it is a story board there is some basic content (often messy and unstructured) that I think will be useful.
• Mistakes, I make loads of mistakes – which is a good thing because I will go through the tough learning and make the mistakes so that others so not need to.

The day 1 story board of my presentation

The actual process of getting content for a presentation is fairly mundane. It involves searching on Google, StackOverflow and SlideShare, and adding information I have already.

Slightly for my own memory (since I will forget in future and at least it's available here), but for an upcoming training session which I am presenting, I wanted to be able to inline a method when using the .NET ThreadPool’s QueueUserWorkItem method which requires a WaitCallback pointing to a method. I did this using the lambda expression support in .NET 3.0+ and it looks like this:

static void Main(string[] args)
{
    Console.WriteLine("Starting up");

    ThreadPool.QueueUserWorkItem(new WaitCallback(f =>
    {
        Console.WriteLine("Hello for thread");
        Thread.Sleep(500);
        Console.WriteLine("Bye from thread");
    }));

    Console.ReadKey();
}

I have been writing some multi-threaded code recently where I was initially adding items to the .NET ListBox control and then later changed to the ListView control. In both cases my code I would get a StackOverflow exception fairly consistently when I added the 224th item (my first two items I added manually so it was the 222nd item added via a separate thread). The first troubleshooting tip is that you do not have an infinite loop, which I could confirm that it did not have.

So the first thing I tried, was to limit the number of items which would be added with each button click. Doing this enabled me to go well over the 224/222 limit from before – thus eliminating any thoughts of limit on the number of items the controls could handle.

After some other failed tests I found out it was how I was handling the cross thread communication, being that I had a separate thread add the items to the control which was created on the applications main thread. To handle to cross threaded communication I kept calling this.BeginInvoke, however I never called this.EndInvoke which a lot of places seem to say it is fine. However at some point it will fail, with the StackOverflow exception – that point is dependant on a number of factors (including the worst factor of all: timing, making this one of those issues that may only appear in the field).

My solution was simple, change the standard this.Invoke method and the issue went away.

For the search engines the full exception is “An unhandled exception of type 'System.StackOverflowException' occurred in System.Windows.Forms.dll”.