Hello – welcome back to the third and final installment of the (3) part series on programming the WinJS App Bar. In this post, I’ll cover some more of the exciting advanced topics in programming the WinJS App bar like:

• Creating “Sticky” App Bars – that are not lightly dismissed
• Implementing a “Navigation” App Bar
• Incorporating CSS styling – for maximum flexibility for customizing the look and feel
• Localization - for global appeal of your application
• Integrating custom Fly-Outs – for easy pop-up dialogs for user interactions
  

Just for a quick re-cap, here is the link to part 1 for a basic introduction and below are the links to the 3-part “How Do I” short video series on programming the WinJS App Bar for Channel 9 – here’s the line-up:

#1 - How Do I: Implement App Bars in a Windows 8 Metro Style Application (Part1)?
#2 - How Do I: Implement App Bars in a Windows 8 Metro Style Application (Part2)?
#3 - How Do I: Implement App Bars in a Windows 8 Metro Style Application (Part3)?

Creating “Sticky” App Bars

Ok, you you have the basics down and you have some cool App Bar icons to use for your application – how do you make the most of an App Bar that is mostly hidden?  In some cases, it is highly desirable to have your App bar remain visible – like when invoking the Camera to take a picture for example.

The good news is that it is extremely easy to do – by setting the AppBar data-win-options to “sticky:true” – like below:

By invoking this setting, the App Bar will remain visible until the user swipes down or up again to “dismiss” the AppBar,

Implementing a “Navigation” App Bar

Besides using an AppBar as a “commanding surface” from the bottom of your screen, they can also be used as a means of implementing “Quick Navigation” into your App,  For example, in the Microsoft Bing Sports App, if you swipe down form the top of your screen, you will notice an AppBar at the top of your screen that will allow you to quickly navigate to the sport of your choice:

This effect is very easy to do – and again all it takes it setting the AppBar data-win-options to “placement:'top'” – like below:

Incorporating CSS Styling

For ultimate control over how your AppBar looks – you can implement the use of Cascading Style Sheets (CSS) to fully define the colors, fonts, and size of your AppBar items.  All it takes to make this happen is (2) simple steps:

(1) Assign a class to the AppBar control like below:

(2) Define a CSS Style sheet that overrides the default App Bar styles with your own styling:

See this link for a full set of the available AppBar Styles.

Localization of your App Bar Resources

When you are ready to take your application global – you will want to implement App Bar localization – so that folks in different countries can understand the App Bar commands in their native language.  Fortunately, it is very easy to do this in Windows 8.

The first step is to define your AppBar Button with the additional “data-win-res” attribute – which defines the use of a resource file to be used for language translations:

The next step is to add a new folder to your solution named “Strings”.  Then add a new folder underneath the Strings folder for each language code you wish to support:

Then “Add” a new “Resource File (.resjson)” item to the folder: 

At this point, you can provide language translations by editing the corresponding resource file for each language you wish to support.  Note that the format is simply a text file – in JSON notation.

The last thing required to implement localization for AppBar commands is to insert the following (2) lines of code into your application to handle processing for resource file translations and in the event the user changes the default language at the OS level:

Integrating Custom Fly-Outs from the App Bar

One of the coolest capabilities in Windows 8 applications written using HTML/JS/CSS is the capability to implement custom Fly-Outs in your application to handle user input or notifications.

There are several steps to implement a custom App Bar Fly-Out, the first is to define your Fly Out in HTML and assigning the data-win-control attribute to "WinJS.UI.Flyout":

The next step is to define an App Bar command button with the following (2) data-win-options set to type “flyout” and the ID of the Fly Out HTML:

Once these are in place – you have a really nifty Fly Out control that can be invoked by a command in the App Bar:

The Fly Out can then be easily dismissed by pressing on the command button in the Fly Out – or by clicking anywhere else on the screen outside of the Fly Out control.

And there you have it!  Some great ways to add advanced functionality for your Windows 8 App Bar commands!

Take a look at the screencast – @ 10 minutes: How Do I: Implement App Bars in a Windows 8 Metro Style Application (Part3)?

Here’s a link to all of the full code samples.

And be sure to check-out the entire series of “How-Do-I” Windows 8 videos on Channel 9

 

Hello – we’re back with the second installment of the (3) part series on programming the WinJS App Bar.  In this post, I’ll cover some more of the finer points around customizing the look & feel of your App Bar – specifically around how to find (or create your own) cool App Bar icons and how to position your App Bar and App Bar Commands according to the Windows 8 UX guidelines.

Just for a quick re-cap, here is the link to part 1 for a basic introduction and below are the links to the 3-part “How Do I” short video series on programming the WinJS App Bar for Channel 9 – here’s the line-up:

#1 - How Do I: Implement App Bars in a Windows 8 Metro Style Application (Part1)?
#2 - How Do I: Implement App Bars in a Windows 8 Metro Style Application (Part2)?
#3 - How Do I: Implement App Bars in a Windows 8 Metro Style Application (Part3)?

App Bar Icons – (3) options

Ok, you you have the basics down and now you are looking for some cool icons to use in your app Bar.  The first resource I will point you towards is the “stock” icons that are available in Windows 8. 

Option #1 – Windows 8 Default Icons:

To see the list of default icons:

• Create a new (or open an existing) JavaScript Windows 8 App using Visual Studio 2012.
• Expand the References\Windows Library for JavaScript \ JS \ UI.JS file.
• Search for the word ”Glyphs” and you should see a screen similar to the one below:

• Here, you will see @ 193 definitions for default icon values that you can use in your Windows 8 application.
• To use these icons in your App – simply reference them by name when specifying the icon value like below:

Option #2 – Segoe UI Fonts:

The next resource for finding some cool App Bar icons is to make use of the Segue UI Fonts.  The easiest way to do this in Windows 8 is to invoke the search charm from the Windows 8 Start Screen by swiping from the left and selecting the “Search” charm (or just hit any alpha-numeric key on a physical keyboard) and then typing the words”CHAR” – this will display the “Character Map” in the search results:

After selecting the Character Map – you will see the Character Map utility – be sure that the Segoe UI font is selected in the drop-down:

From here, you can browse through the many interesting icon values in this font.  When you find the one you want, be sure to note the specific character value – this will be used to denote your icon value by adding the prefix of “\u” + character value like so:

Option #3 – Custom Icon Images:

If you haven’t found the right icon yet from either the default Windows 8 icons or the Segue UI fonts, you can always create your own.  There is a great example of how to do this in the Windows 8 App Bar control Sample. 

The base size of the custom PNG image is 40 pixels x 40 pixels, with 2 rows of 4 images. The 1st row represents the normal button state, and the 2nd row is for the “toggled state” if your App Bar command has toggled states (like Pin or Un-Pin).  Below is an example PNG for a custom icon for an “Accept” command from the SDK App Bar Control Sample above:   

Check-out this recent blog post for more information on how to create your own custom PNG images for use as App Bar icons. 

As you can see, there are a wide variety of options available to you for finding the right icon for your App Bar.

App Bar – Positioning

So now that you have some great looking icons for your App bar commands – the next topic to cover is positioning these app Bar commands on the bottom or top of the screen.  Knowing when and how is the key to success here – as far as the question of App Bar on the top or bottom – the answer is that App bars on the top of the screen are reserved for “Navigational” commands.  The bottom App bar is reserved for Application commands.

Left-side / Right-side

The bottom left-side of the App Bar is reserved for contextual commands for your application – the right-side is reserved for global, App-wide commands.

The way to denote these is through the use of the “Section” attribute; note that setting the value to “Selection” will display the App Bar command on the left-side; using the value of “Global” will cause the App Bar command to display on the right-side of the screen: 

Top / Bottom

By default, the App Bar will display on the bottom of the screen.  To denote that the App Bar should be placed on the top of the screen (again for App Navigation) – all we have to do is modify the data-win-option for the “placement” attribute and set it to “top”:

And there you have it!  There are multiple ways to get some great icons for your Windows 8 App Bar commands (including creating your own) along with how to position the App Bar and App Bar commands on the Top/Bottom or Left/Right.

Take a look at the screencast – @ 10 minutes: How Do I: Implement App Bars in a Windows 8 Metro Style Application (Part2)?

Here’s a link to the full code samples.

And be sure to check-out the entire series of “How-Do-I” Windows 8 videos on Channel 9

I’ve been doing a lot of Windows 8 HTML5 development lately and wanted to share some key learning's for what I would consider to be one of the most integral parts of every GREAT windows 8 application – The App Bar.  To that end, this is the first of a multi-part series on the topic of programming the Windows 8 App Bar – specifically via WinJS (HTML, JS, and CSS).

In Windows 8, t he App Bar is really the new “Toolbar” and provides a consistent commanding surface for both local contextual commands and global app functionality across screens – all nicely tucked at the bottom (or top) of the screen to keep the surface area of your App Free & Clear.

Some examples uses of the App Bar may include operations such as:

• Pinning  a Secondary Live Tile
• Invoking a Camera interaction or working with other system elements
• Providing Actions on a Data Entry Screen such as (File/Save/New…)

I recently completed a 3-part “How Do I” short video series on programming the WinJS App Bar for Channel 9 – here’s the line-up:

#1 - How Do I: Implement App Bars in a Windows 8 Metro Style Application (Part1)?
#2 - How Do I: Implement App Bars in a Windows 8 Metro Style Application (Part2)?
#3 - How Do I: Implement App Bars in a Windows 8 Metro Style Application (Part3)?

The first part of the series is a basic introduction on how to get up and running quickly with HTML and JavaScript.  As you can see below in the following HTML snippet, the key is assigning the “data-win-control” attribute values for  WinJS.UI.AppBar and WinJS.UI.AppBarCommand values:

In the example above, note that the data-win-options values for the WinJS.UI.AppBarCommand allow us to define things like the icon value (in this case using a “stock” App Bar icon value from UI.JS reference library), whether the App Bar command resides on the left or right (via the “section” value), and a descriptive tooltip value.   

From there, you can easily wire-up event handlers in JavaScript for the App Bar command buttons – in this case, we will just display a message box when the user invokes the App Bar command by swiping-up from the bottom of the screen or using the Windows Key + Z and then selecting the AppBar command   

And that’s all you need to quickly get started with an App Bar in your Windows 8 application.  The next video segments build on this basic example and show you how to add custom icons for your App Bar via the WinJS reference files, the Segue UI Character set, and using a custom .PNG template.  Additionally, we will take a look at styling the app bar using CSS, specifying the location of App Bar elements (Top/Bottom or left/right), localization, and implementing custom Fly-outs.

Take a look at part 1 below – @ 8 minutes: How Do I: Implement App Bars in a Windows 8 Metro Style Application (Part1)?

And be sure to check-out the entire series of “How-Do-I” Windows 8 videos on Channel 9

Here’s a few screenshots of the sample application I will walk you through in this blog post.  The secret to success is the use of the the Multi-Scale Image control:

The other secret to success is hosting your Deep Zoom content in Windows Azure Blob Storage – which provides a highly robust, scalable, and inexpensive way to serve-up your visually stunning experiences over the web.  For even greater performance on a world-wide basis, you can also leverage the Windows Azure Content Delivery Network (CDN) capabilities of Azure Blob storage for your data elements. 

My goal is to take you all the way from a cool hi-resolution photograph to a Windows Phone 7 application that can dynamically “Deep Zoom” in and out of the initial image in a Windows Phone 7 application. So, the steps will be as follows:

Cool Photo –> Deep Zoom Composer –> Azure Blob Storage –> Windows Phone 7 App – Deep Zoom Viewer 

With this framework and knowledge,, you will be able to host all kinds of valuable Deep Zoom imagery in Windows Azure Blob storage – and create mobile, web, and client applications to consume them.

Step 1 – download Deep Zoom Composer and Create Deep Zoom Images

First, get the Free Deep Zoom Composer Download.

Working with Deep Zoom composer is very easy and straightforward – there are basically (3) operations you can perform:

• Import – your favorite images or pictures.
• Compose – layout the image(s) on the screen in any pattern you wish
• Export – to create a folder containing the Deep Zoom Tile images that are used to render your scene.

Here you can see that I have imported an image and centered it on the canvas:

The next step is to EXPORT your Deep Zoom project images:

Select the “Custom” tab:

• Output Type: Silverlight Deep Zoom
• Export as a collection (multiple images)
• Set your folder location for the exported images

Now you can view the image folder and you should have the following files and folder structure:

Step 2 – Upload  Deep Zoom Content into Windows Azure Blob Storage

If you don’t already have a Windows Azure Account, you can sign-up for a Free 90-day Windows Azure Trial to get started.

Once you are in the Windows Azure Portal – you will want to select the option for “Hosted Services, Storage Accounts & CDN.  From there, select “Storage Accounts” and then you can right-click on your subscription and select “New Storage Account”:

Once you have created a new Storage Account, you will want to select the option to view the primary or secondary account key:

This keys will valuable for the next step where we will upload the Deep Zoom Images to Windows Azure – so please copy them to to your clipboard for later use.  You will also want to protect these keys – as they are the security mechanism to allow programs to   

Once you have provisioned Windows Azure Blob Storage, we will use a C# .NET console application to upload the Deep Zoom images files into Windows Azure.

I affectionately call this application “BlobBlasterParallel” - the program basically will move a folder and all subdirectories underneath and upload all the files into Windows Azure using the .NET Parallel libraries to maximize the efficiency of the application across all available CPU’s. 

All that is required is to modify the variables in the Program.cs file for the following information:

• Folder location for your Deep Zoom images (generated in Step 1).
• Your Windows Azure Blob Storage Account Name.
• Your Windows Azure Blob Account Name.
• Your Windows Azure Blob Account Key.

Here is the code snippet to modify:

Note the use of the Parallel.ForEach construct in the In the code snippet below that iterates over the files in a folder: 

Now compile and run the application from a command prompt. Note that this program will maximize your CPU’s and network connection to upload all of your Deep Zoom images and folders into Windows Azure as fast as possible – so be aware of network saturation issues you may cause for your home or work environment.

*Any on-line gamers in the household are particularly at risk for total p0wnage during this time.

You can download the all the code for the BlobBlasterParallel application at the bottom of this post.

We can use a tool such as the Azure Storage Explorer to view the content that has been uploaded to our Azure Blob Container. 

Here’s a view of our Blog container after we have uploaded all the Deep Zoom content that was generated in step 1:

Step 3 – Create a Windows Phone 7 Application to display Deep Zoom Images

Everything you need to get started building Windows Phone 7 applications (including the free tools) can be found at: http://create.msdn.com/en-US/

Once you have the Visual Studio tools for Windows Phone 7 installed, create a new Windows phone Application by selecting

File / New / Windows Phone Application - and then allowing Visual Studio to populate your solution.

Enable the Multi-Scale Image Control in the Toolbox

The multi-scale image control not visible by default in your toolbox - so all you have to do I right click on the toolbox and select “Add Items”:

Now you can drag and drop a Multi-Scale Image control from the toolbox and size it on the page like below (I named my Multi-Scale Image control “msi” for the next step :

Now, we can modify the page load event to set the Multi-Scale Image control source property to our Windows Azure Blob container:

Now, if we run our WP7 Deep Zoom project in debug, we will get the Deep Zoom Image displayed on our WP7 Emulator – directly from Windows Azure!

Of course, this is great – but our application still lacks the ability to respond to mouse events in order to zoom in or out.  To remedy this situation, I have taken the initial code base from Alex Yakhnin's blog post Deep Zoom on WP7 and modified it to work on Windows Phone 7 Mango.

And with that, we get a full-fidelity Deep Zoom experience on Windows Phone 7 – using Windows Azure Blob Storage to host our content!

So there you have it; Windows Azure hosting Deep Zoom image content in Blob Storage and a Windows Phone 7 application to display your super cool visual experiences!

All the source code for the above examples can be found here

Enjoy!

Welcome back – this blog post is Part 2 to my previous post to help provide a functional walk-thru of how to install and get up-and-running quickly with the Windows Azure Auto-Scaling Block – also known as “WASABI”.

This walk-through will demonstrate how much time, effort, headaches, and money you can save with this fantastic new (and *free) application framework for running a highly dynamic Windows Azure infrastructure that can easily scale up or down (automatically) with both predictive and reactive rule capabilities to handle almost any business scenario (seen or unforeseen).

Rule Types in the Windows Azure Auto-Scaling Block:

There are (2) basic rule types to consider:

Constraint rules:

• Use timetables (with recurrences) to proactively set limits on the number of instances for handling peaks & valleys.
• Have a rank to determine precedence if there are multiple overlapping rules.

Reactive rules:

• Use conditions to reactively adjust the number of running instances or perform some other action like notify an operator to take some action.
• Reactive rules would be typically based on performance counters and other potential system metrics (like Azure Queue length).
• You also have the ability to define custom business metrics – which in turn, can be used to trigger reactive actions.
• These capabilities help you to respond to unexpected bursts or collapses in your application’s workload.
• Guard your SLA and Save Money.

Scenario:

I chose the simplest of scenarios to help illustrate the capabilities of the WASABI block, so the scenario we will cover will be an Azure Worker Role that monitors an Azure Queue to determine whether to scale the number of Worker Role instances Up or Down with a minimum of (1) instance and a maximum of (4) instances.

Before you begin:

You will need to have the following items to make it all work:

• A Windows Azure account and access to the Azure Management Portal- you can also try Azure for free for 30 days at: http://windowsazurepass.com
• Visual Studio 2010 with the Azure Tools for Visual Studio 2010 downloaded and installed from: http://www.microsoft.com/windowsazure/sdk
• An X.509 Certificate for the Windows Management API http://www.davidaiken.com/2009/12/21/how-to-create-a-x509-certificate-for-the-windows-azure-management-api
• The Windows Azure Storage Explorer from: http://azurestorageexplorer.codeplex.com

Getting Started:

Now, from Visual Studio 2010 – File / New Windows Azure Project:

Select a Worker Role and let Visual Studio create your project and Solution.

If you have NuGet installed, its as simple as right-clicking on your solution and selecting “Manage NuGet Packages”

Once we have a base initial project, the first step is to find and install the NuGet packages – simply search on “WASABI” and you should get the two packages listed below.

The first selection is for the Windows Integration Pack (beta) Source code – I would suggest downloading and exploring this package if you want to see all the underpinnings of the Auto-scaling Application block. For purposes of this demo – select the second option to install the WASABi Block (Beta).

Once the NuGet package has been installed, you will notice that all of the prerequisites and dependencies have been also been installed for you.

The next step is to open the Worker.cs file in your project and add the following references for the Enterprise Library blocks:

The next step is to modify the Worker Role to declare an initialize an Autoscaler object and set it to the current instance – along with a few handy trace statements:

After that, we override the OnStart() method to set-up the default connection limit and diagnostic monitor configuration.  The diagnostic monitor set-up is super important because this allows the Auto-Scaling block to capture and monitor system usage metrics.

The next step is to configure the Azure Auto-Scaling block with the Enterprise Library Configuration Console by right-clicking on the “app.config” file in the solution and selecting the option to “Edit Configuration File”:

From there, you can select the option to “Add Autoscaling Settings”:

Now you should have the following screen displayed to allow you to configure the Auto-Scaling Block:

Note in the settings below, I configured the Application Block to use my Azure Storage account credentials to allow the block to retrieve the rules and service information files from my Azure Blob storage account that I had previously set-up for easy rule modifications on the fly:

Next, we use the Azure Storage Explorer application to create an Azure container named “autoscaling-container” and (2) Blobs:

• Rules-store – this blob will hold the contents of the rules.xml file for runtime evaluation.
• Service-information-store – this blob contains the contents of the services.xml file.

*Super Important* – note the content type above – you must manually change the content type for these (2) blobs to “text/xml” after you create the blobs – the default content type is “application/octet-stream” – which will not work for our demo.  Make sure you get this right.

Another key component of our demo is to create an Azure Queue that we can use to have our Auto-Scaling block monitor in order to decide whether to spin-up (or down) new Worker Role instances.

Note that we can use the Azure Storage Explorer to manually create and add new messages to our Queue – which will be very handy for experimenting with the Windows Azure Auto-Scaling block and testing our rule behaviors in response to the Queue length.

Setting the Rules:

Below is our sample rules.xml file that defines the rules for our scenario.  Note that I have uploaded the contents of this file to my azure Blob named “rules-store” – this allows me to easily change the rules “on-the-fly” by simply editing the contents of the Azure Blob.

As you can see from the above rule definition, we have defined the following criteria:

• A rule ranking of “10” to establish evaluation order and precedence for any overlapping rules.
• A Minimum Worker Role instance count of (1) and a Maximum of (4).
• Rule to increase the number of instances by (1) whenever the Azure Queue is greater or equal to (5).
• Rule to decrease the number of instances by (1) whenever the Azure Queue is greater or equal to (5).
• Information about the Azure Queue to monitor “autoscaletestqueue”, what statistics to monitor (Max number of entries), and time period (within a 5 minute period).

Auto-Scaling Services Definition:

Below is a snapshot of the services.xml file that defines our Azure service and storage account information:

Note that I have uploaded the contents of this file to my Azure Blob named “service-information—store” – this allows me to easily change the service information by simply editing the contents of the Azure blob.

*Important* – pay close attention to this configuration – the settings in tis file must exactly match your specific Windows Azure environemnt settings in order to work correctly.  Pay careful attention to the “dnsPrefix” setting and the “slot” (Production or Staging) setting.

Ready for Testing:

At this point, after configuring everything and uploading to Windows Azure, we are ready to begin testing the azure Auto-Scaling block.

To see the WASABI block in action, we will start our Azure application and note the default behavior in the Azure Management portal – which is to have only (1) instance running due to the fact that we have < 5 messages in our Azure Queue.  Remember that our rule is to increase the number of instances of the azure Queue length equals 5 or greater.

Now, if we manually add a few messages to our Azure Queue using the Azure Storage Explorer tool, we can quickly make sure that there are (5) or more messages in the Queue – which will trigger the auto-Scaling block to spin-up more instances to handle the load:

A few minutes after adding (5) or messages to our Azure Queue – we can see that the Auto-Scaling block has automatically started additional Worker Role instances – up to the “max” of (4) running instances! 

Ok, so the rule for detecting increased load worked great – and we have automatically spun-up the maximum desired instances.

Now let’s see what happens when we delete all but one entry form the Azure Queue:

Now, after a few minutes, when we look at the Windows Azure Management Portal, we see that our “Low Usage” rule has been activated and the Auto-Scaling block is now decreasing the number of running instances – and will quickly get back down to (1) running instance – our desired minimum. 

Below, we see the results of the first decrease of the number of running instances by (1).  This will continue to automatically decrease as Azure Queue length is evaluated every 5 minutes.

And after a few more minutes, we get right back down to only (1) running instance:

And there you have it! All these instances were scaled up and down automatically without any human intervention!

This was just a simple walk-thru and demo of the new capabilities in the Windows Azure Auto-Scaling Application Block – this is only a small sample of the automation capabilities exposed by the block.

I would encourage you to try it for yourself and see how easily you can create a truly dynamic, elastic, and “self-aware” Azure cloud infrastructure.

You can download the sample demo code here.  Please remember to modify the project for your own Azure credentials for storage and host environment settings.

Happy Auto-Scaling!

The Windows Azure Auto- Scaling Application Block (WASABi) is now available as a beta release and it allows developers and IT professionals to add and manage *Automatic* Auto-Scaling capabilities for Windows Azure hosted services and applications.  The block is a part of the Windows Azure Integration Pack which is still in beta – but should be coming soon. 

One of the key benefits that Windows Azure delivers is the ability to rapidly scale your application in
the cloud in direct response to sudden changes in demand and/or for scheduled time periods to handle known peak and non-peak time periods.  These are key characteristics of an elastic cloud infrastructure.

When you deploy an application to Windows Azure, you deploy roles as either Web roles for the externally facing portions of your application and Worker roles to handle backend processing.

When you run your application in Windows Azure, your roles run as role instances (i.e. virtual machines). You can specify how many role instances you want for each of your roles: the more instances you have, the more computing power you have available for that role, and consequently the more it will cost you.

In Windows Azure, you can specify the number of instances you require for each your roles when you first deploy an application to Windows Azure.  You can also add or remove role instances "on the fly" while the
application is running, either manually through the Windows Azure portal, or programmatically by using the Windows Azure Management API.

By adding and removing role instances to your Windows Azure application while it is running, you can balance the performance of the application against its running costs. You can add new instances when demand is high, and remove instances when you no longer need them in order to reduce running costs. 

If you rely on manual interventions to scale your application, you may not always achieve the optimal balance between costs and performance: an operator may respond late, or underestimate the number of role instances that you need to maintain throughput.

The Windows Azure Auto- Scaling Application Block (WASABI) will now allow you to create logical rules to (almost) completely manage your cloud infrastructure to handle both peak loads and be as stingy as possible when it comes to deploying required infrastructure to manage web workloads and ultimately costs.

Below are a few code snippets and screenshots to give you an idea of the flexibility and power that the WASABI block  provides.

Basic Set-up – Constraint Rules:

Rank = order of precedence for Rule Evaluations – *Remember this to prevent a full transition to SKYNET.

Range = You can set this by Role along with the minimum and maximum number of instances.

*Note: The “max” range setting can potentially have negative financial consequences.  Please don’t ask me how I know this. 

An automatic auto-scaling solution reduces the amount of manual work involved in dynamically scaling an application.

It can do this in two different ways:

• Preemptively by adjusting the number of role instances based on a timetable rule.
• Reactively by adjusting the number of role instances in response to some performance counter or measurement that you can collect from your application (business KPI) or from the Windows Azure environment.

Preemptive Rule Example:

Auto-Scale UP on the second Friday of the month at 3:25 pm for 5 minutes starting on 10/14/2011:

 

Reactive Rules Example:

Spin Worker Role Instances Up or Down in Response to the Length of an Azure Queue:

Resources:

Autoscaling Application Block - BETA 
http://entlib.codeplex.com/releases/view/74618

Windows Azure Autoscaling Block BETA is out
http://blogs.msdn.com/b/agile/archive/2011/10/13/windows-azure-autoscaling-block-beta-is-out.aspx

Summary:

The Windows Azure Auto-Scaling Block WASABI provides a huge leap forward in terms of allowing IT pros and developers to create a fully automatic, ,elastic, and scalable cloud infrastructure. The block includes a very flexible way to implement simple or complex rules to either react or plan computational resources.

Caveat: You will still need to have a “carbon-based-browsers” evaluate the results of your auto-scaling solution on a regular basis to ensure that it is delivering the optimal balance between costs and performance.  

Other than that bit of advice – enjoy your newly found work-life balance as a result of implementing a reactive and self-managed cloud infrastructure!

Have fun!

*In my next blog post I will walk you through the WASABI installation process and how to create and host a simple example in Azure so you can see how powerful this capability can be for automatically scaling your cloud infrastructure.

A big thanks to all the local AOIT High School students who came to my presentation today at the 5th Annual Student Industry Conference presented by the Academy of Information Technology and Miami-Dade County Public Schools.  I’d also like to thank our hosts for the event, Miami-Dade College, for the use of the Wolfson Campus facilities. 

The topic of my talk today centered around a discussion of "what are the current software application development trends" that are impacting the industry today and what should students consider in order to be relevant when they hit the job market.  Here’s a brief summary of the topics we covered today:

‘

(I now know what the perfect gift is for Fathers Day…)

And for all of those who I may have inspired to start creating the next generation of mobile applications and games on Windows Phone 7 – be sure to check–out Rob Mile’s new XNA Game Studio 4.0 programming book to help get ramped-up quickly with tons of examples and sample code. 

I hope to see you all again next year!

Windows Phone 7 provides an exciting new opportunity for companies and developers to build applications that travel with users, are interactive and attractive, and are available whenever and wherever users want to work with them.

By combining Windows Phone 7 applications with on-premises services and applications, or remote services and applications that run in the cloud (such as those using the Windows Azure™ technology platform), developers can create highly scalable, reliable, and powerful applications that extend the functionality beyond the traditional desktop or laptop; and into a truly portable and much more accessible environment.

This guide describes a scenario around a fictitious company named Tailspin that has decided to include Windows Phone 7 as a client device for their existing cloud-based application. Their Windows Azure-based application, Surveys, is described in detail in a previous book in this series, Developing Applications for the Cloud on the Microsoft Windows Azure Platform. For more information about that book, see the MSDN® page at (http://msdn.microsoft.com/en-us/library/ff966499.aspx).

Common Scenarios:

"Introducing Windows Phone 7" provides an overview of the platform to help you understand the requirements and advantages of creating applications for Windows Phone 7. It provides a high-level description of the possibilities, features, and requirements for building applications for Windows Phone, and it includes references to useful information about designing and developing these types of applications. It also includes a glossary of terms commonly used in mobile application development. It's probably a good idea to read this chapter before moving on to the scenarios.

"Designing Windows Phone 7 Applications" discusses planning and designing applications for Windows Phone 7. It covers the run-time environment and life cycle events for your application, how to maximize performance on the phone, and considerations for the user interface, resource management, storage, connectivity, and more.

"The Tailspin Scenario" introduces you to the Tailspin company and the Surveys application. It describes the decisions that the developers at Tailspin made when designing their application, and it discusses how the Windows Phone 7 client interacts with their existing Windows Azure-based services.

"Building the Mobile Client" describes the steps that Tailspin took when building the mobile client application for Windows Phone 7 that enables users to register for and download surveys, complete the surveys, and upload the results to the cloud-based service. It includes details of the overall structure of the application, the way that the Model-View-ViewModel (MVVM) pattern is implemented, and the way that the application displays data and manages commands and navigation between the pages. The following chapters describe the individual features of the application development in more detail.

"Using Services on the Phone" discusses the way that the Windows Phone 7 client application stores and manipulates data, manages activation and deactivation, synchronizes data with the server application, and captures picture and sound data.

"Connecting with Services" describes how the client application running on Windows Phone 7 uses the services exposed by the Windows Azure platform. This includes user authentication, how the client application accesses services and downloads data, the data formats that the application uses, filtering data on the server, and the push notification capabilities.

"Interacting with Windows Marketplace" describes how you can distribute and sell your applications through Windows Marketplace, and the restrictions and conditions Windows Marketplace places on your applications and content.

Check it out here: http://msdn.microsoft.com/en-US/library/gg490765

And here: http://wp7guide.codeplex.com/

Enjoy!

That’s right – with yesterday’s announcement, the tools are now final – now is the time to “Lock & Load” on building the next generation of amazing mobile applications – Powered by Windows Phone 7.  Whether you are newcomer to the platform or already have been developing with Silverlight or XNA you’ll find the transition is painless, quick, and easy.  Your first stop is the Windows Phone Developer Portal for all the resources to get started building your applications today. 

Next, get a head start and be ready for the upcoming Windows Marketplace for Mobile launch by signing-up (it costs just $99) and get ready to register your applications in the marketplace.  Savvy marketers will tell you that “first in wins” –  there’s nothing like being found on the shelves of a brand new store.

Here are some additional guides & resources to help get you started quickly:

• Application Platform Overview for Windows Phone: http://go.microsoft.com/?linkid=9713249
• Windows Phone UI Design and Interaction Guide: http://go.microsoft.com/?linkid=9713252
• Designing Web Sites for Phone Browsers: http://go.microsoft.com/?linkid=9713253
• Code Samples: http://go.microsoft.com/?linkid=9713254
• WP Blog Announcement: http://windowsteamblog.com/windows_phone/b/wpdev/
• Tools Download Center Landing Page - http://www.microsoft.com/downloads/details.aspx?FamilyID=04704acf-a63a-4f97-952c-8b51b34b00ce;
• Headless Download (direct to .exe) - http://go.microsoft.com/fwlink/?LinkId=185584;
• Release Notes - http://go.microsoft.com/fwlink/?LinkId=185269 
• WP7 Jump Start registration training link (live class 9/21) - https://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032462274&Culture=en-US
  

Get ready to see some amazing new experiences on the Windows Phone 7 platform!

Looking to get a jump-start on some building some great Windows Phone 7 applications? And even better - without leaving your desk?

Windows Phone 7 promises to be an amazing mobile phone operating system given its innovative user interface and functionality, as well as its great development platform upon which you can quickly and easily build games and applications.

This course is organized into four virtual instructor-led sessions that are of 3-hour duration. They will be presented by forthcoming MS Press authors and MVP's, Andy Wigley and Rob Miles. It will provide developers a jump start for developing Windows Phone 7 applications. Labs will be completed offline with office hour access to the instructors.

This session is the first of 4 sessions.  Please register for all 4 in order to complete this training.

July 20th
Session One:   Windows Phone 7 Jump Start

What are you waiting for? This IS your invitation….