Dean Hachamovitch, who runs the IE team, spoke first.  His main focus was an update on the progress of IE9.

• History
• In the last year: IE8 getting big, Windows 7 released, IE6 going away
• Still supporting IE6 with security updates
• Making a big effort to get people off IE6
• Performance
• new JS engine: “Chakra”
• IE9 current SunSpider v0.9 score: 599 (IE8 > 3000)
• Compiled JS in background, on separate core if possible, to take full advantage of the hardware
• Standards – goal is to be totally standards compliant
• They did a study of 7000 sites, looking at what Web APIs they used.   Some common ones include indexOf, CSS opacity change, getElementById, addEventListener
• DEMO: same markup in IE9, Chrome, FF using event listeners and opacity on hovers
• DEMO: CSS3 selectors test, IE9 passes 578/578 tests
• DEMO: Border radius changes -- serious browser differences between IE9, Chrome, FF
• ACID3: IE9 passes 55/100
• Working with standards committee and other browser vendors; contributing DOM, CSS3 Standards compliance tests to W3C (100+ tests)
• GPU powered HTML5
• DEMO: rotating logos in 3D:  in IE9 very little CPU with 256+ logos and 60fps; Chrome 2fps with 32 images using both cores; FF a little better but still hitting CPU
• Platform Preview: download it today
• Lightweight frame around IE9 core
• no back button
• no phishing protection
• does have devtools
  • Network tab to capture traffic
  • Script tools
  • SVG support
  • Force IE5/7/8 document mode
• Goal: update every 8 weeks
• More forums for community
• HTML5 Video
• Not there today, coming in an update
• DEMO: YouTube, not using flash
• DEMO: chrome 720p = peg both cores, drop frames; IE9 running two HD streams, both cores about 40%, no frame drops
• DEMO: Video carousel with opacity compositing on same surface

Scott Guthrie was up next, talking some more about the tools.

• VS10 and .NET 4 will release in April
• Code Editing improvements
• Full multimon support  -- drag tool windows out to other monitors, etc.
• Better intellisense
• faster for all JS libraries, including 2x on YUI and jQuery
• substring matching and CamelCase matching (e.g., typing SCC will match SomeCoolClass)
• Better code navigation
• Class visualizer
• Debugging improvements
• Historical debugging
• Debug managed minidumps in VS without SOS
• Threading visualization
• Parallel task visualization
• ASP.NET improvements
• WebForms clean markup, no inline styles, better CSS support
• Smaller ViewState (ASP.NET)
• Clean Semantic URLs out of the box
• Better controls
• Support for MVC 2.0 built in
• Multiple configs for web deployment
• One-click publish: content, code, databas
• jQuery
• making code contributions
• providing QA and testing support to the community
• OData
• iPhone support
• SharePoint: lists exposed as OData
• Excel: support for pivot, chart, etc. using OData sources
• Support for jQUery, palm webOS, php, restlet
• .NET OData client released under apache2 license

Overall, Day 2 was interesting, but not as much as Day 1.  The tools are getting better all the time, which is good.  Hard to say what will happen with IE9 – it demos well today, but who knows what will happen when it releases.  I know for me, I don’t spend much time on the web other than looking for what I need, so browser startup time is the biggest thing for me.  IE8 doesn’t have it, so I don’t use it.  We shall see…

As always, you can see the keynotes and other videos here.

Features

• .NET: superset of Silverlight 3
• WCF support for SOAP and REST
• Media: capture and playback
• Phone access: phone UI, sensors (accelerometer now, IP-based sensors later), picker for contacts and photos [NOTE: programmatic access to the camera will not be available in v1; however, a flow where you can have the user hit a button, take a picture, then kick you back to the app to bring up the photo picker will be there]
• Data: Isolated storage, LINQ to objects/XML
• Cloud: app deployment and updates, push notifications, location, Xbox LIVE [can use SL and not XNA and still write an Xbox LIVE game!]

Application Model

• App runtime: .NET CLR
• Process model (OS): Windows CE with some abstractions
• Deployment: service-based, deploy to marketplace, then to phone

Development lifecycle

• Emulator testing
  • Phone OS compiled for x86 running virtualized; it is NOT emulating the ARM processor
  • 3D accelerated using Direct3D
  • Multitouch support so that you can test your touch interactions without debugging on the device!
• Device testing
  • Web-based service which allows you to unlock your phone for debugging purposes and use debug tools on the device
  • Dev tools can start debug on the device
• Packaging
  • Basic idea: dev/debug/test > submit for review > certification and signing > Windows Phone app deployment service > marketplace
  • Review process includes business policies, technical policies, and content policies.  More detail tomorrow.

Marketplace

• Similar to iTunes
• Browse apps
• Try before you buy!  Apps can query the IsTrial() API and expose the proper set of features; to upgrade from trial to full, there is a built-in UI that is one API call
• Payment flexibility
• Automatic application updates (user must OK)

Misc

• All UI is accelerated through DirectX; preserve battery
• Push notifications are all done through a single pipe; focus on efficiency and battery life
• Deployment within an enterprise will be up to the enterprise in v1 – pure consumer focus right now
• No demand-loading XAPs in v1 [this is common in Silverlight apps today], so you have to ship all your code in one package
• No announcements yet on Silverlight for XBOX
• No sharing data between applications – IsolatedStorage is sandboxed.  To share data use a cloud service.
• IPC only available for built-in apps, not for 3rd parties in v1
• No background apps, but common scenarios work, such as continuing to play music, phone call, etc.; also live tiles can update through the notifications service

All in all, it has a lot of promise.  I’m going to play around with it and kick the tires. ;)  If you want to get the devtools, go to http://developer.windowsphone.com/windows-phone-7-series/.

You know it’s going to be a demo-packed keynote when ScottGu is the opening speaker.  He’s known for talking a little, demo’ing a lot, and writing code onstage.  Today was no different.  Here’s how the keynote went down.

Silverlight 4

• Deployed > 60% of desktops (was 45% at PDC in November)
• Large enterprises starting to adopt
• Consumer sites: MLS, NBC Olympics, Sunday Night Football, Netflix, Bing Maps, Victoria’s Secret, UFC, McDonalds, NCAA March Madness
• Vancouver Olympics
  • 12 million hours streamed, up to 76 minutes in a single stream, up to 720p
  • IIS Smooth Streaming
  • live ad injection
  • rough-cut editor written in SL for immediate highlight publishing
  • open source player and tools: http://smf.codeplex.com
• New features in SL4 RC
  • Fullscreen on secondary monitor
  • Pivot control for large data set visualization

Windows Phone 7

Windows Phone 7 is VERY similar to iPhone and Android (not surprisingly).  It has a very Zune-y flavor, but a lot of the interactions are very similar.  Basic facts:

• Every device is a Zune
• Dev platform: Silverlight 3 + XNA
• 3 buttons on the bottom: start, search, back
• UI Leverages the Pivot control
• App bar – common place to find application buttons, sits at the bottom of the app’s UI – is expandable vertically as well as contextual so that you can offer different choices based on app state
• Item delete – small checkboxes next to the item; check one and they all get bigger so you can check more
• Start Menu
  • Main screen has tiles for each app; each tile is live and can animate its content, etc.
  • Press and hold to rearrange/delete apps like iPhone
• Hubs
  • A hub is a pivot with content/apps that are similar, e.g., Music, Photos, People, etc.
  • Panoramic UI – content wider than screen with columnar panning
  • Applications can plug into a hub – e.g., a photo editing app would sit in the Photos hub as opposed to living in a random list
• Monetization
  • Because it’s silverlight, you have rich ad content opportunities
• Full hardware acceleration for max performance

The development platform is one that is very familiar to Windows devs.

• Same programming model/code/tools as desktop SL3 apps
• Visual Studio 10
  • Templates for blank app, list-based app with navigation, class library
  • Can test on emulator (which is FAST) or the device
  • Emulator supports MultiTouch on Windows 7 so you can test right there!
• Blend 4
  • Can build an app just like you would build a regular SL app
  • Can launch testing on emulator from within Blend
• Features
  • Media (DEMO: Netflix.  Great fidelity for the media.)
  • Deep Zoom (DEMO: Graphic.ly)
  • 3D (DEMO: XBox Live game)
  • Location/map (DEMO: foursquare)
  • Push Notifications (DEMO: MLS)
  • Microphone/Camera (DEMO: Shazam for microphone)
  • Accelerometer (DEMO: “Marionette” – funny)
  • Other demos
    • seesmic plugging in Bing maps
    • Coding4Fun Cannon – controlling a cannon that shoots T-Shirts using the accelerometer
    • XNA gaming

Overall, the technology seems exciting.  The dev story is way better than on Android.  I can’t speak for iPhone.  But if Microsoft is able to deliver on the handsets and market them well, they should be able to get developers writing apps – god knows there are enough of us .NETters out there waiting to write apps. ;)

If you want to watch the keynote, go to http://live.visitmix.com/.  I haven’t seen it there yet, but it will be soon, I’m sure.

UPDATE: here’s the on-demand video gallery.

Windows 7

Steven Sinofsky, who runs the entire Windows division, led off talking about Windows 7.  First, Steven went through the background on how they engineered Windows 7.  Given all the problems that Vista had, it was important that they learn from everything and do it right.  Here is the basic timeline and goals:

• Collect feedback from the community – the “Engineering 7” blogs were a great start
• Do tons of research on what’s wanted, needed, etc. – user studies, surveys, …
• Determine ecosystem readiness
• Have a good rhythm of pre-beta, beta, RC, RTM
• Collect a ton of telemetry.  Here are some of the data collection mechanisms:
  • “Send Feedback” button
  • Hardware/Device Diagnostics
  • Reliability Analysis Component (RAC)
  • Software Quality Monitor (SQM)
  • Windows Error Reporting (WER)
  • Numbers associated with the telemetry collected during the Win7 process.  It’s a ton of data.
    • 1.7MM “send feedback” reports
    • 91k unique hardware devices connected to the machines
    • 14k unique printers (!) connected to the machines
    • 883k unique applications installed
    • 10.4MM aggregate WER reports
    • 4700 code changes stemming from WER
    • 6k SQM data points
    • 900MM logon sessions logged
    • 514MM start menu clicks
    • 46MM uses of Aero Snap and Aero Shake

Overall, it was clear that they put a ton of work into making Windows 7 more stable and reliable than Vista.  So far in my usage, it’s much much better – boots extremely fast even though I have a lot of junk installed, is responsive, and causes very few issues.

On the developer side, Windows 7 adds a ton of new features that applications can take advantage of, including:

• New taskbar (the “SuperBar”)
• New Aero features – Snap, Shake, Peek
• Multitouch
• Location and Sensor APIs
• DirectX 11.  Great demos.
  • an app with 20,000 stars in a system interacting with one another.  Using DX11 hardware along with the DirectCompute APIs (which use the GPU for computation) running at 702 GFlops, minimal CPU, 73 degree temperature; DX10 hardware was pegging 8 cores at 100 degrees and getting 17 GFlops.
  • First-person game showing the difference in ability to tesselate polygons by one or two orders of magnitude on DX11
• Hardware support for media transcoding

Also, I attended the Windows 7 Dev Camp on Monday. Of particular interest was the Windows 7 Kernel Changes talk.  It was put on by Mark Russinovich of SysInternals fame, as well as Arun Kishan and Landy Wang, both of whom are architects on the kernel team.  What they discussed were all the changes and improvements made to the kernel in Windows 7.  Highly fascinating.  There are also two sessions from the conference on the same topic – watch them here and here.

IE Update

They just started IE9 a few weeks ago.  The goal is to improve standards compliance even more, support HTML5, improve JS performance (compiled?), and take advantage of hardware acceleration for graphics a text.

Steven ran a demo of IE9’s current build, and showed off some of the speed and rendering.  So far it looks promising, but it will take a ton of work to make it the browser everyone really wants to use.

Silverlight

Scott Guthrie came on stage next to talk about developer tools, and SDKs.  He led off with Silverlight.  SL3 released in the summer, and currently has a 33% penetration (total SL penetration is at 45%, compared with 25% at MIX09 in March).  So overall adoption is growing, thanks to big wins with Netflix, NBC (Olympics and Sunday Night Football), Major League Baseball, the Democratic National Convention, the White House, etc.

He then went on to talk about Silverlight 4, which is slated for release in the first half of 2010.  SL is on a pretty aggressive release schedule – SL2 was October 2008, SL3 was July 2009, and now SL4 in H1’10.  They are working hard to penetrate the market to better compete with Flash in the browser.  But they are also trying to make Silverlight the cross-platform development platform of choice for desktop apps (competing with Adobe Air, primarily).

It seems like Microsoft’s strategy is multifaceted:

• In-browser: Silverlight competes with Flash.
• Out-of-browser: Silverlight competes with Adobe Air 2.0 (see a link here by an Adobe evangelist) and other cross-platform application shells like Titanium
• Windows desktop application: Silverlight becomes a lighter-weight desktop platform than WPF with much of the goodness that WPF offers.
• Windows desktop application: WPF offers an even richer application development platform.

[Aside: Many people are having the “Is WPF dead?” discussion these days.  I don’t think it is.  Silverlight is definitely the platform-of-choice in many instances, but WPF has legs – Visual Studio 2010 is being built on it, and other applications inside Microsoft are probably watching that project intently to see if WPF is something they can move to.  The current Beta 2 of Visual Studio 2010 is very good so far.  If you watch Paul Harrington’s session on how they’ve built it, it’s pretty impressive.  We had to solve a lot of similar problems on our project and it was interesting to compare their solutions with ours.]

The features announced in Silverlight 4 are very ambitious, but also very needed.  Following is a rundown.  If you read the Adobe link I referenced above, you’ll see tons of overlap.  I don’t think that’s a coincidence.

• Media Enhancements
  • webcam and microphone access (raw stream access, API to select devices)
  • multicast HD streaming
  • output protection (ie., no display on external monitors if you choose)
  • Offline DRM, MP4 DRM
  • Silverlight Media Framework (codeplex project for media)
  • IIS Smooth Streaming
    • exists in SL3
    • SL4 adds iPhone support (other devices coming) – backed will re-encode on the fly from the same URL.  Scott demo’d a video in browser and then on iPhone with the same URL.
• Out of Browser (OOB) (introduced in SL3 but very rudimentary)
  • Sanboxed Mode
    • add Windowing APIs for positioning, min/max/normal, topmost, application activate
    • add toast APIs for rich toast notifications
      • arbitrary content
      • up to 400x100 and 30s
      • no opacity or rounded corners
      • no popup launching
      • fixed location per OS (lower-right on Windows, upper-right on Mac)
    • HTML hosting support – introduced primarily to support ads
      • only works in OOB mode, not in-browser
      • can navigate to a URL or get/set content
      • Windowed hosting with interop (IE on Windows, WebKit on Mac) – by default not compositable
      • For compositing, there is an HtmlBrush (like the VisualBrush in WPF) where it renders the browser offscreen and composits the bitmap.  This is live, so if your webpage is on YouTube playing a video, you see the moving video in the brush.  The demo was a jigsaw puzzle that he scrambled.
      • Supports browser plugins
    • Drop target support – drop a file from the filesystem onto the app and it can be opened
    • Add/Remove Programs integration
  • Full Trust Mode (new in SL4)
    • Custom window chrome
    • Local file system access (My Documents)
    • Cross-site network access
    • Keyboard use in full screen mode
    • Access to hardware devices
    • Access to full path in Open/Save dialog
    • COM Automation – office, Windows 7 APIs, anything that’s IDispatch; uses the C# 4.0 “dynamic”
  • OOB Demo: Facebook
    • add Facebook events directly to Outlook calendar using COM
    • take photo with webcam and upload as profile picture
    • inline video playing using H.264 support or hosted HTML page with video
    • drag/drop photos from desktop and upload to Facebook
    • pull in photos from external camera for upload
    • multitouch support
• Application Development features
  • Printing support – custom view of any element; can print offscreen elements
  • Rich text support (like WPF)
  • Full system clipboard access
  • Right-click and mousewheel access
  • Implicit styling (don’t need a ResourceKey)
  • bi-directional text, RTL support (Hebrew and Arabic fonts)
  • commands and MVVM support
  • more controls
  • extended PNG support
  • CLR4 support
• Data and Networking
  • Share assemblies across SL and .NET 4
  • binding improvements (IDataErrorInfo, async; StringFormat; etc.)
  • UDP multicast supports
  • REST enhancements (ADO.NET data services)
  • WCF improvements (TCP channel support)
  • WCF RIA Services
• VS10 Support
  • WYSIWYG SL design surface
  • XAML Intellisense++
  • Binding, layout, styles
  • WCF RIA Services integration
• Performance
  • Full JIT support – 2x speedup
  • 30% faster to start up (up to 80% in some cases)
  • NGEN the system assemblies to avoid JIT
  • ICorProfiler support for real perf tools
  • 5MB download, 10s install

If you want to watch some Silverlight sessions, go here.

Overall, the tools and SDKs talk was much meatier (for me, anyway) than the Azure stuff.  There is a ton of great stuff coming down the pike.

Other links:

• See the Day 1 Keynote Roundup here.
• Watch the Day 2 Keynote here.
• Full session list (with videos) is here.

Day 1: Client Side

A core tenet of the strategy is deploying to Three Screens – desktop/laptop, TV/big LCD, mobile.  They want to have primarily web/cloud-centric experience with rich desktop/device integration.  They want to make IE the best standards-based browser (IE9 is already in development as of 3 weeks ago), and use Silverlight to deliver rich in-browser experiences.  This isn’t really new, and is completely expected.

Day 1: Windows Azure, redux

Azure is the set of cloud services that Microsoft announced last year, aimed squarely at competing with services offered by Amazon, Google, etc.  Last year’s technology was based purely on the Microsoft stack – you would use Visual Studio, SQL Server, IIS, etc, and then deploy your app to the cloud using SQL data services and the like.  From a developer’s perspective, this was great, because you had a fully integrated local solution to build and test, and (literally) with the push of a button, deploy to the cloud.  There are control panels for configuring things like how many virtual machines you want, and it’s all based on a pay-for-play model (though they have not started charging anyone yet).

The problem with that scenario is that many companies don’t want to (or can’t) tie themselves to that stack.  So this year, part 2 of the Azure strategy is to open up the platform for a more a la carte selection of features.  For instance:

• You can now talk to Azure services if you’re running in a “AMP” stack
• There are a number of services targeting developers and IT that will run under a service called PinPoint – you can pick whichever you want and use them
• Project “Dallas” will offer all sorts of commercial and public data sets for consumption in your apps
  • open marketplace
  • uniform discovery and binding to data
  • working with the government to run data.gov for public sources
• REST-based service management
• Multiple virtual machine sizes, so you can choose what’s best for you
• XDrive – a storage blob, mountable as an NTFS virtual hard drive
• database services – simple creation, replication, etc.
• AppFabric – new application server; extends IIS to build scale-out services
  • includes caching, service bus workflow/hosting, monitoring, service hosting, access control
• Project “Sydney” – allows you to connect the systems in your existing data center (not necessarily Windows boxes) to Azure services

These solutions will ultimately help them get more apps running on different components of the Azure platform.  There were the usual demos, including:

• WordPress.com – running the “AMP” part of LAMP but using Azure services
• The Cheeseburger Network (of Lolcats fame)
  • 40 blogs, 8MM page views, 10k submissions, 100k votes
  • Need to handle spikes, do it via config
  • Windows Azure storage plugin for WP

Overall, the strategy that they laid out isn’t really anything different than expected.  No major announcements on Day 1 aside from the next steps in the Azure world.

Other links:

Watch the Day 1 Keynote here.

One solution I offered was one we did on Messenger where we used a combination of a TabControl and ListBox to achieve the desired behavior.

• TabControl retemplated to remove the ContentPresenter where it normally shows the selected content
• ListBox with a Grid as the ItemsPanel
• both controls bound to the same data source with IsSynchronizedWithCurrentItem=”True”

This solution works well, but it’s kind of klunky.  So I dug through Reflector at the TabControl and found that it wouldn’t seem to take much to make a TabControl subclass which did what we needed.  So I pressed on. ;)

The upshot to the solution is the following:

• subclass TabControl.
• override OnApplyTemplate and find the template part which is the Panel (named “PART_ItemsHolder”, normally a Grid) that will house all the potential selected content items.
• as the selection changes (or items are added), create a ContentPresenter to house the selected content.  Add it to the PART_ItemsHolder.
• as items in the control change (OnItemsChanged), remove any ContentPresenters from PART_ItemsHolder that correspond to removed tab items.
• when an item is selected, the content is made Visible; when deselected, it’s Collapsed.

This solution seems to work pretty well, and it allows us to keep the ability to databind the ItemsSource or add TabItems directly.  It also is non-greedy in that it doesn’t create child ContentPresenters unless an item actually becomes selected.

You can find a sample project here.  When you run it, there are 3 panes: the left pane is the “old” solution with the TabControl+ListBox; the middle pane is the “new” solution with databound items; and the right pane is the “new” solution with TabItems added directly.

Comments appreciated!

Today’s keynote was much shorter than yesterday’s but it had some good info.  If you want to watch the video, check out the MIX site.

IE8 released to the wild -- Dean Hamatchovich, the GM of Internet Explorer

Today marked the IE8 release to the wild.

• 25 languages, Vista/XP/Windows Server, x86/x64
• data driven design: tons of real-word data gathered from user sessions, home visits; 200+ data points in the product were measured
• search box now has suggestions AND history; quick links to other providers’ suggestions
• “New Tab” page now has more tab restore and accelerator options
• tab groupings and colorings based on task (e.g, if I open 5 tabs from a page I’m on, they’ll all be colored the same and grouped in the bar)
• tabs isolated for better crash recovery
• load performance is on par with Firefox and Chrome
• better online safety: XSS attack prevention; address bar domain highlighting; etc.

Overall, this isn’t much different than what has been around in the beta for a while.  I’ve been using IE8 today, and it actually is pretty good.

Changing Behavior Through Design – Deborah Adler

I wasn’t sure what Deborah was going to talk about, and I have to say I was pretty impressed.  As a developer, I’m not always plugged in to the decisions the designers are making – often things seem the same to me, but a designer would see them as completely different.  Deborah’s keynote opened my eyes to the power of design in a very clear way.  I highly recommend you watch the video.

For those who don’t want to watch the video, the short version is this: Deborah’s grandmother took the incorrect medication by mistake, which Deborah attributed to poor design of the classic prescription bottles.  She decided to make her thesis focused on researching and developing a newer, safer method of prescription packaging.  What results is the Target ClearRx program.  Very cool

More posts to follow…

First up was Bill Buxton.  Bill has been around for 30 years in the design world.  And I have to say, he was a very passionate, engaging speaker.  At close to 60, he’s got more energy than many people my age.  He spoke about how EXPERIENCE is the end goal of design, not just design for design’s sake.  He had some great historical examples from the first wave of industrial design in the late 1920’s.  Good stuff.

Scott Guthrie was next.  Scott’s keynote addresses are always free of fluff and full of stuff.  In that vein, here’s my all-stuff-no-fluff bullet list of what’s coming up:

Expression Web 3

The big news about Expression Web 3 is SuperPreview.  Read this page for a great description of it.  Definitely a big step forward in the world of browser compatibility testing.

VS 2010

See my post regarding a lot of this stuff from PDC.

Better tooling support for jQuery and JavaScript is also coming.

Web Platform Installer V2

This is an application which lets you pick and choose which tools you want installed in order to do web development.  You can configure and update the tools from within the WPI as well.

Azure Services Platform

• Adding FastCGI/PHP support.
• relational database in SQL Data Services
• more web standards in .NET Services
• commercial release in 2009

BizSpark

This is a free program where, if you are a qualifying startup, you get free tools and support for 3 years to get up and running.

Silverlight 3

This is the big announcement.  There is a ton of stuff they are releasing.  You can look at more info at the official Silverlight site, but here’s the rundown:

• > 200 partners in 30 countries.  Lots of big names – Netflix, NBC, Intuit, etc.
• Media
  • GPU h/w accel
  • H.264, AAC, MPEG-4
  • raw bitstream API (custom video format decoder plugins that you can write)
  • better logging for media analytics
• Graphics
  • perspective 3D
  • Bitmap and Pixel APIs
  • pixel shaders
  • Deep Zoom improvements
• App Development
  • Deep linking, better navigation, SEO
  • ClearType and other text improvements
  • MultiTouch support
  • 100+ controls available
  • Library caching: reference an assembly and get it on demand (not in XAP) and cache it
• Data
  • ElementName binding
  • validation error templates
  • server data push improvements
  • binary XML networking support (transparent persistence of data?)
  • multi-tier REST data support
• Out-of-Browser
  • API call to Detach() the app – prompts the user to allow
  • app still sandboxed, uses same site of origin
  • can write offline-aware apps; gets events for network status changes
  • can integrate with underlying OS (e.g., Start Menu or Desktop)
  • autoupdate support a la ClickOnce
• Release Details
  • Download size: 40k less than SL2 because they give you the ability to break out libraries that get downloaded and cached on demand
  • Beta today, release later this year

Blend 3 [get the beta at the official Silverlight site]

• SketchFlow
• PSD and Illustrator import with layer preservation and editing
• Behaviors – like triggers on steroids
• create, import, edit sample data to bind to
• source code control
• XAML, C#, VB intellisense
• watch the demo in the keynote video!!   [It starts about 3/4 of the way into it – sorry I don’t have a time, but the player doesn’t have it! :(]

IIS Media Services

• smooth streaming
• DVR-like support on a *live* stream
• edge caching (Akamai)
• web playlists
• bit-rate throttling
• advanced logging
• instant seek drops the bitrate for a short time so that video is more instant; keeps constant bitrate for better UX, even if that's a little lower than impulse max
• NBC Olympics in 2010 will use this
  • 720p HD
  • DVR
  • super slow-mo and high-res frame capture
  • metadata overlays
  • live video alerts
  • real-time feeds

Overall, some awesome stuff is on the way (or is it already here?).  Tomorrow, we’ll see some IE8 previews.

The Basic Idea

Let’s digress first to the Win32 world.  In these apps, it’s pretty trivial to do this: handle the WM_GOTFOCUS message, and call ::SendMessage(hWnd, EM_SETSEL, 0, -1).

In Windows Forms, it’s equally simple: handle the control’s GotFocus event and call textBox.SelectAll().

In WPF, you would think you would just handle the GotFocus event and call textBox.SelectAll() as well and be done.  This will sort of work, but it’s not acceptable.  Run this simple app (full source) to see this solution in action.  The app will open up and set focus to the first text box, causing it to SelectAll().  Tab back and forth between the text boxes, and you will see that the behavior is as expected.  So far, so good.

The issues begin…

Now, hover the mouse over the text in the TextBox that doesn’t currently have focus so that the cursor is an I-Beam.  Click and hold the mouse – you will see that all the text gets selected.  Now release the mouse.  Huh?  Where’d the selection go?!?!

As it turns out, the TextBox captures the mouse and waits for the MouseUp to take action.  When the TextBox gets the GotFocus event, the event handler gets called and we call TextBox.SelectAll(), which is fine; however, when the user releases the mouse, the TextBox’s OnMouseUp override gets called which somewhere down the line will cancel any extended selection and then set the cursor.

To mitigate this, you might try using Dispatcher.BeginInvoke() to delay the call to TextBox.SelectAll().  Run the same simple app (full source) to see that in action – just check the box to put the app into the Dispatching mode.  [You should dispatch at ContextIdle priority so that it runs *after* any Input is received, so that you can get the MouseUp event before you call SelectAll().]  This solution actually works OK; however, there are a couple glaring gotchas.  First, if you click-and-release too fast, my guess is that some deferred operation in the MouseDown handler won’t run before MouseUp, so it kills your selection.  Second, if you wait too long (the greater of SystemParameters.MenuShowDelay or 200ms, which isn’t that long!) to MouseUp, the ContextIdle priority items will run (including your SelectAll()), and then the MouseUp handler inside the TextBox will kill your selection.  Not a good UX.

[Complicating things more is the fact that the TextBox will try to start a drag/drop operation if you move the mouse while it’s down, which results in another codepath which can mess with you.]

UPDATE: thanks to Andrew for the great suggestion about calling TextBox.ReleaseMouseCapture() after you call TextBox.SelectAll().  This does seem to mitigate the issue of the selection clearing on MouseUp pretty well.  However, caution still applies because if the underlying implementation of TextBox changes drastically in the future (it likely won’t, but it could), this solution might break.  I’ve updated my code that is linked off this article to reflect the change.  Note that dispatching the SelectAll() call isn’t necessary, but I haven’t removed the checkbox.

For more complications, hover the mouse over the text in the TextBox that doesn’t currently have focus so that the cursor is an Arrow.  Usually, you can do this by pointing to the bit of whitespace just below the text.  Click and hold the mouse – as before, you’ll see that all the text is selected.  Now release the mouse – lo and behold, it stays selected!  This is because the drag/drop operation above didn’t begin, so the code executed correctly.

Finally, hover the mouse over the TextBox that doesn’t currently have focus so that the cursor is an I-Beam *and* the mouse is to the right of the text between the last character and the right side of the TextBox.  Click and hold the mouse, and -- no text is selected.  Sigh.

I know what you’re thinking: “Uh, OK, so how do I solve my Select-All issue?”  Turns out, there’s not really a one-size-fits-all solution.  To really understand how best your app should handle this, we need to dive into how the concept of focus works in WPF.

Keyboard vs. Logical Focus

In WPF, there are two different types of focus: Keyboard focus and Logical focus.

Keyboard focus means the UIElement which will receive any keyboard input.  There can only be one UIElement in the entire application (and only one HWND in the Windows environment) which can have Keyboard focus.  (If there were more than one, how would the system decide which one should get the input?)

In Logical focus, there is the notion of a “Focus Scope”, which is an application-defined boundary around a group of UIElements.  Each Focus Scope maintains its own “Focused Element” which can be different than the element that has Keyboard focus.  For example, consider the following XAML:

      <StackPanel
            FocusManager.IsFocusScope="True">
            <TextBox
                  x:Name="textBox1"
                  Text="Hello" />
      </StackPanel>
 
      <StackPanel
            FocusManager.IsFocusScope="True">
            <TextBox
                  x:Name="textBox2"
                  Text="Goodbye" />
      </StackPanel>

In this snippet, both TextBoxes can have Logical focus at the same time since each is inside a separate focus scope. However, only one can have Keyboard focus at any given time (which implies that it also will have Logical focus in its Focus Scope).

Much of the reason for logical focus was to make Menus and Toolbars work properly.  The canonical example is using a menu or toolbar to choose Edit > Copy after selecting text inside a TextBox.  Since Menus and Toolbars are Controls which can be focused, without the concept of Logical focus, the moment the user clicked on the menu, the selection inside the TextBox would disappear since it clears its selection rendering when it loses focus.  By adding Logical focus, and by making Menus and Toolbars have FocusManager.IsFocusScope = “True” by default (the Window is a focus scope as well), the TextBox will never lose logical focus and thus not clear its selection rendering.

Custom Focus Scopes

So… let’s see what happens when we introduce some custom focus scopes to our app.  Run this more complex app (full source) – you will see a more complex app with two TextBox on the left and two RichTextBox on the right, as well as a MenuBar at top.  The TextBoxes are inside one UniformGrid, and the RichTextBoxes are in another.  Each UniformGrid can be a Focus Scope, controlled by the CheckBox at the bottom. I also moved some of the “Select All” logic out to a class called TextBoxHelper which implements attached behaviors.

First, make sure the CheckBox is clear.  Select some  text in the first TextBox on the left.  Now click the File menu.  Note that the TextBox’s selection is still shown even though it doesn’t have Keyboard focus.  Now dismiss the menu.  The TextBox still has Logical focus.  Now type something – notice the TextBox has Keyboard focus again!  The reason for this is because once the control that did have Keyboard focus (the Menu) was Unloaded, the system set Logical focus to the parent Focus Scope (in this case, the Window).  Once a Focus Scope becomes the active Focus Scope, it gives Keyboard focus to the element within it that has Logical focus (in this case, the TextBox).

Still with me?

Issue #1 – Menus don’t behave

Now check the first box, so that the TextBoxes are surrounded by a custom Focus Scope.  Perform the same task as before.  Notice that this time, the TextBox’s selection clears when you click the menu, and it doesn’t get Keyboard focus back after the menu is dismissed.  This is because the TextBox is no longer inside the parent Focus Scope that the Menu is in (the Window) – it’s in a sibling Focus Scope now.  All bets are off.  This one is not mitigatable.

Issue #2 – Logical focus doesn’t change

Another issue that arises from having custom Focus Scopes is the retention of logical focus inside them.  Before we added the custom Focus Scopes, all 4 TextBoxes were inside the same Focus Scope (the Window), so clicking inside any of them gave that one Logical focus and removed it from the other.  However, once we added the custom Focus Scopes, the left and right sides were effectively isolated – it is now possible to have two different TextBoxes to have Logical focus.  As a result, if you click the top-left TextBox, then the top-right, then the top-left again, the GotFocus event will not be raised because it already had logical focus!

The way you can mitigate this is to use the PreviewGotKeyboardFocus event instead of the GotFocus event when you want to SelectAll().  Go ahead and check the box that says “Use PreviewGotKeyboardFocus instead of GotFocus”.  Now, as you click back and forth between the top two TextBoxes, the SelectAll() happens properly.

However, if you use this technique WITHOUT custom Focus Scopes, you will introduce…

Issue #3 – After dismissing the menu, the TextBox does a SelectAll() again

When you don’t have custom Focus Scopes, and you use Keyboard Focus events, what will happen is this: when the user clicks the menu, it will get the Keyboard focus.  When the menu is dismissed, the Window’s Focus Scope will get focus again, and give Keyboard focus back to the text box, which will use that Keyboard focus event to SelectAll().  Again, not a great UX.

Wrap Up

So, it’s clear there’s no “right” solution, but we have some guidelines.

• If you have no custom focus scopes, use the Logical GotFocus event.
• If you have custom focus scopes, but no Menus or Toolbars, use the Keyboard [Preview]GotKeyboardFocus event.
• If you have custom focus scopes as well as Menus or Toolbars, you will likely have to deal with some pain.

Download the full source for the examples in this article.

There can be a number of reasons for startup lag. One major reason (especially on Vista) is disk I/O -- literally, the startup time is dependent on how many bytes you’re loading off disk.

"OK," you say, "so how do I know how many bytes are being loaded?"

The answer is pretty simple: ProcMon + a little data munging. Here are the steps I’ve used, and they seem to work pretty well.

First, download and install the SysInternals Suite. (You can install just ProcMon, but there are a lot of good tools there.)

Next, make sure your machine is in a state where nothing is cached. Generally, this means you should turn off Prefetch and Superfetch. You also should make sure that anything that might be loading any .NET assemblies is turned off at system startup time, or that might skew your results.

Once your machine is cold started, run procmon.exe. You will be greeted with the Filters dialog (or you can hit Filter > Filter...). You’ll want to set it up with your EXE name, a ReadFile operation, the Path NativeImages (which is the .NET Framework’s NGEN’d assemblies), and any paths where your assemblies might reside. Once it’s set, OK the dialog.

Next, run your application. Soon you will be seeing the ProcMon window fill up with "Events". Once your app is to a point where you are ready to take a snapshot of the bytes loaded, go into ProcMon and choose File > Save. In the dialog, choose only the filtered events, and XML format with stack trace. You can choose symbol resolution, but my tool might not work with that right at the moment.

After you have done that, you’ll have a very large XML file. Download my tool from here which will calculate the number of bytes loaded from each assembly. Just run "BytesLoaded.exe <filename.xml>".

Here is the sample output from my tool run against Yahoo! Messenger for Vista (note that I did not reboot first):

So what does this information tell you? It tells you exactly how much code is getting loaded by each assembly as your app runs. What I normally look for first is assemblies I didn’t expect to get loaded at all, and assemblies that I might be able to defer until later (e.g,. deferred startup of services, etc.).

In the future, I hope to incorporate the stack trace and symbol information into the tool, which will help in finding which calls load the assemblies. Until then, you can launch WinDbg on your EXE, and type "sxe ld ModuleName.dll", and the debugger will break when that module is loaded. You can then look at the stack trace to see what’s happening. [NOTE: for .NET assemblies, and any assemblies you might have NGEN’d, you need to put ".ni.dll", not just ".dll", because that’s the name of the module that gets loaded.]

I also would like to automate the ProcMon part of things, but it’s not very easy, especially on Vista.

Comments are welcome. Hope you find this useful!

[Looking for Part 2 of this post? See it here.]

Watch the videos here. [You will need Silverlight 2.0, which you can install directly from this page.] Click on Day 2, then "Office Web Applications Extend Office to the Browser" or "Build Rich Social Applications with Live Services".

Live Services

Live Services is one prong of the Azure suite that was announced on Monday. Basically Microsoft will be making all their Live Services available to applications via a rich set of APIs that you can use from web, PC, or phone applications. The managed APIs fit right in with the .NET Framework in that they will expose a rich object model to the application, while doing a lot of the connectivity and data fetching behind the scenes. Client applications will be able to simply create a LiveFramework object and then make API calls to it. Where the data is persisted is largely immaterial to the application. This will make a number of scenarios much much easier.

One interesting example was the ability to sync data between applications via the Live Framework. They showed a photo sharing application with two users. User 1 applied an effect to the photo they were viewing and that effect was applied on the other user’s machine by using the Sync Framework. Pretty interesting.

Office 14

Yes, they skipped 13. Probably bad luck.

Office 14’s big news is that they are making applications available via the browser, which is a huge shift. These applications will be full-features and based on Silverlight as well as DHTML. There will be a number of interesting new features, such as:

• There will be full live synchronization between web, desktop, and mobile documents. If I am viewing a document and someone else edits it, I can sync the changes automatically.
• The apps will support concurrent editing of shared documents by using visual cues as to who is working on what portions of the document so that users can sync if they are about to conflict, or track where other users are editing so that conflicts don’t occur.
• There will be presence information during shared editing sessions. If someone is making a change (or made a change) to a doc I’m working on, the UI will reflect that and I can immediately IM, call, email, etc. with that person with one click.
• Live Web Widgets using REST. It will allow me to create a chart in excel, drop it into my blog, and whenever the page is refreshed, the widget will update itself based on new data.

Overall the Office strategy is a really cool new approach -- definitely trying to quash some of the Google Docs advantages. The big question, as with Azure, is what will be delivered, and when.

As always, questions and comments are always welcome. Day 3 coming soon -- Microsoft Research by Rick Rashid.

Watch the video here. [You will need Silverlight 2.0, which you can install directly from this page.] Click on Day 2, then "Watch Keynote on-demand". Start at 1:12:50 into it.

Scott Guthrie is the GM of the Developer Division at Microsoft. He’s a well-known face the Windows developer world. As a GM, he is extremely busy, yet still finds time to get out there and code, as evidenced by his extremely detailed posts about technical goodies (which, I am told, he writes himself, including all the tutorials). In fact, I was talking to him in the hall yesterday about something and he said, "Oh, I just got an email on that, hang on," at which time he proceeded to bust out his laptop and dig into his email to find the exact info. He’s a developer’s GM, that’s for sure. ;)

Scott talked about a number of different topics.

.NET 3.5 SP1

• Huge performance release.
• Big leap in features (LINQ, pixel shaders, etc.).
• If you are going to develop for .NET/WPF, .NET 3.5 SP1 is what you want.

Visual Studio 2010

• Total WPF UI! Let me say that again. TOTAL WPF UI. Scott showed the power of WPF in the UI by writing a small extension to the WPF Text Editor. The extension took the XML comment and instead of rendering the comment as XML, he rendered it as a richer WPF UI with active hyperlinks to bug numbers which, when clicked, would fetch the bug info from the database and render THAT as rich WPF UI. Under the covers it uses MEF (which will be part of .NET 4, see below) so that you get no-registration drop-in extensibility. AWESOME. As more of the UI moves to WPF, there will be more and more extensibility points that we can take advantage of to get serious productivity.
  
• Support for Multicore/Parallelism (Task Parallel Library, Concurrency Runtime)
  
• Support for large C++ projects in terms of management and build speed
  
• Many other extensibility points, including languages and compilers
  
• Integrated Silverlight design surface

.NET 4.0

There are a ton of new features being rolled into .NET 4.0. The release is tied to VS 2010, which I assume would be somewhere around late 2009 or early 2010.

• New CLR (v4)
  
• Support for in-process side-by-side CLR v2 and CLR v4. This will allow you to load a v2 add-in into your v4 app without recompiling.
  
• New WPF features
  • DeepZoom support (currently in Silverlight 2.0)
  • Multitouch (Windows 7 feature)
  • VisualStateManager (currently in Silverlight 2.0 and shipping with the WPF Toolkit)
  • Better text rendering (called DirectWrite)
  • More controls which are on par with what WinForms has (Chart, etc.)
  • Ribbon control (currently in a toolkit, will be in Windows 7 natively)
  • Common dialog support (yay!)
  • More effects and better animations
    
• Better Native Code Interop support for COM, P/Invoke, DirectX, XNA, etc.
  
• Dynamic Lanugage Runtime now integrated
  
• Managed Extensibility Framework (MEF) integrated
  
• Better XAML support
  • Hooking XamlReader and XamlWriter
  • Support for XAML-only WF, WCF, JumpLists, etc. (no codebehind)

Silverlight

It seems like Silverlight and WPF are headed for true convergence where SL will be a true subset of WPF. What will likely happen is that for the next couple years, we’ll see leapfrogging of features and changes between the platforms. Microsoft seems to be taking care to release Toolkits which augment the platform that does not have the feature(s) that the other does, in order to bridge you for the time being. For instance, currently they have a WPF Toolkit which has things like DataGrid, DatePicker, and VisualStateManager so that you can write WPF apps like you write SL Apps. In 2009 we’ll see a Silverlight Toolkit which will have features not yet in SL that exist in WPF.

• Just shipped SL 2.0, which is the first SL release to have .NET and CoreCLR support
  
• Currently 1 in 4 computers have Silverlight
  
• Upgrade being rolled out from 1.1 to 2.0
  
• Current applications in Silverlight
  • NBC Olympics Video Viewer
  • AOL Mail Gadget (just released)
  • K2
  • Netflix "Watch Instantly"
    
• Integrated Silverlight design surface in VS 2010
  
• Silverlight 3 coming in 2009

As always, questions and comments are always welcome. Part 3 coming soon -- the Windows Live and Office 14 stories from David Treadwell and Takeshi Numoto.

What’s interesting about this is that Josh is an evangelist for Microsoft, and James is an evangelist for Adobe. The two companies are battling for RIA dominance with Silverlight and Flex, respectively. If you talk to either Josh or James individually, they will definitely try to convince you that their technology is the one to use. However, underlying that is that the both are passionate about helping developers architect their RIAs using best practices so that they provide the best experience possible.

You can see the post here, including the slide deck and detailed write-up. Highly recommended read.

PDC Day 2 Keynote, Part 1: Windows 7

Watch the video here. [You will need Silverlight 2.0, which you can install directly from this page.] Click on Day 2, then "Watch Keynote on-demand". Start at 17:00 into it.

Steven Sinofsky opened the drill-down portion of the keynote with an overview of Windows 7. He did a demo with another VP inside Microsoft, showing off a number of new features in Windows 7. The bottom line for me is that it’s clear that Windows 7 will not me any quantum leap from where Vista is; rather, they are trying to fix a number of pain points in Vista as well as add some interface love that either didn’t make it into Vista, or that they came up with since Vista launched. I’ll go through a number of the things they touched on here.

Window Management

The taskbar has undergone a Dockification (tm). The Quick Launch area is gone, and the taskbar window area has transformed to be both the Quick Launch and the Running Applications area, just like the MacOS Dock. You can put application shortcuts there for quick launching. If the application associated with a taskbar item is running, hovering over the icon will give you a thumbnail preview of each window for that app. For instance, if you have 3 Explorer windows open, you’ll see a thumbnail of each, with the ability to close any instance via a "close" button in the thumbnail. For IE, they even preview each *tab* in a separate thumbnail, so that you can more easily switch to the tab you want.

Another taskbar change is to the window icons themselves. Each icon now has its own "Jump List" which includes some standard items and custom items the application registers. For instance, the jump list could include the Most Recently Used Documents list, which lets the user quickly open an MRU document instead of having to launch the app and then try to find the MRU list. Since this is a first-class OS API, applications will have full reign over what appears in the list.

They have also reworked the System Tray. Any application can still register its own icon to be hosted in the tray; however, at first any icon goes into a hidden "bucket" which is accessible by a single icon in the System Tray. The user then has control over if/when that icon shows up in the actual System Tray, and what notification(s) the user would like to hear about from each icon. This should go a long way in preserving valuable real estate in the taskbar, as well as reduce the number of annoying info bubbles the user has to deal with.

Another window management feature they have built is snapping windows to a screen edge. A feature like this has been necessary with the advent of the high-res monitors, where you have the screen space to show multiple windows large enough that you have the workspace you need, without having to manually resize the window. The way it works is as you drag a window, it cues you to snap to an edge. Once it’s snapped it automatically resizes to take up half the screen. This way, you can quickly get multiple windows side-by-side with maximum size without all the manual work.

Windows Explorer and the Home Network

Windows explorer hasn’t undergone too many changes yet. The first thing that’s been added are what they call Libraries, which are essentially virtual collections of files on any number of drives. For instance, I could have a "Documents" library which points to both "My Documents" as well as a "Shared Documents" folder somewhere on my network. This allows me to look at all my documents at once, rather than looking in each directory trying to find what I need. Desktop search results can be federated to over Libraries so that I don’t have to specify multiple directories when searching -- I can just specify the Library to look in. Custom libraries can be created for any number of folders.

They’ve tried to simplify the networking stuff, especially for home users. When you join your home network, Windows 7 will seek out other machines and automatically modify your machine’s Printers, etc. to reflect what you have access to. It can also maintain default settings on a per-network basis, so if you have a computer you use at home and work, it will always reflect the state you want depending on the network.

Overall, they are trying to simplify the use case where your home network has N machines, each with its own set of media and devices that you might want access to. They want you to be able to find anything you want and play it immediately. For instance, you search your "Music" library and find a file on another machine, and you can play it immediately locally or send it to a networked media device without a lot of acrobatics.

Media Support

Windows 7 contains a lightweight media player so that you can quickly play a media file without bootstrapping all of WMP. You still have quick access to the full library via WMP, but if you don’t want it, you don’t have to launch it.

Device Management

Windows 7 offers better device management. When you plug in your device, if Windows recognizes it, it will give you the ability to pull media off the device, configure it, etc. I would assume they will have support for many devices on the market the day it launches, with the ability to easily find new drivers/support for new devices as the manufacturer makes them available. The idea here is that now the home novice user who wants to pull her photos off her camera phone won’t have to try to do it all through a folder interface in Windows Explorer. I wonder if they’ll be able to sync the phone’s address book as well?

Sidebar and Gadgets

Gadgets can now live on the desktop as well as on the sidebar, in the same form. I’m not sure what that means to how the gadgets will work -- currently there is a "I’m in the sidebar" form and the "I’m on the desktop" form. Maybe that type of control will still be there. Also not sure what that means for the flyouts. Clearly the sidebar was not working too well for users.

UPDATE: what i mean is that you can run the gadgets on the desktop without the sidebar taking up desktop space.

Touch and Multitouch Interfaces

Windows 7 will have native support for Multitouch input. The APIs and events will be available in all the SDKs, from Win32 to WPF. This will allow developers to create applications that support Multitouch out of the box. The APIs are similar to the Ink APIs that have been around for a number of years now. There were a few interesting demos in the keynote using the touch interface.

Developer Goodies

What would a PDC be without some new fun developer goodies? Along with the new APIs for Jump Lists, Libraries and Multitouch, there are a number of new common controls (Office Ribbon control, WPF DataGrid/DatePicker/etc.) as well as a bunch of new DirectX APIs and better XNA support (which makes the usually difficult DirectX programming a little easier). As one breakout presenter put it, "DirectX is the new GDI". They really want people taking advantage of the hardware in regular applications.

Virtual Machines

Windows 7 will offer native VHD support via the Disk Manager. You can create and manage any number of VHDs without using Virtual PC. You will even be able to boot a VHD *natively* using the Boot Manager (BootCamp-ish), which is pretty cool -- gone are the days of using Ghost and a floppy (who has a floppy drive anymore, anyway?) to natively boot the OS you want. The one question mark is whether they will have Virtual PC built into the OS. Doesn’t seem like it’s a big stretch at that point.

UAC

The dreaded UAC is back and hasn’t changed a lot. The basic ideas are still the same. The changes (additions, really) are that the user now has more granular control -- instead of on/off, there will be 4 levels of UAC inside a much better (and more discoverable) UAC UI. The question mark for me as a developer is whether or not this means the code which handles elevation needs to be more complicated, or if that doesn’t change.

What doesn’t change is that it’s very important for applications to invoke best practices for running as the Standard User so that you don’t have to deal with a bunch of issues.

Other Goodies

• Ever have trouble getting your desktop replicated on the projector when you plug it in? Yeah, you and everyone else. Windows 7 adds a Windows-P keyboard shortcut which gives you the options you need to quickly switch the display configuration when you have an external display attached (e.g., Replicate my display on both, Extend my desktop, etc.). This should make it much quicker and easier to get your presentation up and running. ;)
• If you are a developer, surely you’ve used Remote Desktop. Ever try to remote into your dev machine which has extended desktop running on 3 monitors? Not a great experience. In Windows 7 they’ve added multimonitor support to RDC. So if you remote into your multimon desktop from a multimon machine, your RDC session will span. I’m not sure what the plan is if you remote into a multimon machine from a laptop -- will you have access to all the screens?

Anyhow, questions and comments are always welcome. Part 2 coming soon -- the developer story from Scott Guthrie.

The overall vision for Azure contains a number of pieces, which are best described on this page. They want to offload the developer of any cloud-based service headaches, including high availability, failover, scalability, etc. It’s likely that this will appeal most to small- and medium-sized businesses. It’s also likely this will appeal most to people running enterprise or LOB applications, although consumer applications can also benefit.

From a .NET developer’s perspective, nothing really changes. You write your application locally and test it against your local development server, using the same tools and languages you’ve been using for client or ASP.NET apps. You then use configuration files and a web interface to actually deploy it to the Azure service cloud.

The speaker who presented the guts of what Azure is also alluded to the plans for interop with other technologies such as PHP, but he did not go into detail on what that would entail. However, he did say that since they are using standard stuff such as REST and XML, it would be possible to do this.

One demo in particular was that from BlueHoo. They are a location-based social networking type site that uses Bluetooth to find people near you that you can connect to. They demo’d using Azure as their cloud that allowed Windows Mobile devices to update profiles, and a Silverlight desktop app for viewing participants, management of the servers, etc. It’s a simple app but they were able to get it running quickly using VS, C#, .NET, and Azure.

The big question marks for me are: how far along is the technology today? What features are implemented? How long will it take for them to achieve their vision? And finally, how much will it cost to use?

Azure is something that is not really a surprise. It really is the culmination of where Microsoft has been headed with all their cloud-based services, including Live Services, Silverlight Streaming, etc. The fact that they have a seamless workflow and stories for developers is typical of Microsoft. Hopefully they will roll out more and more functionality under the Azure hood so that people can build something real with it!