I was watching a presentation yesterday, half way through which the presenters fired up a demo of their application. To their horror, the demos failed spectacularly. After what seemed like an eternity trying to recover, the presenters were forced to move on, leaving the presenters visibly annoyed and the audience disappointed.
Although I’m not immune to this (I had an epic demo fail at JavaOne last year), in this post, I wanted to share a few things that I’ve found successful in preparing for and presenting technical demos.
All About State
I’ve lost count of how many demos I’ve seen that have failed on stage. One of the most common post-demo excuses is “That’s strange… it worked OK in my hotel room”. What these presenters don’t realize is that it’s all about state – and how two types of state changes can affect demos.
Predictable State. When you boot your machine, it starts in a particular state (let’s call it S1). When you test your demo in your hotel room, at the end of the demo your machine is in a different state (let’s call it S2). The demo was successful, and you assume that everything is going to be great for your talk. However, when you walk up to the podium, your machine is no longer in it’s original S1 state, it’s in S2 (because you’ve just run the demo previously). What many presenters fail to realize – until they have 250 people staring at them – is that the demo doesn’t work if the machine is in state S2. Maybe temporary files weren’t cleaned up, or the database connection was left open, etc.
Timeout State. Another case I see frequently is with time lag. I’ve also heard this referred to as “your machine being baked on stage”. In your hotel room, you boot your laptop (which is in state S1) and run the demo – and it works. What many presenters face however is a time lag between starting their talk and presenting their demo. For example, your machine could be sitting on stage for 50 minutes before you actually get to the part where you need to show your demo. By that time your machine is in a different state (maybe some kind of power saving / indexing / virus scanning has kicked in – or maybe your application has a memory leak / has closed database connection) and as a result fails.
How do you mitigate these two changes of state? There are a couple of things that I’ve found really help.
Firstly in your hotel room – either before the presentation or the night before - run the demo as you would, and then re-run it directly afterwards. At the time I’m often thinking “of course this is going to work”, but I’ve been amazed at how many times the demo actually fails on the 2nd attempt. For my more complex demos, one of the things that I’ve been considering is using some TDD approaches to help setup. For example, having a build script that will clean, compile, and run my demo together with a set of unit tests that will check the output. I can run this multiple times in the hotel room previously, and also again when I reach the podium before my talk begins.
Secondly, the only way to deal with the lag issue is to recreate the conditions that you’ll face. A full rehearsal in the hotel room the night before is often the only way to get around this. Many times I’ve been amazed to see that demos that normally need a few seconds to complete take much longer once the machine has been sitting there idle for half the presentation. There are a few things that I normally set by default to help mitigate this (e.g. ensure the machine is in high power mode, turn off unwanted settings etc.)
Scripts
To help recreate a successful state, for each demo I always use two scripts, in printed format. One is my “pre-req” script, another is my “run-through” script.
My pre-req script lists all of the things I need to do in order to get the demo in to a known state for presentation. This can include pre-opening the IDE, setting fonts correctly, minimizing windows, resetting config values, deleting output files, etc. I also have a master “pre-req” list that includes many things that I don’t need every time (switch off IM client, close Outlook, etc.)
My run-through script is exactly as it sounds – a script that I use during the presentation to run through the steps of the demo. I know many people feel uncomfortable reading from a script during a presentation – and for the slides, I completely agree – but for the demo, everyone in the audience tends to be looking at the screen and not at you directly, so while reading from a script might not feel natural, you’ll see that the audience won’t actually notice.
One thing I will say about the run-through script is that it needs to a set of mental prompts, not a set of instructions. For example, if the first part of your demo is to open a new browser window to your demo page, a mental reminder like this would work:
* IE –> http://myapp
Whereas this would not:
* Click on start, select Internet Explorer. Wait for browser to start. Go to address bar, enter demo address and click on OK.
In the heat of the moment, you won’t have time to process everything and you’ll end up ditching the script half way through.
Video Recording
You face your worst nightmare and your demo spectacularly fails. What’s your backup plan? For me, it’s a video recording of the demo produced the night before and made accessible before the presentation.
Many people dislike creating video recordings because they think the audience won’t like the format – or worry that it will take too much time to prepare. I disagree. The audience would prefer to see something in context of your presentation, even if it’s a recording. For example, let’s imagine that your demo doesn’t work during your presentation. It’s perfectly acceptable to spend a few seconds to try and recover before saying “Well, I seem to be having some trouble with the demo – let me switch to a recording instead and walk you through what I was going to show”. I open the video and within seconds the audience is able to keep context with the main flow of the presentation – and they’ll forgive me more for using a video than if they couldn’t see the original intended version.
In addition, if you are doing a full rehearsal the night before, it’s little effort to start some screen capturing software and record your demos. The video doesn’t have to be a Hollywood masterpiece – remember, this is for backup purposes only – and you don’t need to worry about audio (as you’ll be talking over the top of this).
When you record the videos, always set your machine to the resolution of the projector that you’ll be using (this is good advice for running through any demo prep). If you don’t know the resolution of the projector beforehand, I would recommend 1024x768. Your audience will prefer to see a demo with additional screen real estate vs. a demo that’s looks crammed because the resolution was too high.
After you’ve created the videos, I recommend copying a version of them to a folder on your desktop for quick access, and to either a USB stick or online storage where you can access them from another machine if need be. Many conferences that I’ve presented at often have a second presenter machine than I can use in case my demo machine dies.
As a final note, if all of this sounds way over the top, I like to remind myself of the time investment from the audience. If I have 100 people show up to a talk and I have a 15 minute demo, the audience is investing 25 man hours collectively just for that demo (100 people x 15 minutes). I feel that adding a few more minutes of my prep time to ensure the demo runs flawlessly is worth justifying the investment of everyone in the room.
Over the past few weeks I’ve been working with Jean Paoli’s team at Microsoft to create an application that runs across multiple cloud vendors. Jean’s team has been working on a number of SDKs for PHP and Java, and I wanted to create a sample that demonstrated all of them working together.
The result is a small application that calculates every prime number between 1 and 10,000,000 in a minute or less, with the calculation performed by a set of PHP pages running on Windows Azure, a Java Servlet running on Google AppEngine, and an ASP.NET application running on Amazon EC2. All of the results are stored in a central SQL Azure database, and I used the .NET Service Bus to coordinate messages across the three cloud applications.
I presented this for the first time at TechEd Europe last week in Berlin and this week at QCon in San Francisco. Both presentations seemed to strike a chord with the audience, especially the attendees looking for how interoperability works in the cloud.
For those that weren’t able to make it to my sessions, I’ve recorded a short screencast of the demo in action – you can find it here.
If you are after more information, here you can find a longer (50 minute) screencast that goes into the details of how this works.
I’ll be back on the road again on Tuesday to squeeze in three more conferences before the end of the year. My stops this time include:
TechEd Europe, Berlin
This will be my first time to Berlin, so I’m really looking forward to it. I think it will be especially interesting as this year marks the 20th anniversary of reunification in Germany. While I won’t be there on the actual day (9th), I still think the atmosphere will be a great experience.
I have three sessions at a sold out TechEd Europe this year. On Thursday 12th, I will be presenting Working with the OSS Community: Cloud Computing Interoperability (INT02-IS). This was a late addition to my schedule, and I’ve been working on a sample application that runs across Windows Azure, Google AppEngine, and Amazon EC2 – and as it’s an interactive session, my goal is to show mostly demos and walk through how the application was put together.
In the afternoon I’ll be continuing the theme of cloud computing with Demystifying Cloud Computing (ITS204) in the IT Managers Track. This will be an update of the session that I delivered at TechEd US, with a goal of giving IT Managers the foundational information on what cloud computing is, and why they should care.
To conclude the week on Friday, I’ll be presenting Patterns for Cloud Computing (ARC309) which takes architects and senior developers through 5 patterns for the cloud. If you’ve been following my recent posts on my blogs, then this will be the session that brings all this together.
PDC, Los Angeles
The week following I’ll be heading back to the West coast for PDC in Los Angeles. I have a BOF Session this year on Will Cloud Computing change your life? This is an INETA organized panel, and I’ll be in good company with Aaron Skonnard, David Pallmann, Michael Stiefel and others.
QCon, San Francisco
My final stop will be QCon in San Francisco. This will be my first time at a QCon event. and as I know Floyd and the team well, I’m really looking forward to it. I’m presenting my “Patterns for Cloud Computing” session to open the cloud computing track at the event.
If you’ve been following the recent developments on Windows Azure, you are probably aware that the July CTP of Windows Azure introduced support for FastCGI. One of the benefits of supporting FastCGI is the ability to run PHP applications in the Azure fabric.
If you are a developer using the Eclipse IDE, this month marks another milestone with the release of the “Windows Azure Tools for Eclipse”, a project that provides a complete toolkit for Windows Azure development, right inside the Eclipse IDE.
I’ve been playing around with an early build, and have been really impressed.
The tooling adds support to an existing PHP project (using PDT) so that it can run on Windows Azure, integrates with the local fabric so that you can test applications running on your local developer box before deploying, and includes an explorer for interrogating storage elements of Windows Azure.
You can find out more about the project here. If you are using Eclipse 3.5 today, the update URL is http://www.windowsazure4e.org/update. Full instructions for downloading can be found here.
I’m planning to cover this in some detail in one of my sessions at TechEd Europe (INT02-IS Working with the OSS Community: Cloud Computing Interoperability). If you have thoughts on what else you would like to see in a session with such a title, do let me know!
Since returning from Europe a couple of weeks ago, I've been asked if my presentations were recorded, especially for the demos shown. A number of events did record the session, and I'm sure they will be making these available soon, but in meantime I have put together screencasts for each of my five demos.
The first screencast shows a small application called PrimeSolvr, which was created by a couple of colleagues - Wade Wegner and Larry Clarkin. PrimeSolvr is a simple application that solves prime numbers, running on a 25 node instance using Windows Azure.
The second screencast focuses on multi tenancy and shows handling data and UI for multi-tenant applications using ASP.NET MVC, which could then be uploaded the cloud. The demo was inspired by Maarten Balliauw, a Microsoft MVP in Belgium who created a routing mechanism for ASP.NET that uses the domain name.
The third screencast, and demo, is a simple implementation of MapReduce running on Windows Azure. The demo is run locally to demonstrate logging in the fabric, and shows how a MapReduce-like application can run on Windows Azure.
The fourth screencast focuses on storing data in the cloud, primarily with SQL Azure. For this demo, I take the database used in the second demo, and move it from a local instance of SQL to an instance running in the cloud.
The fifth and final screencast looks at communication using the cloud, specifically using the .NET Service Bus. Instead of exchanging "hello world" type messages, I actually show how the service bus can be used to do protocol mapping between two machines - I think this demonstrates some of the more interesting applications that using the cloud can enable. In this demo I connect to an instance of SQL Server running on a remote machine using the .NET Service Bus.
My apologies about the player used for these (e.g. there is no full screen button - to get full screen, you have to double click on the video).
I'm working on a blog upgrade that will fix this, and a few other issues - hoping to get something up and running before heading across to TechEd Europe in Berlin next month.
One of the conferences that I regularly look forward to is PDC. This year will be the first in a move to an annual format, as traditionally it has only been every two years. If you are on the fence about going, it looks like there is only one more day to register (to qualify for the early bird discount). After that, it’s back to full price.
I’m going to be taking part in a couple of sessions this year, including a lunchtime INETA panel on Wednesday on developing for the cloud. Check out the regularly updated feed of sessions, and I hope to see you there!
I’ve just returned from two weeks in Europe, presenting as part of the ReMIX tour in several countries. It was a great experience, and I really enjoyed the participation and feedback at all the events.
In Spain, Belgium, and Portugal, I was given the opportunity to deliver a new presentation that I’m working on called “Next Generation LOB Applications”. The goal of the talk is to deconstruct a Line-Of-Business (LOB) application into 5 characteristics, and for each area explore how this area has changed over the past 15 years, and what new technologies might bring.
For example, one of the characteristics of LOB applications are that they tend to be very interactive – based on this, I ask the question whether new input mechanisms (e.g. Touch in Windows 7) helps create a better experience for certain LOB scenarios.
You can find the deck I presented here on SlideShare. I expect this to be working on this more in the coming months, and any feedback is always welcome (even if you weren’t at the event!).
Brad beat me to blogging this, but he, Arturo, Adam, and I will be traveling to Europe at the end of the month to deliver several sessions across numerous web developer, designer, and architect conferences throughout Europe.
My schedule takes me to the following places:
Tuesday 22nd September (Amsterdam, Netherlands)
Presenting “Patterns for Cloud Computing” to post-LEAP attendees.
Wednesday 23rd September (Madrid, Spain)
Keynote on “Next Generation LOB Applications”.
Thursday 24th September (Dublin, Ireland)
Short session on “Usage Patterns for the Cloud”.
Friday 25th September (London, UK)
Heading to the Architect Forum to deliver “Patterns for Cloud Computing”.
Monday 28th September (Oslo, Norway)
Presentation on “Patterns for Cloud Computing” and a panel/Q&A with the local team.
Tuesday 29th September (Brussels, Belgium)
Presenting both “Next Generation LOB Applications” and “Patterns for Cloud Computing” at the ReMIX event and Architect Forum.
Thursday 1st October (Vienna, Austria)
A packed agenda. The Austria ReMIX keynote, a session on “De-mystifying the Cloud”, and a follow on session “Patterns for Cloud Computing”.
Friday 2nd October (Lisbon, Portugal)
Two sessions at the Portugal ReMIX event to end the trip - “Next Generation LOB Applications” and “Patterns for Cloud Computing”.
As you can see, a packed agenda for a couple of weeks, but I’m really looking forward to it. These are two relatively new presentations, and I’m excited to chat with attendees about the projects they are working on.
If you are in any of these countries, and would like to attend, please use the links above, contact your local Microsoft representative (or contact me – and I’ll put you in touch).
Hope to see you there!
Over the past few months I’ve been working with many customers and internal groups to try and determine whether there is a common set of patterns for cloud computing. As you’ve probably read, many people are claiming to do cloud computing, so my goal has been to explore the types of applications that people are running in the cloud, and whether these applications can be categorized in any way.
The result of this work is a presentation called Patterns for Cloud Computing, which I delivered at our internal conference (TechReady) last month. Due to many people asking for it however, I’ve now created and uploaded a public version on SlideShare, which you can find here.
The presentation first covers a definition of cloud computing (as I believe this is where many people first struggle when trying to understand the space), and continues by exploring five usage patterns for cloud computing. The patterns fall into the following categories:
Using the Cloud for Scale: How are people using cloud computing to achieve scale using provisioned machines in the cloud vs. physical machines on-premise?
Using the Cloud for Multi-Tenancy: How are people using the cloud to create multi-tenant applications, serving thousands of customers using the same code base?
Using the Cloud for Compute: How are people using the cloud to solve computationally intensive problems across a number of machines?
Using the Cloud for Storage: How are people using the cloud to store massive amounts of data, in a way that is “infinitely” scalable?
Using the Cloud for Communications: How are people using the cloud to make peer-to-peer and asynchronous communications easier?
These patterns represent some early thinking and research, but my hope is that they make it easier for people to better understand a definition of cloud computing, together with some of the applications that make sense today.
With the previous builds of Windows 7, and now the RTM, I've had more than enough experience of rebuilding my machines over the past few months. One of the things I've created as a result is a "build script" for each of my development machines - it's still largely manual (although it would be great to have something automated here), but I find it acts as a good checklist to make sure that the machine is setup the way I need with all the necessary applications.
As it's a mixed bag of applications and settings, I thought I would spend a few minutes outlining what this build script looks like - some of which might be useful you upgrade/rebuild your own machines - and would love to hear of anything that I could potentially be including!
Base Operating System
First things first - got to load the OS and configure all the settings. This includes:
- The actual OS itself (Windows 7). I don't do much to the setup, apart from use a local account that's different to my domain account. Doing this prevents any conflict between c:\users\{account} and c:\users\{account.domain} directories.
- Next, add the machine to the domain. Before rebooting, I also make sure to add my domain account to the local administrators group (so that I'll be able to log into the machine afterwards).
- Reboot
- Login, and enter the Windows activation code
- Run Windows Update (great for checking for those updated drivers not found during setup)
Next I install any remaining drivers on the machine:
- For my Lenovo machines this includes the TrackPoint driver and the ThinkVantage Power Manager utility. If this is my desktop machine, then this includes the drivers for a Wacom tablet.
- Any printer drivers not picked up by default with Windows 7(for a Samsung Laser at home)
I also run the Windows Experience Index which is good for showing whether any drivers are potentially missing (e.g. if I get a 1.0 for the display, something is up)
Now for some Windows shell configurations:
- Start Menu / GPEDIT.MSC / Administrative Templates / Start Menu and Taskbar -> enable "Add Search Internet link to Start Menu". This enables me to type search criteria into the start menu and search directly from the start menu.
- Start Menu / Advanced System / Remote tab -> enable this machine to be accessed via remote desktop (RDP). Required for accessing machines remotely.
- Same dialog / Performance Tab -> uncheck all of the "animate xxx" settings, all of the "fade xxx" settings, and the "slide open combo boxes". I find that this helps remove a lot of the transition bottlenecks on older graphics hardware.
- Right click on desktop/personalize/Windows Color / Advanced Appearance Settings -> In here I changes the border padding from 4px to 1px. I've never understood why the border padding had to be so thick...
- Start Menu / cmd.exe / Properties -> Set the command prompt font to Consolas 16, green text on a black background. Much easier on the eyes as I spend a lot of time in the command prompt window.
- Start Menu / Power Options -> set my power options accordingly for the machine. This normally means making sure that the machine does not go into hibernation while on AC power.
Start Menu / Regional -> Add a new keyboard type / Japanese IME. So that I can type in Japanese
Data
After the operating system is up and running to my liking, it's time to get my data on the machine.
- First thing is to install Live Mesh (removing the device from the existing mesh if this was an existing machine).
- I use Live Mesh to synchronize two primary folders between all my machines - one for projects that I'm currently working on, and one for tools, a collection of everyday tools that I just can't live without. I add these as two desktop folders.
- Having these as desktop folders is great for Windows Explorer, but cumbersome to access from the command line and scripts. To overcome this, I use SysInternal's Junction to create NTFS junction points for c:\projects and c:\tools -> both of which point to the corresponding Live Mesh folder.
- In Windows Explorer, I also add the projects folder to my favorites, which makes it display in the left hand column on open/save dialog boxes.
- I use Keith Brown's Password Minder together with a PWM file in my Mesh to act as a password store across all machines.
- One of my favorite editing tools is Notepad2, which I keep in my c:\tools folder and also add to the "Send To" menu by running "shell:sendto" from the Start Menu.
- Searching is really important to my everyday use, so I use Start++ from Brandon Paddock, which gives me access to a whole set of shortcuts from the Start Menu. I also create a junction for the settings directory (%userprofile%\appdata\local) to point to my sync'd tools directory so that all of my shortcuts are sync'd through Live Mesh.
I've also created several
OSDX files that I install - for example, one that searches Amazon and another that searches the Microsoft downloads sites. I pin two of these (Amazon and Microsoft Downloads) to the Start Menu through GPEDIT.MSC/Admin/Windows Components/Windows Explorer/Pin option.
Office Applications
By this point I've got the operating system setup and all my data accessible. Now it's time for Office applications.
- Install Office 2007 SP1
- Configure my Outlook Account for Microsoft Exchange
- Enable Windows Update for Office Applications when prompted.
- Go to Windows Update and apply all of the patches, inc. SP2.
- Configure an IMAP account for my home Email.
- Switch off desktop alerts (too much mail to keep getting toast for each one!).
- Set the default plain text font from Courier to Calibri.
- Configure the shared calendar settings for my wife's shared calendar and also remove the tasks view from my calendar pane. (I have too many tasks to really make use of this functionality).
- Once Office is complete, I install Mind Manager - one of my favorite mind mapping tools.
- Install Office Communicator to get office IM and VOIP access.
- Install Expression Studio 3 - primarily for Expression Blend (when doing anything in Silverlight or WPF) and Expression Web (IMO, one of the best HTML authoring environments out there).
- Install FeedDemon for my RSS updates, and switch off the desktop alerts for this also.
- PDF Reader. My favorite is FoxIt Reader, just because it's darn quick.
- Virtual Clone Drive. One of my favorite utilities for mounting ISO files as drives within Windows Explorer.
BulletProof FTP. One of the most reliable FTP applications that I've come across
Now that all the applications are installed, there's a little more configuration.
- I have a ton of macros that support GTD (Getting Things Done) that you may have seen from earlier posts. This is where I load these into Outlook and create shortcuts for these.
I also setup OneNote, pointing it to a shared set of notebooks in my Live Mesh folders, and also configuring the screen capture utility to save to the clipboard only (anything else is just overkill).
Development Environment
By this point I have the machine at a point where I can use general applications, but not really write any code. Next step is to get all of the developer applications up and running.
- Visual Studio 2008
- Reboot, and then apply Visual Studio 2008 SP1.
- Windows 7.0 SDK. I don't use much out of here, but there are a few tools (e.g. XamlPad) that I can't live without.
- Team Explorer 2008. For connecting to my TFS shares.
- Re-apply Visual Studio 2008 SP1 (required to get Team Explorer working correctly).
- Configure IIS and ASP.NET on the machine (required for the Windows Azure CTP)
- Apply my saved Visual Studio settings file (mostly includes font changes)
- Install the Windows Azure July CTP
- Install the .NET Service Bus July CTP
- Install SQL Express 2008 + Advanced Services to a new instance called SQLEXPRESS08. In my opinion, SQL Express 2008 is Microsoft's best kept secret - a free database, with the power of higher end SQL server editions.
- SQL Server 2008 SP1
- SQL Server 2008 Books Online (mostly for the T-SQL reference - why is it that I can't remember any T-SQL commands? :-))
- Apply hotfix #957944 which allows SQL Express 2008 to be used directly from MDF files in Visual Studio 2008.
- Mobile SDK for Windows Mobile Standard 6.0. Mostly for small applications that I create on my Samsung Blackjack II.
- Web PI - a great application for installing extra Web applications on your machine. From here I also install ASP.NET MVC 1.0 and Silverlight 3 SDK.
- Virtual PC - for accessing my VHDs from the desktop.
- Script# - wonderful tool for creating great scripts.
- DevExpress CodeRushX - a free add on for Visual Studio that supports a number of refactoring shortcuts that I find really useful.
- RAD Software Regular Expression Designer. Before finding this tool I was looking through books when trying to work out RegEx commands - no longer.
Just before heading home from TechEd 2009 in LA, I recorded a couple of online interviews, which are now available:
Patterns for Moving to the Cloud: Recorded with Denny Boynton, host of ARCast, we chat about where applications live, and what applications make sense for the cloud. We also cover a set of patterns that was shown in my previous session.
Demystifying the Cloud: In this talk, I chat with Kevin Remde on what cloud computing means for IT managers, and some of the considerations for moving applications to the cloud.
These were fun to put together; hope you find them useful.
Today is my last day at TechEd 2009 in LA, and as promised, I’ve uploaded the presentations from the three talks that I’ve given this week. Thanks again to everyone that attended my talks, and I really enjoyed speaking with many of you after the presentations.
PRC02 – Demystifying the Cloud
This is the presentation that I gave as part of the architecture preconference on Sunday 10th. It’s a high level look at cloud computing and covers the definition of running applications on premise, in a hosted environment, and in the cloud, together with many of the considerations for doing so.
Click here to view the presentation on SlideShare.
Click here to download the presentation.
ISB204 – Impact of the Cloud for IT Managers
This presentation was delivered on Monday at 4.30pm and covers much of the pre-conference material from PRC02, but through the eyes of an IT Manager. When I was putting the decks together I realized that there were many common concerns shared between the IT Manager (from an operations perspective) and the IT Architect (from a design perspective), in which I try to surface in this deck.
Click here to view the presentation on SlideShare.
Click here to download the presentation.
ARC308 – Patterns for Moving to the Cloud
This is my presentation from Tuesday at 8.30am that covered a series of patterns for moving to the cloud. In this presentation I look at the differences between on premise, hosted, and the cloud, describe some applications that you may find running on premise in a large organization, and then cover five patterns for running these applications in the cloud. The patterns I cover are: Transference – moving applications from on premise to the cloud, Scalable Web / Multi Tenancy – cloud application that can scale on the web front end, Burst Compute – cloud applications that have the ability to dial up / dial down compute resources as necessary, Elastic Storage – looking at how the cloud can provide for storage that can grow on demand, and Inter-Org Communications – sharing how part of the cloud can be used to connect multiple organizations through a service bus and workflow.
As you can imagine, with the space being so new, these are not a definitive or exhaustive list of all patterns for cloud computing, but I hope they were useful in introducing the different types of applications running in the cloud.
Click here to view the presentation on SlideShare.
Click here to download the presentation.
I believe two of the three sessions (ISB204 and ARC308) were also recorded and will be online soon. Once I get hold of them, I’ll update with the link.
I recently put together this article for InfoQ on using SketchFlow to create better prototypes.
In case you haven’t run across it yet, SketchFlow is a feature of Microsoft Expression 3, announced during the MIX09 conference in March this year. In this article I cover the importance of prototyping (I’ve often said that we don’t do enough prototyping in IT), and take the reader on a walkthrough of using SketchFlow to build a prototype shopping store for InfoQ.
Hope you enjoy the article – feedback always welcomed!
I’ve recently been involved on a project that has a requirement to create and view XPS documents in Silverlight. The application needs to display the XPS file in a full screen window together with zoom and navigation features.
After a little searching on how to do this, I was able to get a head start with this great post from David Anson, which includes sample code for viewing XPS files in Silverlight 2 beta 2. As his updated post attests to however, there were a few issues with Silverlight 2 due to a breaking change with the ways that font resources could be referenced from within a Silverlight assembly. Fortunately, this post from Li Chen pointed me in the right direction, separating out the ODTTF fonts into separate XAP files which can be referenced at runtime.
The sample code provided by Li Chen works well with the sample XPS files provided, but I couldn’t get it working with an XPS file generated using Microsoft Word. After a little debugging this weekend, I found a few subtleties with how the code dealt with XPS files geneated from Microsoft Word:
Firstly, the root document of the XPS file is called FixedDoc.fdoc instead of FixedDocument.fdoc (which is the name when using the XPS Printer Driver). This was fairly easy to correct using a simple check:
// Added to support "Save as XPS" from Microsoft Word
if (resourceInfo == null)
{
resourceInfo = Application.GetResourceStream(_streamResourceInfo, ConvertPartName("/Documents/1/FixedDoc.fdoc"));
}
Secondly, the .fdoc file refers to pages using relative links. Instead of the absolute link (e.g. /Documents/1/Pages/1.page), a relative link (e.g. /Page/1.page) was causing the sample to be unable to find the pages. A small piece of code to append the full path quickly fixes this also.
// Update the page names for "Save as XPS" from Microsoft Word
List<string> _newPageNames = new List<string>();
foreach (String pageName in _pageNames)
{
if (pageName.StartsWith("Page"))
{
_newPageNames.Add("/Documents/1/" + pageName);
}
}
Finally, it looks like Word includes a page attribute called BidiLevel, which isn’t recognized by the Canvas element. Adding an additional exclusion line into the sample code quickly fixed it.
_elementAttributesToRemove.Add("Glyphs", new List<string> { "BidiLevel" });
The result seems to work quite well, with an XPS file saved from Microsoft Word viewable within Silverlight.
If you are interested in trying this yourself, I’ve posted a version of the sample code here which contains the above modifications. To use the modified sample with your own XPS file, do the following:
1. Go into Microsoft Word and “Save as / XPS” to create a new XPS file.
2. Download and compile the sample (note: only works in Visual Studio 2008).
3. Copy the XPS into your Visual Studio project, in the SimpleSilverlightXpsViewer_Web project.
4. In Windows Explorer, rename the original XPS file to a ZIP file. Ignore the warning about changing the file extension.
5. Open the zip file and go into the /Resources directory. Look for font files ending in ODTTF - these are embedded font files for the XPS file and must be referenced separately in the Silverlight project. Copy all of these ODTTF files to the SampleWordGenerated project in the solution. Also note that the ODTTF files are dynamically named when the XPS file is generated. This means that although you may have already imported the correct ODTTF files for previous XPS file that use the same fonts, you’ll still need to re-import the fonts again to handle a new XPS file.
6. Edit default.html in SimpleSilverlightXpsViewer_Web and on line 70 change the xpsDocument=SampleWordGenerated.xps to the correct name of your XPS file.
7. F5 to run and you should see your XPS document displayed within a Silverlight control!
There is still a bit of work to do with the sample code, which I think would be worth taking into a CodePlex project. For example, the code should initially read the XPS root file (FixedDocSeq.fdseq) instead of looking or FixedDoc.fdoc or FixedDocument.fdoc directly. It would also be great to figure out a better way of extracting the fonts more dynamically at runtime. Other than that though I found this to be a good solution to display XPS files in Silverlight applications, especially useful as Silverlight doesn’t support the FlowDocument element (which is commonly used in WPF applications for creating documents and report generation).
I wanted to share the details of two cloud computing sessions that I will be presenting at TechEd 2009 in Los Angeles next month:
ISB204: The Impact of the Cloud and Software as a Service - 5/11/2009 4:30PM-5:45PM
ARC308: Patterns for Moving to the Cloud - 5/12/2009 8:30AM-9:45AM
The first session (ISB204) is part of the IT Manager track. The goal of this 200 level session is to explore the significance of cloud computing for IT decision makers. This will include looking at different types of applications and understanding whether they make sense for the cloud, and why – and then investigating some of the tradeoffs and risks for moving certain applications to the cloud.
The second session (ARC308) is the next level deeper: an architect/developer focused session that will cover a collection of design and implementation patterns for cloud based applications. For example, how the cloud can enable parallelization across multiple machines, blob storage in the cloud, and some of the finer points of identity management within applications.
We are still a few weeks away from the event, so if there are questions that would like to see answered or other items that you think would make sense in either presentation, do get in touch and let me know.
And to those that will be attending TechEd 2009, I look forward to seeing you there!