Slides! - because that's all some people think a talk is.
Let me add some background.
Above are a modified version of the slides used in this talk. The modifications remove things that aren't relevant, were there just as a backup for the more risky demos, and strip out the animations.
This is not the whole talk!
There is no way you could take this deck and give the same talk.
For starters, there are 10 (yes ten) demos that aren't included here.
I do not have slide notes.
Sorry, no. For what the slide doesn't make clear you're out of luck.
It's a talk, and the slides are there to support what I say. I'm not there to talk about the text on the screen. I know some people do it that way but I don't.
The basic structure of the talk is as follows:
- Why XAML was created?
- How it's developed and evolved.
- XAML has multiple versions, allows you to build for multiple platforms, and has multiple ways of doing things.
- Given all those variations, tooling hasn't always been great, but that is starting to change.
- There is a lot to be gained when thinking about XAML as code and what you expect from the tooling for other languages.
- Given that comparison:
- What about creating apps that use XAML?
- What can be done in the editor?
- What can be done in the designer?
- What can be done at run-time?
- What's coming in the future?
- Conclusion and questions
I don't have a script for the whole talk. That's why I can't share one here.
Instead, I plan by focusing on the overall structure. I then look at how different elements can fit into that structure.
The structure comes down to two parts.
- Provide background
- Walkthrough building an app and show how the tooling can help at different stages.
Within the walkthrough, I combine a number of small demos to show different features and that things work with different platforms. This means jumping between WPF, UWP, and Xamarin.Forms projects but this shows that the tools apply regardless of the platform without repeating everything three times or just claiming what's possible.
Having multiple small demos also allows me to focus on one thing in each demo. Trying to put everything in a single demo was more complicated than I could manage and involved too many things being on screen at once which was potentially distracting and confusing.
Having multiple small demos made them easy to practice. I practiced the demos many many times in preparation for giving the talk. Having small, simple demos allows me to experiment within the rehearsal to become familiar with variations. It allowed me to explore things like "what if I did this differently?", "How could this go wrong?", or "How could I make this simpler?".
Because each demo doesn't depend (much) on what's gone before it I can make changes in one demo without having to worry about possible negative consequences in subsequent demos.
Finding times to practice small demos is easier for me to do than finding the time to practice a long, complicated demo.
Not being tied to a specific, strict format allows me the flexibility to adjust the talk when given based on anything that may happen on the day, has been said in other talks earlier in the conference, or where my mind goes at the time.
Preparing this way takes ages. It's not something that can be done without a lot of time to prepare and so it's not a technique that can always be used. I do it where/when I can.
I made sure to know the content inside out and roughly how long each section takes and then adjusted what I said accordingly on the day.
I deliberately include some questions on slides at the end. This is for a number of reasons.
- It shows I'm open to answering difficult questions.
- It provides an easy way to answer common questions that I didn't cover earlier.
- It provides an opportunity to cover questions that don't naturally fit into the rest of the talk.
When I gave this talk in Stokholm I finished, including the Q&A section with 3 seconds remaining.
Additional questions were taken 1-to-1 immediately after the talk.
Hopefully, this is useful if you're interested.
Also, links to tools mentioned in the talk can be found at
https://www.mrlacey.com/2020/02/modern-xaml-development-notes-from.html
