Even a chimp can write code

Of Crashing and Sometimes Burning

2010-04-15T14:41:00.000-07:00

I don't feel we've narrated the story about error and exception handling in Silverlight very well. We started out in v1.0 with a relatively sucky error reporting and diagnostics story and only did real work in building a robust internal infrastructure and adding diagnostics support incrementally, starting with Silverlight 2. We've since made big strides.

Our core tenet is to always provide a robust and reliable operating experience for apps.

What conditions can cause crashes?

Crashes are rare occurences. Ideally we'd avoid them altogether. They are symptoms of one of the following conditions:

A bug in the platform
A security mitigation being acted out
The app doing an illegal reentrant call

Crashes due to platform bugs
These are rare because few bugs of that severity ever get past our quality gates. This remedy is used within Silverlight only in situations where there's a reasonable chance the platform is in uncertain state and going ahead might be fraught with problems. Within this category, there are two variants: shutting down the app and then the runtime; and tearing down the host process.

Of the two variants, the former is the more common approach. It is typical for Silverlight to notify the app via Application.UnhandledException, and most times followed by raising the OnError DOM event for the OBJECT tag prior to shutdown. If you don't see either of these happening, then that might also indicate a bug, and you should report it.

In some situations Silverlight may not consider it tenable to continue processing. Instead it takes recourse to a failfast - aka a forceful teardown. Examples include when the internal state machine appears to be corrupt or required data is missing (an ExecutionEngineException thrown but not necessarily).

If you think you've found a platform bug that is causing crashes, we'd love to get our hands on a simplified repro app with sources. If the bug does not reproduce reliably, we'd appreciate crash dumps.

We will fix most of these issues as and when they're reported.

Crashes due to an in-built security mitigation
When Silverlight detects an Access Violation (aka segfault) or a Stack Overflow, or a Buffer Overflow, the runtime's built-in failfast routines kick in. These are deliberately designed to disallow app code to catch/suppress/rethrow these exceptions, and instead prevent any exploit from taking effect. Doing that would be folly... therein lie known attack vectors. Even in the most benign situations Silverlight assumes past performance is an indicator of future performance (no, we wouldn't be good investors with that mindset!) and finds its extreme action justifiable.

We will not "fix" issues in this category.

Crashes due to reentrancy
Silverlight does not deal well with reentrant behavior. Simply put, if Silverlight calls app code in a synchronous callout, it expects the call to be blocking, and it does not expect to be called back via that or another avenue until the blocking call exits. But when it finds itself in this situation, Silverlight will teardown with extreme prejudice, bringing down app, runtime and host (browser) together with a Null AccessViolation. A Null AV is different from a regular AV.

Here's how to tell if this is happening to you. The simple way is to look for "Null AccessViolation" in your dump. A more contrived way requires symbols and involves looking at the callstack:

KernelBase.dll!DebugBreak()  Line 81             C
npctrl.dll!CWindowsServices::DebugBreak()  Line 4270 + 0x8 bytes        C++
npctrl.dll!DisplayDebugDialog(unsigned int uClass=1, unsigned short * pFileName=0x5ef4ef78, int iLine=64, int iValue=0, unsigned short * pTestString=0x5ef36dec, unsigned short * pMessage=0x037d9a0c)  Line 926        C++
npctrl.dll!XcpVTrace(unsigned int uClass=1, unsigned short * pFileName=0x5ef4ef78, int iLine=64, int iValue=0, unsigned short * pTestString=0x5ef36dec, unsigned short * pMessageString=0x5ef31e78, void * pVArgs=0x037d9c00)  Line 1036     C++
npctrl.dll!CWindowsServices::XcpTrace(unsigned int uClass=1, unsigned short * pFilename=0x5ef4ef78, int iLine=64, int iValue=0, unsigned short * pTestString=0x5ef36dec, unsigned short * pMessageString=0x5ef31e78, ...)  Line 7258     C++
npctrl.dll!CReentrancyGuard::CheckReentrancy(int bNullAvOnReentrancy=1)  Line 64 + 0x36 bytes              C++
npctrl.dll!CXcpDispatcher::OnReentrancyProtectedWindowMessage(HWND__ * hwnd=0x004b039a, unsigned int msg=1026, unsigned int wParam=0, long lParam=0)  Line 900 + 0xa bytes  C++
npctrl.dll!CXcpDispatcher::WindowProc(HWND__ * hwnd=0x004b039a, unsigned int msg=1026, unsigned int wParam=0, long lParam=0)  Line 807 + 0x18 bytes    C++
user32.dll!_InternalCallWinProc@20()  Line 106         Asm
user32.dll!UserCallWinProcCheckWow(_ACTIVATION_CONTEXT * pActCtx=0x00000000, long (HWND__ *, unsigned int, unsigned int, long)* pfn=0x5f10bc90, HWND__ * hwnd=0x004b039a, _WM_VALUE msg=1026, unsigned int wParam=0, long lParam=0, void * pww=0x00e267f8, int fEnableLiteHooks=1)  Line 163 + 0x12 bytes         C
user32.dll!DispatchMessageWorker(tagMSG * pmsg=0x5f10bc90, int fAnsi=0)  Line 2591 + 0x1e bytes        C
user32.dll!DispatchMessageW(const tagMSG * lpMsg=0x037d9dec)  Line 999     C
user32.dll!DialogBox2(HWND__ * hwnd=0x002902ac, HWND__ * hwndOwner=0x000b0924, int fDisabled=0, int fOwnerIsActiveWindow=0)  Line 1150           C
user32.dll!InternalDialogBox(void * hModule=0x760b0000, DLGTEMPLATE * lpdt=0x04923388, HWND__ * hwndOwner=0x000708fe, int (HWND__ *, unsigned int, unsigned int, long)* pfnDialog=0x7611eec8, long lParam=58564704, unsigned int fSCDLGFlags=0)  Line 1314 + 0x9 bytes           C
user32.dll!SoftModalMessageBox(_MSGBOXDATA * lpmb=0x00000030)  Line 1237 + 0x18 bytes  C
user32.dll!MessageBoxWorker(_MSGBOXDATA * pMsgBoxParams=0x037da060)  Line 791             C
user32.dll!MessageBoxIndirectW(const tagMSGBOXPARAMSW * lpmbp=0x037da0d4)  Line 528 + 0xe bytes              C
ieframe.dll!6132ecd5()

The presence of CReentrancyGuard::CheckReentrancy indicates the reentrancy guard; message 1026 indicates WM_INTERNAL_TICK the veritable sign of the ~~apocalypse~~ reentrancy; and the presence of a (non-Silverlight, in this case from NTUser) MessageBox at the bottom indicates an actor that pumps messages including Silverlight messages. Note that Silverlight's own MessageBox will not cause this reentrancy - it and the reentrancy guard were specifically designed to play well with each other. So I recommend using that any place you'd consider using an alert.

Now consider that SizeChanged and LayoutUpdated events are raised synchronously as part of a layout pass. (I've previously expressed my firm preference for all things async -- I'd have loved for these events to be async but lost that argument since it'd have broken WPF compat and eliminated a couple scenarios. But I digress.) Now if you were to use the DOM Bridge within a SizeChanged event handler to, say, do an alert(), that'd align all the stars. The alert would pump messages; Silverlight would be in a blocking call, not expecting any messages in its internal queue; its little "reentrancy guard" would see this as reentrant behavior, and initiate adverse action terminating with a Null AV.

Silverlight's behavior in this situation was intended to be moral equivalent of a shock collar. We wanted app authors to detect these situations at development time and fix their code, so it never shipped with reentrant behavior.

This condition is the most common cause for crashes in Silverlight, and is indicative of programming error in the app.

We're constantly evaluating whether this sort of positive reinforcement through operant conditioning actually works. If you have anecdotes or feedback, please drop a line. Bear in mind that we have done a poor job at advertising this behavior, and I do sincerely apologize. So the fact that it took you a good while longer than average to debug such an issue is unfortunate but explained away by that.

Where to look for crash dumps?
While developing apps on Windows, with Windows Error Reporting (Watson) you should see the path in the UI shown upon a crash. Alternately look under %Temp% for dirs with "WER" prefix, and look for a .mdmp file prefixed by process name. If this is an out of browser app, you should see "sllauncher.exe.mdmp" instead of one for the browser's executable.

A word on diagnostics

If we could rewrite the past and change something, we'd have tweaked our initial conditions to one that enforced error reporting best practices in our internal development of the runtime. This would have eliminated having to perform triage and surgery on a rapidly evolving runtime as we added better diagnostics. There are still too many E_FAILs in our code that bubble up and result in the totally unhelpful "Unknown error" and the wildly melodramatic "Catastrophic error". There's a bit of dark humor in the backstory, but that's for another time.

Our work is not done though. We continue to seek feedback from app authors and fix our oversights. Keeping Silverlight easy to develop against is a giant priority for our team. Making sure you have great diagnostics and get past issues fast is one way we can make that happen.

Four scores!

2010-04-15T12:28:00.000-07:00

Silverlight 4 is now live! Here's what's new.

End users can get it here: microsoft.com/GetSilverlight
App authors can get the runtime and tools here: silverlight.net/GetStarted
Developer docs for Silverlight are on MSDN

The team is taking a much-deserved couple days off to recharge. Besides, the sun's out in Seattle this week - after what seems like decades.

Can you access a loose XAML file from LoadComponent?

2010-04-15T12:24:00.000-07:00

The answer is no. The job of Application.LoadComponent in Silverlight is to “merge” a specified XAML file with a specified object.

public void Application.LoadComponent(object, Uri);

In doing so, it does a series of validations:

checks that neither parameter is null
checks whether the specified XAML URI is absolute or relative. Absolute URIs are not allowed.
checks whether the specified XAML is embedded within an assembly. If not, LoadComponent fails.
checks whether the root element declared in the specified XAML is actually the same type as that of the specified object. If not, LoadComponent fails.

and only then attempts to merge the two in a custom parsing step.

Well, why not?

The last bullet point above is consequential in why we don’t allow loose XAML. LoadComponent thinks of an assembly as a logical boundary. In the presence of XAML with contents like this:

<UserControl x:Class=”Foo”> …

the only unambiguous way for Silverlight to identify and locate “Foo” is if it knew the DLL where that type was defined. Iterating through all DLLs loaded in the AppDomain isn’t an optimal solution at all. This is why it insists that the XAML be embedded within a DLL. Then it knows the un-qualified type is defined within that DLL. In practice, the URI specified on the LoadComponent call ends up being something like:

/SomeAssemblyName;component/Page.xaml

which has metadata on the provenance of said XAML i.e. that it came from an assembly with short name “SomeAssemblyName”. Silverlight can now happily match it against the type backing the other specified parameter – the object.

How does one work around this?

A workaround exists, but it has some limitations. You can use XamlReader.Load() to have Silverlight create an object tree from your specified markup. The caveat being that said XAML cannot have code-behind associations i.e. a backing type as root element, or event handler declarations. This approach is ideal if you’re dealing with sprites that are injected into the app, with other plumbing hooked up programmatically.

Aside: This is part of a recycling bits series I've been considering for a while. I frequently find myself answering the same questions over email or other forums, and figure I'd give some of those FAQs airtime on this blog, so as to multiply any benefits the information might have.

Stepping outside the browser with Silverlight 4

2010-03-18T16:17:00.000-07:00

Thanks to all those who attended the talk "CL10 - Stepping outside the browser with Silverlight 4" at the Mix 2010 conference or caught it via the recorded session online. I talked about the evolution of Silverlight into a general purpose development platform, far away from its origins as a browser plugin. I walked through features that light up outside the browser through our deliberate nested doll design approach - both in Silverlight 3 and continuing into Silverlight 4 now. I also talked about trusted apps and emphasized how important getting the right user experience and removing friction from app deployment was to us in the Silverlight team.

Here is the slide deck from the talk. Source code for the basic sandboxed app is archived here; and code for the trusted app can be found here. Hope you find it valuable.

The Q&A session at the end was very useful. I appreciate all the interest in this space and was happy to learn of the apps people were building. We could only get here "with a little help from our friends" in the ecosystem. We can continue that conversation on this blog, or you can send me email (ashsh).

Update: as a postscript, the slide deck I linked to here looks different from the one I used in the talk. Due to "technical difficulties" the podium machine had an older copy of the deck from one of my previous uploads, and I only found out once I was into the talk (silly me for not checking). So if I looked like I crapped a brick at the beginning, now you know why. Live and learn.

Silverlight out-of-browser apps: Remove

2009-07-25T15:45:00.001-07:00

Removing a Silverlight out-of-browser app is as easy as installing it was previously. From within the app, just right-click and choose “Remove this application…”.

Just so you don’t wipe away apps by accident, Silverlight will ask you to confirm, and when you do, the app is uninstalled and its binaries are scavenged from the offline application cache.

Data persisted by the app into local data store (Isolated Storage) is not removed. It is still consumable by the in-browser version of the app.

On Mac OS X, dragging the app bundle into the Trash can is another way to remove the app.

In line with our guiding principles which involve keeping the consumer end user firmly in control, keeping it simple and staying out of the way, the Remove experience does not allow the app to programmatically delay, defer or prevent its own uninstall.

Previous posts in this series:

Silverlight out-of-browser apps: How Updates Work

2009-07-10T19:58:00.001-07:00

Silverlight makes updating your out-of-browser XAP a breeze. It does the heavy lifting for you, asking that you merely invoke the update logic from within your app at a time or frequency of your choosing, and respond to events raised by Silverlight.

If an updated XAP has been published to your web server, Silverlight will download and induct it to the offline application cache. The next time your app is activated, Silverlight will ensure the updated bits are activated and the old bits are scavenged.

What the app author needs to do

Employ the async-pattern APIs exposed for updates in your out-of-browser apps. The trigger method is the Application.CheckAndDownloadUpdateAsync() method. Hook up an event handler for the CheckAndDownloadUpdateCompleted event. See, there’s not much to it! No messing with version numbers or the like.

Gotchas?

Well the only thing to watch out for is the situation when a new version of Silverlight comes out (say v4) and your app is built against it, but the consumer is running an older runtime (say, v3) and an appropriate older version of your app. In this situation, the app update cannot be applied because it requires a runtime update first. Silverlight notifies your app of this situation by setting the event arg’s Error property value to System.PlatformNotSupportedException.

All in all, here’s the code you’re going to write:

What the app publisher needs to do

If you handle application deployments or administer web servers, all you need to do is xcopy the new XAP (plus any external content files it needs) in place of the old XAP. Silverlight will take it from there.

In the end, a word to the wise... Make sure you clearly articulate your app's update policy to your end users. Whether you auto-update, or require user-initiation; whether you update upon every app launch or at another discrete frequency; let your app's consumer audience know. Ideally you'd grant them the ability to override your defaults. This is the right thing to do. The user must always be in control.

Previous posts in this series:

Three Years and Three Versions

2009-07-10T09:58:00.000-07:00

Silverlight 3 just shipped! 3 is so much bigger than 2; and here's what's new. See Scott's post announcing the release to web (RTW) and outlining the major features.

Microsoft.com/silverlight gets a facelift. Goodbye dusk (theme), hello dawn. Be sure to check out the overview of Silverlight 3 there.

Thanks to all of you for your persistent feedback and support in making this such a powerhouse of a release. Keep that feedback coming - we're already working on 4.

More soon...

User-initiated operations in Silverlight

2009-05-09T16:32:00.000-07:00

User-initiated operations in Silverlight:

must be initiated by the user via an input device like keyboard, mouse or accessibility client...
...within Silverlight
have an in-built timeout
have atomicity of transaction
cannot be marshalled across the specific Silverlight plugin's boundaries

#1 is obvious.

#2 isn't. Silverlight will not honor user-initiated operations that start from an HTML element, have a JavaScript handler which calls into a Silverlight scriptable API or other such endpoint.

#3, the in-built timeout in a user-initiated operation exists to eliminate long running, blocking, iterative, recursive tasks within one user-initiated method call. The timeout value is sort of a magic number, chosen to be small enough to no be a pain point for most developers and their scenarios, and large enough not to compromise on its goals.

#4 indicates that you cannot combine two operations in Silverlight which both require user initation into one transaction.

#5 means that the user-initiated "bit" doesn't traverse the Silverlight plugin boundaries, via IPC calls such as local messaging or even intra-process calls via DOM bridge or Scriptable object features.

These may look like quirks but are actually "features" that exist in Silverlight as secure defaults and to provide consistency of behavior across its supported browser and platform matrix. It is important for every Silverlight designer and developer to understand these nuances.

Silverlight out-of-browser apps: Local Data Store

2009-04-27T19:03:00.000-07:00

Silverlight applications – whether in-browser or out-of-browser, and whether running online or offline - can persist data into a local data store referred to as “Isolated Storage”. With the new offline/out-of-browser support in Silverlight 3, the platform further ensures that an app has access to the same Isolated Storage data regardless of whether it was activated in-browser or locally. This way, apps can share data between the in-browser and out of browser versions. As I’d mentioned in a previous post, Silverlight will enforce the provenance URI of the XAP in either case, ensuring that when each queries for its local store, it gets the very same artifact.

What can you do with this power?

Scenario #0: Local playback sure beats network playback.

Scenario #1: Assuming you have consumer use cases that involve using your in-browser and out-of-browser apps interchangeably, you now have a way to share data between them.

Scenario #2: If you need to share data between your in-browser app and your newly minted out-of-browser app immediately upon install (detach), you can use this local store as your custom “cookie store”.

Scenario #3: If your out-of-browser app detects no network connection, it can still take user input but persist that into local store, to later playback when connectivity is regained.

Internals

Silverlight’s Isolated Storage feature provides a virtual file system in which apps can create and store both files and directories with arbitrary data.

Apps are abstracted from the lower level file I/O functionality; they do not (need to) know where the files are stored or what sort of internal formats and directory hierarchies are in place. While apps can use file paths and dot-out syntax, these paths cannot escape the bounds of the virtual file system. This sort of virtualization provides isolation of app data, preventing other apps from inadvertently reading from or writing to your app’s store. Hence the term “Isolated” in the name. Apps and app authors do need to recognize that data stored in this persistence store is per-user and per-domain.

The Isolated Storage feature in Silverlight persists app data within a directory in the user profile (\%AppData%\LocalLow\Microsoft\Silverlight\is on Windows Vista and up and /Users/<user>/Library/Application Support/Microsoft/Silverlight/is on Mac OS X). The AppData folder is a hidden folder. This has the beneficial side effect of hiding your data from from OS search utilities (Windows desktop search and Spotlight) as well as the casual user. This should not be seen as a security boundary – only as a perpetuating the isolation of data.

Quotas

The space allocated for local data storage in a Silverlight app is bounded by a default quota assigned to that app’s domain of origin. At install (detach) time out-of-browser Silverlight apps will have 25MB space available within the Isolated Storage by default. Contrast this to the default quota of 1MB enjoyed by conventional in-browser Silverlight apps.

Needless to say, more space is available to the app upon user consent when the app invokes the System.IO.IsolatedStorage.IsolatedStorageFile.IncreaseQuotaTo() method. That method invocation itself needs to be in response to a user-initiated action such as mouse click or key press.

When your out-of-browser app is uninstalled, Silverlight does not reclaim your special quota or erase data persisted there.

Encryption

Although the isolated storage maintains data in an obscure location, it should not be confused with secure or encrypted data. However apps can easily encrypt and decrypt isolated storage files; they may also sign and validate the signature of an isolated storage file using the SHA256 hash function.

Gotchas

When saving to a virtual file system, one needs to be aware of inherent limits on file path size. This is imposed on you because the Isolated Storage’s root dir itself occupies several characters in the path (151 on Vista/Win7, 183 on XP/2K, 160 on OS X) effectively leaving you only the remainder (109, 77 and 100) respectively for your own file and directory names before Silverlight’s limit of 260 chars for a file path is hit.

Saving files outside of Isolated Storage

Silverlight 3 allows for saving files outside of isolated storage. Saving to any location on the client-side file system requires user initiation and the use of the SaveFileDialog control - a new “safe” control which allows saving one file at a time via a stream with your app code not having access to the file system or structure. Saving data to the server via an HTTP postback is another option.

----

This was #6 in my ongoing series of posts on Silverlight’s new offline and out of browser support. Hope it is helping you gear up.

Previous posts in this series:

Silverlight out-of-browser apps: Network Awareness

2009-04-22T16:29:00.001-07:00

There will be times when your Silverlight app is run but the end user does not have a network connection. A key attribute of making a functional offline Silverlight app is building in network awareness. In this post, we’ll look at how easy Silverlight 3 makes this for you.

The API

Silverlight provides current network status via the NetworkInterface.GetIsNetworkAvailable() method. Apps can be notified of changes in network availability via the NetworkChange.NetworkAddressChanged event. The NetworkInterface and NetworkChange types are both declared in the System.Net.NetworkInformation namespace.

Here’s sample usage of the network detection APIs:

...

NetworkChange.NetworkAddressChanged +=
new EventHandler (OnNetworkChange);

}

void OnNetworkChange (object sender, EventArgs e)

{

if (NetworkInterface.GetIsNetworkAvailable())

{

nwIndicatorEllipse.Fill =
new SolidColorBrush(Colors.Green);

// and do something

}

else

{

nwIndicatorEllipse.Fill =
new SolidColorBrush(Colors.Red);

// and do something else

}

What This Feature Is

The NetworkAddressChanged event – as the name suggests - advertises a change in IP address (availability). It is to be used in concert with the NetworkInformation.GetIsNetworkAvailable() to identify whether the recent change resulted in the system obtaining an IP address or losing one. The IP address is seen as a good primordial proxy for availability of network connection or lack thereof.

This feature is an answer to the question “Is this is a good time to make an outbound network request?”. Silverlight plays an enabling role in detecting offline status, telling you whether it’s worth your while to make an outbound call, or alternately to cache and persist data locally until network connectivity is regained.

What this Feature Isn’t

This feature is not an answer to the question “Is my site (or web service) up and running at this moment?”. The way I see it, Silverlight doesn’t play an enabling role in that situation – that is something your app can achieve with 10 lines of code. And such a service indicator is better off taking the actual URI and returning an actual response, rather than being a glorified HTTP HEAD wrapper.

Gotchas

Say you have 2 adapters – a wireless and wireline Ethernet – both of which are connected. If your wireless connection drops, the NetworkAddressChanged event is raised but in the handler when you query NetworkInformation.GetIsNetworkAvailable(), you still get true because your wireline Ethernet connection is still valid. When that goes down as well, the event is raised yet again and the NetworkInformation.GetIsNetworkAvailable() returns false. Always remember: from your NetworkAddressChanged handler, you must query GetIsNetworkAvailable to definitively find out the connectivity situation.

Other gotchas include the “illusion of connectivity”. This happens when you have some connectivity (say you’re on a WiFi network in an airport or a coffee shop) but not any Internet connectivity until you sign in or pay up. Your app may see GetIsNetworkAvailable return true, but should still try that actual outbound request to ascertain this.

In some cases virtual machines (e.g. Hyper-V running on your Windows Server or running Windows with Parallels on your Mac) may interfere with this feature and your app may see false positives.

---

Previous posts in this series:

Silverlight out-of-browser apps: Launch

2009-04-21T18:13:00.001-07:00

Silverlight 3 offline/out-of-browser apps maintain a sticky presence on your desktop upon the initial detach (install) operation. They can be looked up and launched in an experience not unlike the one you see with conventional desktop applications. You can search for and find these apps using OS search utilities (Windows desktop search, Spotlight on OS X) where they show up in as Programs.

Application id

Silverlight uses some indirection from the shortcut to the real app binaries on Windows (however on the Mac, the bundle created on install is the app, with limited metadata squirreled away in the offline application cache). This isn’t because we drink the “architecture astronaut” kool-aid on indirection, rather because doing so in this case allows us to add runtime logic around housekeeping which is effective when updates for the app or runtime exist. If you deconstruct the shortcut to a Silverlight out-of-browser app on Windows, you’ll find a command like this:

“C:\Program Files\Microsoft Silverlight\<version>\
                                    sllauncher.exe <app id>”

Ignore the newlines above. You’ll notice that the app id is a string made with the union of the domain of origin and some random number/text e.g. www.mysite.com.3509. During install on Windows, Silverlight creates a directory hive within your user profile so it can store the app binaries along with other metadata. It also assigns the app an identifier which is unique for a specific user on that machine. It appends this id into the shortcut, wherever the app is to be referenced.

The app launch sequence

When the shortcut is activated, the command is run, and as a result, sllauncher.exe is launched with that app id as argument. The launcher is a container program that chiefly handles the windowing logic for the app, while instantiating and deferring to Silverlight the specific function of loading and running the app. Among the things the launcher controls are the window adornments like icon and title text, a settings such as position. This is just scratching the surface. In future we expect to provide more window customization.

When sllauncher.exe hosts Silverlight, the runtime does a reverse lookup of the XAP file using the app id, additionally collects all metadata persisted in the offline application cache and then initializes Silverlight core services to the provenance URI of the XAP. This is the app’s original site of origin, not the location it was loaded off disk. This cascades into the correct (i.e. original) networking and security settings being applied to the app. All fallback lookups for relative URIs get resolved against the right base URI. All policy settings for cross-domain and cross-scheme access get applied properly; and the app has access to the same local persistence store (Isolated Storage) as its in-browser sibling. If not for the ExecutionState data exposed by the Silverlight runtime, the app would “think” it was running within the browser like it did prior to install. If updates to the XAP were successfully downloaded in a previous app launch, Silverlight will scavenge the old bits and use the updated bits instead. It is now ready to launch the app.

Was the app locally activated?

Upon launch, Silverlight applications can detect whether the current activation was from within a browser, or locally as a standalone window (aka out of browser). This is done by looking at the RunningOffline property of the Application type. When the value is true, the app was locally activated. When false, the app was activated via an OBJECT tag within a web page in the browser.

public partial class App : Application

{

public App ()

{

...

this.Startup += this.App_Startup;

}

void App_Startup(object sender, StartupEventArgs e)

{

if (Application.Current.IsRunningOutOfBrowser)

{

this.RootVisual = new OutOfBrowserPage();

}

else

{

this.RootVisual = new PageToBeDisplayedInBrowser();

}

~~Note: we’re changing API names to better reflect behavior; so expect the code snippet to change with Silverlight 3 RTW, but the principles will more or less remain true.~~

In the next post we will look at network awareness in offline/out-of-browser Silverlight apps. See you then.

Previous posts in this series:

[Update 10-Jul-09]: Code snippets updated for Silverlight 3 RTW.

Silverlight out-of-browser apps: The Install

2009-04-12T12:15:00.000-07:00

There are three main pillars to the new offline and out-of-browser feature set in Silverlight. These pillars are also tied to user experience; namely Install, Launch and Manage. In additions there are framework-level APIs and behind the scenes support from the runtime for a plethora of things that cross-cut these 3 pillars.

In this post we will look specifically at the Install operation.

A Silverlight app needs to be specially crafted for that out-of-browser function. There’s not much to it really: the application manifest (AppManifest.xaml) should be adorned with the OutOfBrowserSettings element which declares such metadata on the app as short name, window title, blurb and icons. No worries, tools make this easy for you via the Silverlight application project properties pane. Silverlight treats the presence of this element as an indication from the app author for opt-in to the out-of-browser feature set. Only this class of apps can be “installed”.

The install operation itself can be achieved in one of two ways:

via platform UI on the context menu that says “Install {app short name} onto this computer…”
via app driven UI which calls the Install() method on the Application type

Implicit in either case is the fact that install is required to be a user-initiated operation. And that too user-initiated within the Silverlight display surface on a web page. This allows us (building the runtime and platform) to better control the user experience and guarantee predictability, security etc.

Further, Silverlight apps cannot be installed without the consumer end user specifically consenting to this action. This removes the element of surprise. We’ve tried to maintain consistency with the experience one intuits on a particular operating system, while also balancing the needs of Silverlight app authors and our own user experience goals. As a result, you will see different UX on Windows and Mac – each appealing to its demographic.

On Windows, Silverlight shows an application modal dialog like this, seeking the user’s permission to proceed:

The dialog is modeled as a confirmation dialog, and the user is asked to allow or deny permission in context, with the assertion “You are installing {app short name} from {domain of origin}”.

The astute reader will notice that the dialogs are similar across Windows and Mac OS X – at least in principle – but each adheres to the native OS theme. The Mac dialog does not seek shortcut preferences, given that Mac users are expected in the very next step to drag the out-of-browser app bundle into a location of their choice, much like they would when installing another application.

A dialog of the form above is shown when the app declares no icons of its own. You see the “fallback” icon shown by the runtime. When the app declares its own brand icon, Silverlight will gladly display it at install time, as the following screenshot of the dialog on Windows attests: If the install were initiated via the Install() method call on the UI thread, the method would synchronously block until the consumer end user made their decision. If they declined, the method returns false; otherwise true. The other install related activities happen asynchronously. The platform signals this to the app via the InstallStateChanged event and the InstallState.Installing state; it inducts the XAP, along with some metadata and housekeeping information into the offline application cache within the user’s profile dir. When this is successfully completed, the platform raises the InstallStateChanged event with the InstallState.Installed state. This is the official notification to the hitherto in-browser app that its out-of-browser copy has been installed. The out-of-browser app gets a higher default quota (25MB to the previous 1MB) within Isolated Storage for its local data persistence needs. The in-browser and out-of-browser apps share this Isolated Storage with each other. We’re not yet sure if the magic number of 25MB is the right one (or if there is in fact any right value); it is however orders of magnitude higher than the default for in-browser apps and we hope it will open up new scenarios and result in the proverbial 80% of our apps not having to ask the consumer user for a quota increase yet again.

Upon successful install, Silverlight auto-launches the newly installed app – all sandboxed, out of the browser, and ready to go! The salient points of this Install operation are:

keep it lightweight
showcase the app brand, not the technology powering it
keep the decision simple for the consumer, and in context
get the consumer to their desired goal in the shortest time possible i.e. launch the app upon install

More about the story behind the Launch experience in the next post. Until then, cheerio, toodle-ooh and all that.

[Update 10-Jul-09] API names updated to reflect Silverlight 3 RTW

Silverlight out-of-browser support: What kind of apps can you build?

2009-04-01T19:51:00.001-07:00

This is first in my series of technical drilldown posts on the new offline and out of browser support in Silverlight 3.

It is something of a tradition in Microsoft to list out scenarios when a new feature set is being conceived. This practice is by no means unique to this company. I feel that doing so establishes a common baseline and taxonomy which immensely helps as the concept matures and gains complexity. Typically these scenarios are fleshed out in functional specifications.

In this post, I summarize the flavors of apps and scenarios that are enabled by the new offline and out of browser support in Silverlight 3. Most of these are self-explanatory and so using another Microsoft tradition, I will stick to concise bullet points rather than prose. A list similar to the one below in fact was used by our crew when we started our planning for this feature set a few months ago:

Connectedness

Fully disconnected app

App has no networking needs
Reliance on Silverlight just as an installation vehicle for the app
We don’t expect this will be very common

Occasionally connected app

App is resilient to network outage
Conditionally persists data into iso store or cloud based on network availability
This is the sweet spot for our feature offerings and where most of our attention goes

Connected app

App uses the offline feature set only for the sticky desktop presence
We don’t expect this will be very common

User experience

App behaves exactly the same in browser and out

App author wants to deliver the same experience in either case
“Try before you buy”, “Get more features upon install” and other such progressively enhanced SKU situations
Our data suggests consumers find comfort in apps that – in broad brushes – seem similar OOB as when they did in-browser

App shows different UI in-browser and out-of-browser

App author wants to exploit the real estate available in standalone window
Browser page could have limited functionality which lights up only upon detach
Browser page shows only the “Install” badge and the “real” UI only shows up when launched out of browser

Approach

Porting an existing Silverlight 2 app to run offline/out-of-browser

Even though the feature is a new addition to SL3, some SL2 apps can benefit from it
Requires no changes to code and no rebuilds
Can be done as a post-production step by modifying the manifest and optionally adding icons into the XAP
Build disconnected and connected apps, but not occasionally connected

Building a new offline/out-of-browser app

Our mainline scenario
Leverage everything the offline/out-of-browser feature set and the rest of Silverlight has to offer
Build disconnected, connected and occasionally connected apps

In the next post, we will look at the pillars of this feature, starting with the install (a.k.a detach) operation.

Introducing Offline and Out of Browser support in Silverlight

Introducing Offline and Out of Browser support in Silverlight

2009-03-18T09:39:00.001-07:00

Today we are making a radical upgrade to your web experience with Silverlight 3’s support for offline and out of browser apps. App authors can now build one app that works in the browser and out; at home, at work or on the go.

Among the new set of features enabling this experience are:

Sticky presence on the desktop: Upon user consent, a Silverlight app can be detached and pinned on the user’s desktop using familiar OS metaphors for this action. On Windows this can be through Start menu and/or Desktop shortcuts. On the Mac the user can drag and drop the application bundle to a location of their choice.
Run outside of browser: activating the app locally launches it outside of the web browser. Our data suggests consumers find this more intuitive as a result of clicking on a desktop shortcut.
Safe by default: Silverlight still retains a rigid security sandbox within which the app operates. Apps cannot elevate beyond the privileges granted by this sandbox. Our philosophy is to stretch this sandbox by providing features within it on a case by case basis. More on this in future.
Non-administrative install: Along with the sandbox, Silverlight furthers the consumer’s security by never requiring administrative privileges either for install or for run. An exception may be if optionally a user on the Mac wants to drop the app bundle into a dir that requires sign-on. In that case Silverlight honors the framework set out by the OS and user intuition.
Higher default persistence space: the default quota for Isolated Storage for Out of Browser apps is a higher value than for browser based apps. It is currently 25MB.
Network awareness: One of the key ingredients of this feature set is the ability for Silverlight apps to be aware of network connectivity and to be notified when that changes. Apps can cache data (or outbound calls) into Isolated Storage and post-back (or playback) when connectivity is regained. This works in Silverlight apps in the browser and out.
Built-in auto update: Silverlight will check for new versions of the app asynchronously upon app requesting such a check, guaranteeing users an instant-on experience. Updates are applied at next launch, providing apps complete control over when and how frequently updates are applied with Silverlight doing all the heavy lifting.
Execution state notifications to the app: Silverlight notifies the app on momentous events throughout its lifetime and transition from in-browser to out-of-browser, allowing the app to model its UI accordingly.

A short note on our philosophy before I end: When my team and I originally started thinking about delivering this feature set, we were absolutely certain about some things. Namely that this would be inherently a part of Silverlight, requiring no new runtimes/frameworks, no additional downloads, no new learning curve for app authors, no security elevations for consumer installs. That is the Carmot, if you will, in our offline and out of browser support. We’re also introducing a user experience that – in my biased opinion – fits well with the rest of the web; a model that allows consumers to try before they install; a model that takes an app familiar to them on the Web and makes it a companion on their desktop. Contrast that a model that requires consumers to have “install intent” and click on a hyperlink or a badge in good faith to experience an app they haven’t hitherto seen. There’s certainly a place for that install model and we’ve supported that in other products in the past for non-Web scenarios. And finally, I’m closely watching where support for offline applications in HTML5 goes and how mainstream browsers adopt it. At some point I do want our model to co-exist with the experiences they introduce.

Developers can ~~evaluate and play with the Silverlight 3 Beta~~ build these apps using Silverlight 3 right now. There's great runtime and tools support.

In future posts, I will be introducing this feature set from a technical perspective.

Post script: You can now understand why there’s been radio silence on this blog for months. This feature took a lot of Mountain Dew, sweat and tiers from a couple handful of the best darned engineers in the world. And a lot of questions, comments, critiques and feedback from the best darned customers a product can have. Here’s to takeoff and the EAP!

[Update 10-Jul-09] Auto-update section modified based on changes post beta; now reflective of Silverlight 3 RTW behavior
[Update 25-Jul-09] Links updated to Silverlight 3 RTW

Search Engine Optimization for Silverlight applications

2008-10-28T14:32:00.000-07:00

My whitepaper on Search Engine Optimization for Silverlight is now online: http://silverlight.net/learn/whitepapers/seo.aspx

It provides a story for Silverlight 2 application authors and publishers who want their apps and content to show up in search engine results pages (SERPs) today.

Downloadable copies are here on the MS Download Center:
Word Doc | XPS | PDF

Thanks to Dan Penn, Jon Rooney and Nitya Ravi for all their help in getting this off the ground.

Silverlight 2 RC0: Here's what's new

2008-09-26T08:38:00.000-07:00

The Silverlight 2 release candidate build has been released to developers so they can prepare for the upcoming release to web (RTW) of the product, and migrate their Beta 2 applications forward. This build has a number of functional, performance and stability related bug fixes. We’ve had to making some breaking changes along the way. There are also a few new features (which explains the silence on this blog and others like it, over the past few weeks). Here’s an incomplete list:

Per-frame callbacks
Create physics animations or override the animation system by hooking up for the CompositionTarget.Rendering event.

Controls
PasswordBox, ComboBox (well, a non-editable dropdown list only for now), MessageBox and ProgressBar.
Updated look and feel for controls.
IsEnabled and IsEnabledChanged added to the Control type.
Exposed virtual On* events on Control e.g. OnGotFocus, OnKeyDown, OnKeyUp, OnMouseEnter etc.

Support for popping up windows
Use the HtmlPage.PopupWindow API, in association with the new AllowHtmlPopupWindow param on the OBJECT tag to open a URI in a new browser window upon a user-initiated action. Note: doesn’t work on Safari because it doesn’t implement the right NPAPI contracts for this.

Accessibility
Improvements in accessibility and UI automation on Silverlight controls.

Networking
Support for making HTTP requests on background threads.
Upload support added to WebClient.
Support for percent escaped internationalized URIs for remote endpoints.

Input
A new LostMouseCapture bubbling event for when you lost capture.
Support for global keyboard character input into a TextBox (diacritics, non-ASCII characters etc.)

Resources
Extended the kinds of things that can be designated as application or element level resources e.g. Color, FontFamily, TextAlignment and many many more.

XAML
Default value support for custom dependency properties via PropertyMetadata.
Support for object element syntax for StaticResource.

With this release, the Silverlight 2 product is feature complete. Absent any major last-minute fire drills, the public surface area (APIs) in this RC should mirror the upcoming RTW product. Thank you for helping us build this product. Your feedback has been our magnetic north. Just a few more days until the ship sails…!

Death, Taxes and Latency

2008-07-23T20:55:00.000-07:00

By the time Silverlight came around, the problems afflicting web applications all round were well known and somewhat well understood. The burden of dealing with network latency, cancellation and errors should not be thrust on every web developer. Platforms have a unique role in abstracting away these problems. However, beyond band-aid solutions, web platforms haven’t provided any effective remedies. With Silverlight we’ve tried to tackle these head on. I wouldn’t say we’ve solved them, but we’re a ways ahead than many others out there in recognizing and fixing issues in this space.

Our strategy involves giving fish as well as fishing lessons. Silverlight enforces an asynchronous programming model for just about every latency, cancellation or conflict -afflicted scenario your web app would encounter. We further the mindset that much everything you’re trying to access can be on a remote machine or can take forever to return or can simply fail. This defensive posture is critical. And so whether it is invoking and consuming a web service, or modifying the UI from off-thread, there is an API in Silverlight that does this asynchronously. We go further though. Aside from areas where it simply must be compatible with prior art in Windows Presentation Foundation (WPF), it is de jure for events in Silverlight to be async. As of Beta 2 I can only think of layout events as being synchronous a.k.a. blocking and at least one more I can’t talk about just yet being added in RTW.

The novice developer may encounter a bit of friction in learning how to code to this asynchronous programming model. But there is friction in learning that Ctrl+Alt+Del unlocks a Windows machine, but you master it pretty quickly, and it becomes muscle-memory after a while. Likewise, we hope you will master async coding soon enough and be on your way to building web apps the way they were meant to. You and your app consumers will be the better off for it.

Another axis to this is the provision of tools and user experience options in Silverlight around async coding. This includes the options of using BackgroundWorker, multi-threading, splash screens and other forms of progress indication. Whatever your expertise, there’s an option available for you.

Still another axis is the defensiveness in the platform to counter issues like reentrancy. Silverlight has a reentrancy guard which will throw a Null AV (resulting in a process shutdown) if it detects reentrant behavior such as a draw call from within an existing draw call. You can be sure to catch these things at development time, rather than deal with them at runtime.

Given the ambient environment where Silverlight is hosted and run, the runtime needs to deal with problems such as message pumping and reentrancy arising from STA threads. Besides it doesn’t own its own UI thread – the browser does. Async patterns really shine here. Please tell us how we’re doing in this area. Has the predominantly async model been a hindrance in your development or had you not noticed until you saw this blog post?

Remember, like death and taxes, latency issues afflict all who build apps for the web. Asynchrony fixes one of those.

Pages in Silverlight

2008-06-08T18:00:00.001-07:00

Pages as a paradigm likely pre-date the web itself although they have been popularized by document-based markup languages deriving from SGML. Windows Presentation Foundation (WPF) with XAML further codifies Pages as a first-class UI element from its heretofore usage as a logical element. Looking back from Silverlight, this is as good a point in history to start as any. WPF has built-in support for reusable pages in its applications, and the task of navigation between them. It provides the infrastructure for declarative navigation via hyperlinks or programmatic navigation via NavigationService, and a journal that remembers which pages were navigated to or from. For XBAPs on IE7+, WPF supports integration of the journal with the browser's Back and Forward buttons, while elsewhere it displays a substitute navigation bar with this functionality (the limitation is an effect of how the XBAP host plugs into the browser). There is also a building block called PageFunction which introduces a paradigm for invoking pages as if they were methods, providing a neat little way to build wizard UI. Unlike WPF, Silverlight does not support these things, as of version 2. This post isn't about brooding that absence though -- instead we'll look at the lay of the land in Silverlight 2 with regard to pages and navigation, and look at common workarounds.

Although Silverlight does not have the Page type at this time, the term is currently used for its root visual UserControl. That root visual object is analogous to the root window in WPF, can only be set once for the lifetime of the app, and is effective once the Application's Startup event is raised. The act of navigating from one page to another is similar in principle to the act of removing one child element from an invisible root and adding another child in its place. [Actually given the journal it is more like switching Z-indices between siblings, so that one gets prominence while the other is made inconspicuous]. You can use this same principle in devising the notion of paging in a Silverlight app.

This recipe requires the following ingredients:

App.xaml.cs: the code-behind for the Application

Frame.cs: a user control which will serve as our "navigation frame". This has no UI.

Page1.xaml/Page1.xaml.cs: a user control representing a unique "page". This has a button whose click event navigates away to Page 2.

Page2.xaml/Page2.xaml.cs: similar to Page 1 in logic and function, only this represents the second page in your app.

Step 1: Create a navigation frame

This is a really simple user control. It has a public Navigate method which is passed a "page" object for which it duly resets its original content.

// Contents of Frame.cs
 
public class NavigationFrame : UserControl { 
        // Navigate the frame to the specified content
        public void Navigate(UIElement content)
        {
            // the existing content of this user control is
            // discarded and the specified param is plugged in
            // its place
            this.Content = content;
        }
    } 
    // Optional abstraction for page config
    public static class Pages
    {
        // for simplicity we're using static properties,
        // but this could just as easily be a URI to
        // Type mapping table
        public static UserControl HOME_PAGE = new Page1();
        public static UserControl ANOTHER_PAGE = new Page2();
    }

Step 2: Wire up the navigation frame as the app's RootVisual

Ordinarily the code generated by Silverlight tools (Visual Studio or Blend) will have a user control hooked up as Application.RootVisual within the Startup event handler. You will change this to hook up the navigation frame. Then hook up the user control to be the navigation frame's content (by invoking the NavigationFrame.Navigate method you created above).

// Contents of App.xaml.cs
// the Startup event handler sets the root visual
private void App_Startup(object sender, StartupEventArgs e)
{
    // Navigate to home page
    Navigate(Pages.HOME_PAGE);
} 
public void Navigate(UIElement content)
{
    // Create frame on an as-needed basis
    if (this.frame == null)
    {
        this.frame = new NavigationFrame();
        this.RootVisual = this.frame;
    } 
    // Navigate to content
    this.frame.Navigate(content); 
}

Step 3: Build your pages

Now that the navigation infrastructure is ready, go ahead and create a couple pages. These are merely user controls which would otherwise have been hooked up directly as the RootVisual. That part is simple. An important attribute in this equation is the fact that pages need to provide the experience of "navigating away". You can use a hyperlink, a button, or trap mouse/key events. We'll use a button and insert the navigation logic in it's click event handler.

// Contents of Page1.xaml.cs 
// on btn click, this navigates to the second page
private void navigateButton_Click(object sender,
                                  RoutedEventArgs e)
{
     (Application.Current as App).Navigate(Pages.ANOTHER_PAGE);
}

Let's create another user control which will be navigated to.

// Contents of Page2.xaml.cs 
// on btn click, this navigates to the first page
private void navigateButton_Click(object sender,
                                  RoutedEventArgs e)
{
     (Application.Current as App).Navigate(Pages.HOME_PAGE);
}

Well, that's all there is to it really. Build and run, and you've got your simple little navigation application.

In this pattern, the navigation frame element:

is the equivalent of the implicit navigation control

is a container with no visible visual properties (e.g. Background, etc.)

has only a Content element representing the current page

In the pattern, the page element:

is the equivalent of the navigable Page

has visuals or contains visual elements

can be attached and detached from the tree on a navigate event (i.e. the current element is removed, and a new one added in its place)

Our example used the Navigate By Object approach. Note that we invoked the Navigate method and passed it a page object. You could tweak the logic so your pages can be given data as part of the Navigate call. You could just as easily add URI-to-type mapping into the Pages utility type. That would allow you to replicate the Navigate By URI approach which is more organic to content on the web. If you use the Navigate By Object approach and you have a journal that maintains a back/forward stack of pages you've previously navigated to, you can incur a working set hit. This is because your journal will retain references the page objects in memory for long intervals - usually the life of the app - preventing the garbage collector from reclaiming them. Using the Navigate By URI approach in such situations can offer better use of memory. This is because you can delay instantiation of page objects until when the Navigate needs to happen.

In closing, there is a good case for pages, navigation service, journalling, transition animations, deep linking etc. to be part of the Silverlight platform. This is certainly of interest to us as we look toward the next version of the runtime and it's framework. I'd like your thoughts and feedback on these features and how important they are to your scenarios.

How to tell a Silverlight assembly from a .NET Framework one?

2008-06-08T13:41:00.001-07:00

Silverlight 2 application code is compiled to Common IL and packaged into assemblies (.dll) which are in turn deflated into a Zip file (container with .xap extension). The IL is a CPU- and platform- independent instruction set. The Silverlight runtime has in it the Core CLR which executes this IL. Given that .NET Framework involves much of the same things save for the .xap packaging, how does one tell between a DLL built for Silverlight versus one for .NET Framework?

Well, the answer is in one of the security assumptions that Silverlight's Core CLR makes to distinguish a core platform assembly from a transparent code app assembly. The mscorlib.dll in Silverlight is signed with a different key than it's namesake in .NET Framework. This is apparent in it's full name, or specifically it's public key token.

The public key token for mscorlib in Silverlight is:

7cec85d7bea7798e

while the public key token for mscorlib in .NET Framework is:

b77a5c561934e089

So the trick to sniffing out an arbitrary managed code assembly for its allegiance - Silverlight or .NET Framework - is to look through it's list of referenced assemblies, locate mscorlib and then check the public key token. Here is a sample application that does that.

Beta 2 of Silverlight 2 has just shipped

2008-06-05T09:21:00.000-07:00

The second beta of Silverlight 2 has just been released. The team has been cranking away and there are some new features and lots of bug fixes to show. A big thanks to all who provided vital feedback on our previous pre-releases!

Animation
1. Support for animating custom data points
2. Object Animation support (animating structs)
Deep Zoom
1. New XML-based file format
2. MultiScaleTileSource to wire up your own images and get the Deep Zoom experience
3. Better notifications when sub-images enter the view
Controls
1. Customize the look and feel of controls using Visual State Manager. Interactive control templates were never so easy.
2. Some base controls are now part of the core platform, rather than packaged into apps. Say hello to smaller app sizes.
3. Calendar now supports multi-selection and blackout dates
4. New TabControl
5. Control properties changes (Background, Tooltip, FontFamily, FontSize…)
6. DataGrid improvements: auto size, reorder, sort, performance and more
TextBox
1. IME Level 3 input support
2. Text wrapping and multiline selection highlighting in textbox
3. Scrolling and clipboard support
4. Document level navigation keys
Improvements in error handling, reporting
Parser and Property system
1. DependencyProperty.Register/RegisterAttached now supports PropertyMetadata
2. New DependencyObject.ClearValue
3. Visual tree helper
Data-binding
1. Per binding level validation
2. Support for element syntax for binding markup extensions
3. Binding to attached properties
4. ItemsControl extensibility (OnItemsChanged method)
5. Fallback in value conversion (Binding.UnsetValue)
Input
1. Support for limited keyboard input in Full Screen mode (arrow, tab, enter, home, end, pageup/pagedown, space). I've seen more than a few requests for this on the forums.
2. Managed APIs for Inking and stylus input
Networking and Data
1. Cross Domain support in Sockets
2. Cross Domain security enhancements
3. HttpWebRequest and WebClient callable from background threads
4. Upload support in WebClient
5. Isolated Storage: default size increased to 1MB and new ability to change quota with user consent. Also a new management UI.
6. Duplex communications ("push" from server to Silverlight client with no need to "poll" for data)
7. LINQ -to- JSON serialization
8. Significantly improved SOAP interop
9. "Add New Item" template in Visual Studio for "Silverlight-enabled WCF Service"
10. ADO.NET Data Services support
UIAutomation and Accessibility support in the platform
Media
1. Platform support for Adaptive Streaming (also referred to by people as multi bitrate), the ability for Silverlight to switch between media depending on network and CPU conditions
2. Content protection with PlayReady DRM and Windows DRM
3. Basic server-side playlist (SSPL) support
Localization
1. Changes to localized application model. You now create one xap per locale, instead of one monolithic multilingual app
2. Expanded localization languages of runtime and SDK
3. Japanese SDK Installer and documentation (July 10)
Several changes to make API and behavior more compatible with WPF
Tools
1. Beta 1 projects will be automatically ported to Beta 2
2. Remote debugging for VB on the Mac
CLR
1. A new developer-oriented runtime package with debugging binaries, localized strings, docs etc.
2. Support for OS fallback logic for resources
3. CurrentCulture and CurrentUICulture isolation to AppDomain level
DLR
1. Performance improvements
2. Various new DLR and IronPython 2.0 Beta 2 language features
3. Various new IronRuby features

We're not quite done for Silverlight 2, but are getting really close. There's some ongoing work to get more controls delivered (Scott has said the expectation was to ship over 100 controls) at and beyond RTW. I know people have asked for ComboBox and PasswordBox. We'll also have per-frame callback support (CompositionTarget.Rendering event) to light up those physics animation scenarios you're dreaming of, and further accessibility work on controls, improvements to PNG support in imaging, among other things. Needless to say, the focus from here on will be to stabilize and ship a solid product.

I hope you like what we've cooked. Please keep that feedback coming. Without you this would not be possible and be quite meaningless.

Further content:

Get Silverlight 2 Beta 2 now!
Breaking changes between Silverlight 2 Beta 1 and Beta 2
Install Beta 2 tools for Visual Studio 2008
Silverlight 2 Beta 2 documentation on MSDN
Scott Guthrie: Silverlight 2 Beta 2 released

WPF 3.5 SP1: Don't let the SP moniker fool you

2008-05-13T19:00:00.001-07:00

Yesterday the WPF team shipped some major horsepower features in the vastly understated preview Service Pack to .NET Framework 3.5. It is an exception to the rule for an SP release to have features, and not just bug fixes. In the mold of Windows XP SP2, this SP of .NET Framework 3.5 is chock full of new WPF features.

For the first time the .NET Framework has been divided into a Client profile which - intuitively - does not contain server specific libraries such as ASP.NET. This cuts down the size of the .NET Framework to about 25MB (which as Dr. Sneath reminds us is close to Adobe Reader's size) and people like me with a Java background can associate it loosely with the Java SE and Java EE split. In many ways, this is the realization of the Longhorn-era "WinFX" give-or-take a couple assemblies.

Given my previous association with the WPF Application Model, I'll begin with a shout out to improvements from and driven by that crew. The Web Browser control in WPF is embodied by the Frame element. There's new support for interop between WPF and HTML content hosted within it (yay for DOM and script access!). In addition to the existing support for rendering HTML content via URI comes new support for rendering HTML via a stream. This allows for dynamically created HTML content to be rendered in a WPF app. And oh, XBAP enthusiasts will note that this all works in the partial trust sandbox. The progress UI on XBAP launch gets a perf boost and is now an instant-on UI. There's wide ranging real and perceived perf enhancements in the product that customers will truly love. Besides, there are some ClickOnce improvements allowing you to customize the activation error experience, suppress/customize the ClickOnce UI, set up file associations (yes, despite my reservations to this), opting out of signing your apps (I've long maintained that shelling out 300 bucks for a cert is good news for Verisign and gang but bad tidings for hobbyist developers; good to see this change) but with support for corps to block unsigned apps (so this is a wash security-wise). And yeah, ClickOnce-deployed apps can be launched with a click of a hyperlink on Firefox!

An update to Visual Studio 2008 now lets you target your apps specifically to this Client profile of .NET Framework. You have an option of packaging up your app in an installer which will bootstrap .NET Framework 3.5 and uses some nifty tricks (like asynchronous NGEN) to speed up the time between the click and bits showing up on screen.

This release contains the graphics features demoed at Mix 08, like extensible shader effects which will let you harness the power of the GPU while still using animation, data-binding, media, composition and other WPF goodness. Fittingly, as has been WPF's charter, these features bring advanced concepts like HLSL effects and SIMD processing to the realm of application developers like me with simple abstractions and none of the complexity (I mean creating an effect is still the realm of experts, but using it is as simple as instantiating a control in WPF which I'm perfectly capable of doing, equating it with something like a DataGrid). Besides, there's deeper DirectX integration so you can blend or overlay D3D content with WPF.

There's a new DataGrid and Office Ribbon control provided out of band with WPF.

I can go on and on, but I should stop now because I can't hold this smile much longer. The WPF and other partners contributing to .NET Framework kick some major bootay with this release. Calling it a Service Pack is a classic understatement. Readers who are familiar with Silverlight, but not so much with WPF are encouraged to dig deeper. And do let us know which of these features you'd like to see in Silverlight.

Further content:

Channel 9's ongoing WPF Series has a set of videos where folks from the team talk about features and do demos
Scott Guthrie: VS 2008 and .NET Framework 3.5 SP1
Tim Sneath: Introducing the third major release of WPF
Greg Schechter: A series on GPU based effects for WPF

Silverlight 2: Layout and Rendering engines

2008-04-14T15:15:00.000-07:00

A layout engine which does precise and optimal size or position calculations is critical in any user interface framework for building responsive, interactive and high-performance applications. The term "layout engine" is often interchangeably used with "rendering engine" to mean code that takes markup content along with styles, templates and other formatting instructions to display content on screen. As prominent examples, you know of Trident, the layout engine in Internet Explorer, or Gecko which performs a similar function in Netscape/Mozilla family browsers.

In Silverlight, we typically look at the layout and rendering engines as two distinct things rather than one amorphous entity. The former handles the math which dictates how UI elements are sized and positioned on screen, and how they may be constrained or clipped in order to fit into the bounding box. The latter deals with the logic of taking bits representing graphical objects and showing them on screen. Lets do a quick lap around these features.

The Silverlight layout engine

Among the goals of the layout engine is to:

Enable highly complex and dynamic user interfaces where elements can be automatically positioned
Provide a gradient of Panel choices in which to place UI elements, as well a mix of knobs to achieve very precise positioning: absolute/relative sizes, margins, padding, static or specified sizes as well as dynamic or calculated sizes
Allow app code to participate in layout. This can be as simple as being notified on layout events, or as niche as extending the layout behavior by actively participating in the process

With the design patterns and public APIs of the layout engine in Silverlight, we've stayed close to the behavior displayed by Windows Presentation Foundation (WPF), even if the implementation is custom keeping in mind the needs and constraints of Silverlight.

Very simply put, layout in WPF or Silverlight is a recursive operation that involves two passes, measurement and arrangement. During measurement, a child element is effectively told by its parent element "Here's how much room is available to all you kids and your 'gear'. Tell me how much you really need." Once all appropriate elements in the tree have been measured in this way, the arrangement pass kicks in. At this time, the elements' sizes are finalized. The parent element can choose to say either "Sure you can have your own room" or if the demands are profligate, then "Oh, the kids these days! I'd like champagne on a beer budget too. But no can do. Get your things together - you and your brother are rooming up." After arrangement, the elements in the tree are ready to be rendered.

Example of a grid with constrained size. The rectangle within it asks the parent for all its got -- and gets it:
<Grid Width="250" Height="600">
<Rectangle Fill="Red" />
</Grid>

Example of a stack panel with constrained size. The first rectangle gets what it desires. The second rectangle gets clipped because it desires more than the parent has room for:

Needless to say, the layout algorithm employs optimizations to ensure layout doesn't happen until absolutely necessary, and when it does, there selectiveness on which items need to be considered. I won't go into too much detail but primarily this keys off the knowledge that certain properties such as Width, Height, Visibility, Stretch, Alignments, Margins etc. are deemed layout-affecting and a change to one or more of these invalidates the current layout, causing Silverlight to re-layout i.e. measure and arrange its UI elements.

The Silverlight rendering engine

Silverlight uses vector graphics as its rendering data format, giving its graphics the ability to scale to any size or display resolution.

In WPF, the Visual class is the basic abstraction that provides rendering support. UI controls like Button, ListBox etc. derive from UIElement and FrameworkElement, which derive from Visual. In Silverlight we've dispensed of the Visual type, folding its functionality into its child types. This way we can keep the object hierarchy shorter, have one less type to deal with, small size reductions and still be a subset of WPF both conceptually and behaviorally. Silverlight also generally discards the notion of distinct visual and logical trees, effectively reducing to one tree where visual/drawing/logical info is persisted. This tree is the effective consolidation of elements you created in markup or code, containing all rendering info needed to output to screen. The tree determines rendering order as well - starting with the root visual (the top-most node), progressing to its children from left to right. If an element has children, then they are traversed before its siblings.

Silverlight uses retained mode rendering and employs a custom rendering pipeline, not relying on OS libraries like GDI/GDI+/WPF for better consistency and performance across platforms. It uses occlusion culling among other approaches to prevent overdraw. This is particularly significant if you consider that a typical application has 3-4x overdraw and perhaps 10x if effects are employed. Another very significant (but not commonly known) fact about Silverlight's rendering engine is its many-core support; specifically how it was architected to utilize the raw power of multiple cores and subdivide rendering tasks to be processed in parallel by CPU cores as they have available time. This provides phenomenal linear speed increases when you have dual, quad or 8 core machines. In this regard, Silverlight has few peers. Of course, one must not gloss over the detail that other functions such as tree walks, layout, template expansions etc. do not necessarily scale linearly.

Post-script:

Blog posts are never a substitute for good documentation (and we're fortunate to have a great team of doc writers). My intent with this post was to mix the "how" with the "why". One of my mental models is to view teams based on what I call "team DNA". In this respect, the UI platform team in Silverlight traces its DNA to the User32, GDI/GDI+, Trident, WinForms and WPF teams (Note: I'm way oversimplifying - we have a far more diverse team in ideas, outlooks and heritage than I can describe with words; but bear with me here). I think the team's DNA gives it a rich corpus of experience in blending the web and desktop, plus the ability to distil things on the "what works", "what doesn't work" and "what didn't work then, but will now" buckets. In the spirit of evolution and due to the unique size and platform requirements, the layout and rendering engines as other areas in Silverlight, introduce optimizations and use different algorithms than their WPF cousins. Feedback is always appreciated.

How to tell the screen resolution from within a Silverlight app

2008-03-11T20:13:00.000-07:00

There isn't a direct API for detecting the screen width and height from within a Silverlight app. Fortunately, JavaScript provides you a way, viz. via the screen.width and screen.height properties. So with a nifty use of Silverlight's HTML DOM Bridge, these values can be read with little issue.

int screenWidth = Int32.Parse(

HtmlPage.Window.Eval("screen.width").ToString()

);

int screenHeight = Int32.Parse(

HtmlPage.Window.Eval("screen.height").ToString()

);

Then when your app runs in fullscreen mode, you'd get the screen resolution using the Silverlight plug-in's ActualWidth and ActualHeight.

int screenWidth =

Application.Current.Host.Content.ActualWidth;

int screenHeight =
Application.Current.Host.Content.ActualHeight;

Silverlight 2: Demystifying URI references for app resources

2008-03-11T19:46:00.001-07:00

In this post we will look at how application data files can be referenced using relative Uris from within XAML or code in your Silverlight 2 application.

Silverlight provides you with a luxury of choices for how you declare your application data files. These are the non-code artifacts of your app, such as images, videos, fonts etc. The build action for any file - i.e. how you declare it in your project file or within Visual Studio or Blend - is consequential to how it can be referenced in XAML or code via a Uri. While care was taken to ensure defaults that gel with the programmers intuitiveness while referencing them in Uris, there are always subtle issues that the intrepid Silverlight designer or developer must be aware of. If you come to Silverlight with previous WPF experience, the contents of this post should be old news to you. If not, fear not; Silverlight is designed to be easy to learn and easy to master.

Let's take Image files as an example as we walk through the various cases. Once you understand how this works, you can extrapolate behavior for MediaElement (audio/video) or MultiScaleImage (SeaDragon in Silverlight) or perhaps even fonts. While examples below show XAML syntax, the same applies to code.

Files marked as Resource:

Get embedded in the app assembly within the XAP
Are accessible using a relative Uri, relative to the XAML file from where they are being referenced
For e.g. <Image Source=”Foo.jpg” />
When not found, there is no fallback. The ImageFailed event is raised.

Tip: Using assembly qualified Uris is most reliable both from within and outside that assembly. E.g. <Image Source=”/{assemblyShortName};component/Foo.jpg”/>

Tip: You can programmatically extract any application resource using Application.GetResourceStream(uri).Stream.

Files marked as Content:

Get added to the XAP at the conceptual application root
Are accessible using a relative Uri, relative to the application root. This requires the use of a leading slash
For e.g. <Image Source=”/Foo.jpg” />
When not found, the resource loading mechanism falls back to the application’s site of origin and looks for the image under the same (web root) dir as the XAP is located
When not found, the ImageFailed event is raised.

Tip: this is a no-brainer when you have a resource that is commonly used from within 2 assemblies in the XAP

Files marked as None (with CopyToOutputDirectory set appropriately):

Don’t get copied into the XAP, but the CopyToOutputDirectory metadata will ensure it gets copied alongside the XAP
Are accessible using a relative Uri, relative to the application root. This requires the use of a leading slash
For e.g. <Image Source=”/Foo.jpg” />
This is the fallback path of the above

Tip: in most cases you want to keep your video files out of the XAP. They are not encumbered by x-domain download restrictions. You do not get compression benefits from keeping them in the XAP. Rather you can use streaming or progressive download if they are outside.

Files marked as None, as well as image and audio/video files not marked at all in the project (i.e. external to the project), can always be referenced using absolute Uris.

Files marked as EmbeddedResource:

Get embedded into the assembly in a manner that Silverlight cannot use for URI references either from XAML or code
Should be changed to Resource, and used as detailed above.

Hopefully this demystifies Uri usage in Silverlight for you. If we can make improvements in the runtime or in tools to make this easier for you, please post a comment here. Feedback is always appreciated.

Related links:

Transcoding media files for Silverlight

2008-03-11T12:34:00.000-07:00

Silverlight supports Windows Media Audio and Video (WMA, VC-1/WMV7-9) and MP3 formats. If you have existing media assets in other formats, you can convert them into a format Silverlight can understand. There are a couple ways to do this.

On your desktop using Expression Encoder

Use the user interface for granular control over the entire user experience on your media files with support for encoding, enhancement and publishing for Silverlight
Or use the command line interface for batch processing
Choose this when you do not have abundant bandwidth to upload media assets to Silverlight Streaming for encoding or transcoding
Choose this if you have adequate CPU power on your desktop to transcode your assets
Expression Encoder can upload your media files to the Silverlight Streaming service using this plug-in

In the cloud using Silverlight Streaming

The companion service to Silverlight on the cloud at http://silverlight.live.com/ provides transcoding support in the Video Management area
Choose this if you have enough bandwidth to upload (unencoded) media assets to the cloud
Choose this if you do not have adequate CPU power on your desktop machines to efficiently encode/transcode media assets
Choose this if you would like to offload your media hosting to Microsoft's high performance, geo-scale content delivery network (CDN)

PS: my one gripe is that the Silverlight Streaming SDK docs do not explicitly say which file formats it can transcode for you. I know they support .mov, but what about .flv? Hoping they fix this soon.

Update [3/12/2008] : Thanks to Anoop Anantha, WL Platform Architect, I've now learned that Silverlight Streaming will transcode mpeg2, mpeg4, divX, H.264, flv formats, among others, to a Silverlight-friendly wmv format. He mentioned they will be updating the docs.

PPS: tip o' the hat to Angus Logan for his excellent talk at Mix 08 on Windows Live services.

How to pass initialization params to a Silverlight 2 app

2008-03-10T17:25:00.000-07:00

This is something of an FAQ on our internal discussion lists, so I figured it merited a post.

Step 1: Declare the initParams param on the Silverlight plug-in and pass in a comma-delimited set of key-value pair tokens. For e.g. "key1=value1,key2=value2,key3=value3".

</object>

For best results, the key and value tokens in the initParams string must be restricted to alphanumeric values. There currently isn't support for escaping equality signs or commas, for instance, should they exist in the key or value part of the token.

Step 2: In the Application's Startup event handler, extract the initialization parameters via StartupEventArgs.InitParams property. You'll get an IDictionary<string, string>.

// Contents of App.xaml.cs

private void Application_Startup(object sender,
StartupEventArgs e)

{
string startPage = e.InitParams["startPage"];
if (startPage != null && startPage.Equals("Page1"))

    {
       // Load Page1
       this.RootVisual = new Page();
    }
    else
    {
       // Load Page2
       this.RootVisual = new AlternatePage();
    }
}

Simple, huh? I have a sample project on how to pass initialization params to a Silverlight 2 app, and conditionally show UI, up on my sky drive.

Silverlight 2: Application model

2008-03-10T07:25:00.001-07:00

The first public beta of Silverlight 2 is now live. If you've played with building apps on it, you know we weren't kidding when we used the "Windows Presentation Foundation / Everywhere" moniker. Although we didn't inflict that monstrosity of a name on you, we did bring much of the sheer goodness of WPF in the APIs, the depth of functionality, the extensibility points and the overall experience designing or developing one of these babies.

In this first installment of a series of posts on Silverlight 2 features, I'll talk about the new Application Model. I'll loosely define an Application Model as "the principles on what constitutes an application, how it's lifetime is governed, and the set of services offered by a platform or runtime to the application". The Silverlight 2 Application Model borrows heavily from that of WPF. And it's goals are to be simple and predictable, to provide extensibility hooks, and otherwise to stay out of the way.

The Silverlight 2 application
The Silverlight 2 application is a client-side entity running within the confines of a host such as a browser. It is a packaged archive -- we use the Zip data compression and archival format -- with the .xap file extension and application/x-silverlight-app MIME type. Despite the introduction of this new application file, the Silverlight 2 runtime continues to support vanilla XAML content specified via file Uri or inline reference to SCRIPT block a la the v1.0 programming model.

Here's an outline of the features supported in the new application model:

New application package unit
Encapsulation of application functionality in a type deriving from System.Windows.Application, along with app definition XAML
Application lifetime: ctor, Startup event, Exit event
Handle exception conditions in a central location at the app level
Support for declarative dependency downloads, as well as programmatic for more granular control
Utility methods to extract app resources or resources from arbitrary Zip packages
Access to the Silverlight plug-in's object model via the Host property
Default splash screen provided by the platform, with ability to override it using custom XAML and JavaScript
Support for activating a Silverlight application from cross-domain (x-domain) to HTML page; secure by default, and ingress/egress need to be opted into.
Ability to refactor application functionality into individual pieces, daisy-chained together and dynamically loaded at runtime

A more detailed overview of the new Silverlight 2 application model is provided in this slide deck I've posted on my sky drive. The Silverlight 2 application model documentation on MSDN is a must-read. As always, feedback is appreciated. You can drop a comment here or post on the Silverlight forums.

British Library's Turning The Pages project now in Silverlight

2008-02-23T10:08:00.000-08:00

The British Library's Turning The Pages project is currently featuring 5 treasures from across the United Kingdom. In addition to the Windows Vista version (specifically a WPF browser app a.k.a. XBAP) of the app, there's now a new Silverlight version for broader browser and platform reach.

I love this app and often use it as an example to explain what I do in Microsoft to lay persons. A tip for the authors of the Silverlight 1.0 flavor of the app: it'd be cool to see mousewheel support for the Zoom function. Here's a post from Pete that explains the approach.

Unwrapping Silverlight 2

2008-02-22T09:52:00.000-08:00

Ahead of the first public Beta of Silverlight 2, Scott posts this overview and follows up with a series of tutorials that will get you up to speed with the breadth of features being introduced:

Part 1: Creating "Hello World" with Silverlight 2 and VS 2008
Part 2: Using Layout Management
Part 3: Using Networking to Retrieve Data and Populate a DataGrid
Part 4: Using Style Elements to Better Encapsulate Look and Feel
Part 5: Using the ListBox and DataBinding to Display List Data
Part 6: Using User Controls to Implement Master/Details Scenarios
Part 7: Using Templates to Customize Control Look and Feel
Part 8: Creating a Digg Desktop Version of our Application using WPF

This is just an hors d'oeuvre before the Beta is available for public download. Soon! Hope you love what we've cooked.

Update: Adam does a CliffsNotes take on Scott's posts.

Free Microsoft Software for Students

2008-02-20T05:23:00.000-08:00

Microsoft is making professional development software available at no charge to post-secondary school and university students worldwide. The initiative called DreamSpark was announced yesterday starting with 11 countries, and will soon grow to more countries over the year.

Among the products available currently are Windows Server, the Expression Suite of products, XNA Game Studio, SQL Server and the new Visual Studio.

Students attending accredited university, college, junior college, community college, or a tertiary/higher education institution can go to the DreamSpark site on MSDN now to sign up.

PS: Kudos to Academic DPE.

Life at Microsoft

2008-02-14T19:49:00.000-08:00

Booyakasha. If you've ever pondered the question, then check this look at life at Microsoft, courtesy of the folks at On10.

Update: inline now...

Olympics online coverage to be powered by Silverlight

2008-01-07T17:05:00.000-08:00

This one is big for my team. My colleagues and I on the Silverlight product development team are enthused about NBC Universal's choice of our platform to power the user experience on their site for the upcoming Beijing 2008 Olympics. I think providing a compelling experience around the thousands of hours of live feeds and on-demand content is just the kind of challenge that Silverlight was built for.

Here's to Silverlight 2.0, of which you'll hear more in the days and months to come.

Popfly: Now open to all

2007-10-18T09:30:00.000-07:00

This morning the Popfly team announced a new Beta and have removed the invitation-only restriction on that site. Just sign in to Popfly.com with your Live ID. You can create your own gadgets, mashups and web pages using Silverlight powered tools. No programming skills required.

PS: If someone from the Popfly team is reading this, how about adding a "Sign up" link on the landing and overview pages to eliminate the guess-work?

Nothing beats shipping: Silverlight 1.0 is here!

2007-09-05T07:46:00.000-07:00

Today Microsoft announced the debut release of Silverlight, the new cross-browser, cross-platform technology for developing compelling media experiences and RIAs. I joined the Silverlight effort around November of 2006 from working on WPF 3.5 feature areas, and it has been a wonderful ride. Working on two different product releases – Silverlight 1.0 and 1.1 - simultaneously is a very unique experience not easily summarized in a blog post. The kind of stuff this team has done in a matter of months is nothing short of amazing. We joke internally about how someday books will be written about these episodes; and needless to say, about the giants upon whose shoulders people like me stood. But for now, I’m happy and tremendously fortunate to have been a part of shipping a great product that millions will use and love.

Congratulations to my colleagues on the Silverlight team and the leadership in Microsoft’s Developer Division.

Get Silverlight.

Tafiti - Search Visualization with Silverlight

2007-08-21T11:06:00.000-07:00

Microsoft today announced the launch of Tafiti, an experimental web site showcasing a different take on the Live Search experience. The site "helps people use the Web for research that spans multiple queries and sessions by helping them visualize, store and share the result." While the search is powered by the Live Search engine, the client experience is built on Silverlight.

With Tafiti and Ms. Dewey before it, it is interesting to see development teams at Microsoft move out of the rut of the run-of-the-mill search interface and experiment with specialized usage scenarios with richer visualizations.

Silverlight 1.1 controls from ComponentOne

2007-08-11T19:21:00.000-07:00

ComponentOne Labs features a suite of over 30 UI controls and components for Silverlight 1.1. This is an impressive list covering the gamut with buttons, text controls, lists, date pickers and layout containers. Apparently charting controls and grid are in the works. You can play with these controls on their slick gallery. I'm very impressed.

My team shipped a set of sample UI controls with the Silverlight 1.1 Alpha SDK building on the platform's basic foundations for control extensibility. I've been pleasantly surprised by the the sorts of things the community has done with what can only be kindly referred to as rudimentary support in the platform. As Silverlight 1.1 evolves, you will see the platform provide a lot of the building blocks such as robust keyboard/input support, a layout system, basic UI controls and more. The possibilities are endless. Of course, there's still a lot to get done. If you've read this far, you probably care. Please tell us about your experiences building RIAs using Silverlight and what you'd like to see in the platform and the framework.

Barry Bonds hits 756th homer

2007-08-08T06:05:00.000-07:00

Barry Bonds hit his 756th home run last night passing Hank Aaron's record. In terms of records in baseball, this is probably the single most important one, earning anyone that holds it the arguable distinction of being the greatest player of all time. As a San Francisco Giants fan with little to boast about thus far, I am going to savor this moment for a long time.
Here's the video of the moment... in Silverlight, courtesy of Major League Baseball.

Silverlight 1.0 Release Candidate

2007-07-30T09:26:00.001-07:00

I am happy to announce the availability of Silverlight 1.0 RC. Much of our team has been working on this heads-down for the past few weeks. For those not familiar with (Microsoft) pre-release software nomenclature, an RC is the last major milestone before the final release of a product. I think with this RC we have a great solution for building media-rich experiences that span browsers and platforms.

You can get the runtime here and here's information on what's changed between Silverlight 1.0 Beta and now. The Silverlight product and community sites both have updated content. If you are a designer or developer, then you might want to look at the downloads page on the Silverlight.net community site for tools, documentation and SDK support, including info on Expression Blend 2 August Preview. This Silverlight 1.0 RC release comes on the heels of the twin releases of Visual Studio 2008 Beta 2 and .NET Framework 3.5 Beta 2. Kudos to all the teams involved in this.

The RC has breaking changes from the previous releases. There are also a few new features like support for accessing the root element via silverlightPlugin.content.root for one. This was a frequent ask on the Silverlight forums and we were glad to oblige.

This post had been sitting in my Live Writer app since Friday and I only just got a chance to hit the shiny blue Publish button.

nibbles: snack tutorials for hungry designers

2007-06-21T09:57:00.000-07:00

Celso Gomes has a new site up called nibbles: snack tutorials for hungry designers.
In his words:

The concept of nibbles is simple: snack tutorials for hungry designers. The tutorials will teach a few steps at a time, so they will be short and easy to follow - the perfect creative snack.

There are a few tutorials on using Expression Blend and Silverlight already up, with content on Blend and WPF coming soon. New additions will be announced on the nibbles blog.

Silverlight links

2007-06-14T16:39:00.000-07:00

Joe has a comprehensive list of breaking changes between the 1.0 Beta and the forthcoming 1.0 RTW release of Silverlight. It's a small list but the changes were mostly requested by the community via forums and 1:1 interactions.

Vivek has been blogging up a storm in this past couple months on Silverlight topics. Some good posts there on his experience building a sample search app using Silverlight, a hyperlink control etc. (Thanks to Lauren for the tip)

Outlook 2007 look and feel with WPF

2007-06-14T16:25:00.000-07:00

Ronnie Saurenmann, one of our architect evangelists in Switzerland, sent a link (via email) to a Hands-on Lab (HOL) on how to build an Outlook 2007 UI look and feel using Windows Presentation Foundation. He says this was done "90% in Blend and 10% manual XAML" tweaking. There's an XBAP demo of the app in case you want to see the results, along with a lab manual with step-by-step details and sample source code.

Update: Fixed source code link.

Why is XAML case-sensitive?

2007-06-14T16:18:00.000-07:00

In short, because XAML is XML, and XML is case-sensitive. Rob Relyea, fellow program manager and owner of the XAML specification at Microsoft explains with details.

Joel Spolsky's brush with Vista's SuperFetch

2007-06-14T13:18:00.000-07:00

In a scathing post on the new Safari 3 for Windows, Joel remarks how slow the browser is while starting up. He likens Apple's performance claims as reality distortion, but later makes an update saying:

The more I run Safari on Vista, the faster it launches. Am I hallucinating? Is there a cosmic force that means just when I complain about Safari taking 57 seconds to launch, as soon as that complaint is made public, it launches much more quickly? Am I going insane? Or is someone playing a clever prank on me?

Well Joel, you're not going insane. Ironically this is Microsoft's Windows Vista coming to Safari's rescue. You see, Windows Vista has a little known feature called SuperFetch, which

enables programs and files to load much faster than they would on Windows XP–based PCs.

When you're not actively using your computer, background tasks—including automatic backup programs and antivirus scans—run when they will least disturb you. These background tasks can take up system memory space that your programs had been using. On Windows XP–based PCs, this can slow progress to a crawl when you attempt to resume work.

SuperFetch monitors which applications you use the most and preloads these into your system memory so they'll be ready when you need them. Windows Vista also runs background programs, like disk defragmenting and Windows Defender, at low priority so that they can do their job but your work always comes first.

The Windows team has figured out that the more you use something, the more you must like it and the easier and faster it should be to load. But you won't see that in a Microsoft ad.

Eyes On Darfur

2007-06-06T08:19:00.000-07:00

Amnesty International's Eyes On Darfur project just went live. It uses satellite imagery to get a neighborhood watch going over 12 vulnerable villages in Darfur. The idea being that with the eyes of the world on Darfur, the repressionist establishment and its cohorts there would not go about business as usual.

The project claims to leverage "the power of high-resolution satellite imagery to provide unimpeachable evidence of the atrocities being committed in Darfur - enabling action by private citizens, policy makers and international courts. Eyes On Darfur also breaks new ground in protecting human rights by allowing people around the world to literally "watch over" and protect twelve intact, but highly vulnerable, villages using commercially available satellite imagery."

There's much to be said about the low resolution images. But this is a cause that is dear to Ashley and I, and we're happy to see Amnesty do this if only to increase awareness. There's another project that's been in the works for a while and I hope to talk about that soon.

Google Gears and Silverlight

2007-06-05T18:06:00.001-07:00

Last week Google announced an early beta of Gears, a "browser extension that enables web applications to provide offline functionality using following JavaScript APIs:

Store and serve application resources locally
Store data locally in a fully-searchable relational database
Run asynchronous Javascript to improve application responsiveness"

I figured that meant it was an automatic fit within a Silverlight application. So, as a proof of concept I decided to tweak the Simple Database Demo and integrate Silverlight content into it. The results are here for you to see.

Thanks to how Google and Microsoft architected their respective products, that was 5 minutes of effort at most. You can choose your browsers View Source option on that example and see how script interacts with the Gears APIs and tweaks XAML in Silverlight.

If you play with Gears and Silverlight some more and create something cool, drop me a comment.

Update 1: Danny Thorpe talks about his founding work on Gears whilst at Google.

Update 2: Fixed broken link to SilverGears sample.

Update 3: Fixed links again. Due to some issues with the hosting service for the "SilverGears" sample, I've moved it to a new host. I really appreciate Mike and Chris for hosting it on simplegeek.com thus far.

Update 4 (May 02, 2009): Those of you searching for information on local persistence store in Silverlight may want to see this post which also looks at offline/out-of-browser support.

Everybody Hates The London Olympics Logo

2007-06-05T13:02:00.000-07:00

Not me though. If you've built a brand that everybody's suddenly talking about, can it be a bad thing? [Tip: look at the size of the thumb on your vertical scrollbar after you jump through that hyperlink.]

Although the use of a tangram-like style evokes images of broken glass or even an athlete doubled over in pain, it seems to spell out "2012", the year of the Olympics in question.

Surface As Inspiration

2007-06-01T13:25:00.000-07:00

David Anson outdoes himself yet again. Check out his Silverlight Surface demo. Source code included.

Microsoft Surface: What WPF Can Do For You

2007-05-30T09:55:00.000-07:00

Today Microsoft announced the Surface, a new line of consumer products that turn "an ordinary tabletop into a vibrant, dynamic surface that provides effortless interaction with all forms of digital content through natural gestures, touch and physical objects. Beginning at the end of this year, consumers will be able to interact with Surface in hotels, retail establishments, restaurants and public entertainment venues." If the videos on the Surface website seem impressive, you haven't even scratched the surface yet. Using the real product is way cooler!

The Surface team has thus far been operating under the radar. I'm proud to say that the device runs a variant of Windows Vista and uses Windows Presentation Foundation (WPF) for its user experience. It shows how WPF can be a game changer when you exploit its power. It is understandable that the first generation of the product - shipping in the second half of 2007 - is out of reach of the average consumer, and is focused on businesses. I expect that in a couple iterations, component prices, usage scenarios and its economic network will work their way to the mainstream. We've seen that story before. These are good tidings for designers and developers; as Rob points out, this is a "nice device to leverage some of your WPF programming skills on!". This is a great time to pick up and hone those WPF, Silverlight and Expression tools skills.

Congratulations to our friends in the Surface team on the public unveiling of a fantastic product.

View Source - Giving It Back with Silverlight

2007-05-19T17:51:00.001-07:00

Much of my HTML, Javascript and CSS learning came by way of the View Source context menu option in Netscape Navigator and Internet Explorer with some tinkering on (the old) Geocities. My experience in that domain is hardly unique. And I had the opportunity to learn from the best; to sit on the shoulder of giants, as it were. I'd posit that the acceptance, popularity and ubiquity of the universal web is in large part due to that "openness" and the ethic of sharing. By keeping XAML in Silverlight a mere step away from your piqued curiosity, we're actively trying to make it easier to learn from the best.

Ernie Booth takes away what little remnants of pain existed on the newbie programmer's path to Silverlight nirvana with his excellent plug-in for Lutz Roeder's Reflector. Check out Ernie's post entitled View Source Reflector tool for .NET Silverlight sites. A must-have tool for the Silverlight developer.

Needless to say, should you care about protecting your IP, the tool doesn't circumvent any existing safeguards you have in place.

We Popfly High, No Lie, You Know It

2007-05-18T11:29:00.000-07:00

With what it states as "another piece in [Microsoft's] company-wide outreach in helping non-professional developers build everything from Xbox games to Robotics to custom Web applications using Windows Home Server", Microsoft today announced a new service called Popfly.It comprises a set of online visual tools so non-programmers can create web experiences, and a social aspect involving a community watering hole where people and view, share, remix and rate content. And did I mention Popfly was built using Silverlight? Popfly is currently accepting limited participants for its private alpha.

Personally speaking, Soma's and John Montgomery's talk about extending tools like Visual Studio to the Live world, is starting to make sense. Of course, this is just a step in that direction. John was kind enough to give us on the Silverlight team a sneak peek at Popfly at a Friday Beer Bash some weeks ago. As a fan of UNIX Pipes programming paradigm, I was immediately fascinated by some aspects of the Popfly Creator. We'd have loved to have shown this off circa Mix 07, but John and team rightly were looking at Maker Faire as the correct avenue to showcase this.

See one such Popfly creation in action here.

Namescopes in Silverlight

2007-05-17T16:15:00.001-07:00

When you start naming things, you quickly realize that you need a method to disambiguate or resolve conflicts between names. When your sister cried out "Mom! Pete flushed the goldfish down the toilet!", your mom knew the "Pete" your sis was referring to was you, not the kid down the street. That's because she used an implicit name scope to infer.

What is a name scope?
Nick Kramer describes a name scope or namescope thusly:

"In almost all programming languages, names are not globally unique, they are unique only relative to other names in the same name scope. In C++ and C#, a name scope is roughly what goes between curly braces -- { }. And in C++ and C#, namescopes nest -- if the compiler can't find the name in the nearest namescope { }, it will look in the containing namescope.

Xaml names have many of the same issues. In <Button Name="foo">, foo is not unique to the whole program, there could be other xaml files with the same name. And you can instantiate that xaml file multiple times (e.g., multiple windows). "

Nick goes on to explain the role namescopes play in WPF. They kinda play a similar role in Silverlight.

Okay so we now know that a namescope is a logical grouping of named elements. Further, the "root" or ownership of a namescope is tied to a specific element and all of its named children fall into that namescope unless a child defines another namescope. This element is considered having the ownership of the namescope.

When do I care?
A namescope is typically created when the root visual is set. Well, in Silverlight there's a couple ways you, the app developer, can create elements in a separate namescope. One way is through a createFromXaml call in Javascript where you set the last parameter to true. The other is when you instantiate a Silverlight 1.1 Alpha control (see the SDK). In the latter case, the ControlBase class constructor makes a call to InitializeFromXaml in System.Windows.Controls.Control - which in a way is the managed equivalent of making a createFromXaml(xaml, createNamescope) call. You can use that approach for your custom controls.

Update: And oh, you also care when you do a FindName(). That method only walks the tree in the namescope of the element on which FindName was called. For instance, of you do rootCanvas.FindName("someElementName") you're searching for "someElementName" in the namescope of the rootCanvas element. Another element with the same name but different namescope is invisible at this time.

What types of namescopes exist?

The namescope created with the root visual is called the default namescope. When you call createFromXaml and tell it to create a namescope this is called a private namescope. If you call createFromXaml and do not create a namescope a temporary namescope is created

All elements content created in the visual tree will reside inside the namescope. Names defined in the namescope will not conflict with other names outside of the namescope.

Default namescope
A default namescope is automatically created when the root visual is created. The default namescope can be replaced by resetting the main visual tree.

Private namescope
A private namescope is the permanent name scoping that is created. A private namescope has the restrictions mentioned earlier in that it cannot be dissolved – it is always associated with the element that owns the private namescope. Named/un-named elements can be added/remove from the private namescope though.

Temporary Namescope
A temporary namescope is created any time you call createFromXaml and have an element tree fragment not associated with the main tree. A temporary namescope is different from a private namescope in that when you add the element tree fragment to another tree the temporary namescope is dissolved. This "addition" can be by using a collection's Add method or by setting a property such as a Rectangle's Fill.

A Layout System and Containers for Silverlight 1.1 Alpha

2007-05-17T11:34:00.000-07:00

Dave Relyea's first blog post showcases some work he'd been recently doing to build a layout system, several layout containers and some layout-aware controls -- all in user code. Ooh, but that's not all. Dave cranked up a pretty cool TextBox control as well. See Silverlight 1.1 Alpha Layout System and Controls Framework.

You can use this until the Silverlight 1.1 platform natively supports layout and editing (which is... soon).

New To Programming?

2007-05-15T10:26:00.000-07:00

Microsoft's Beginner Developer learning center has great resources for beginner programmers intending to learn web and desktop programming basics. There's also a Kids Corner.

Silverlight UI Controls

2007-05-03T14:59:00.001-07:00

Update [Apr 2009]: The post below is now obsolete. There is now a great ecosystem of UI controls for Silverlight. You can start with the Silverlight Toolkit, a Microsoft provided collection of Silverlight controls, components and utilities made available for your development with a permissive license (MSPL). Besides, there are excellent controls from ComponentOne, Telerik, Infragistics etc. There's also some good documentation on Silverlight Controls on MSDN.

-----

If you've played with Microsoft Silverlight 1.0 Beta or 1.1 Alpha bits, you've no doubt noticed that while there's Canvas, TextBlock and other such controls, there is no Button or ListBox or even layout elements like StackPanel or Grid. Rest assured, your UI development needs are always on our mind.

If you download the Silverlight 1.1 Alpha SDK, you'll see a UI controls package in there. You didn't think we'd leave you in the lurch, did you? Although it is very easy to whip up a Button control with XAML and some code in Silverlight, that detracts from your app building. To address this, we've released a modest set of controls in the Silverlight UI Controls package. These include:

Button
ScrollBar
ScrollViewer
Slider
ListBox

Also included are a couple primitives like RepeatButton, Thumb and GripThumb.

All of the controls in that package are managed code controls i.e. they rely on Silverlight 1.1 Alpha and the CLR and Silverlight framework in it.

These controls currently sport the Silverlight "Dawn" look and feel. We're releasing source code for these controls so you can modify and customize them as appropriate. There is a readme file with additional information and the code is peppered with comments, all which the agile diehards are free to ignore, 'cause the code is the documentation. The control behavior is in C# code-behind files, while the control templates, i.e. the visual aspects governing look and feel, are in XAML markup files. Another example of separating UI from behavior, as architecture astronauts have been telling us since the dawn of time.

Controls such as ScrollBar, ScrollViewer, ListBox and Slider are composed of other controls. We picked this mix because it accentuates the diversity of the control set and allows you - the designer or developer - to look at the source code and understand the Silverlight framework, the inter-dependencies between controls, and not to mention, the quirks in the control set arising from some features being absent in the 1.1 Alpha.

Please use these controls in your applications targeting Silverlight 1.1 Alpha. In fact, it should be pretty simple to take the XAML pieces, tie in some JavaScript and have all of this run on 1.0 Beta. But I'll leave that to the community.

As always, direct comments and bug reports on the UI controls to the Silverlight Forums. If you have questions about the control roadmap or other considerations made while developing this set, drop me a line here.

Meet Silverlight

2007-04-30T08:42:00.000-07:00

Today at the Mix 07 conference, Microsoft is announcing a couple preview releases of Silverlight. Silverlight v1.0 Beta is the next in series to the two community technology previews (CTPs) released with the codename "WPF/E".

Silverlight v1.1 Alpha is a sneak peek at some future functionality.

While it is unusual to have two separate pre-release trains for a product, we believe that there's nothing like real code and real samples to demonstrate our feature set, roadmap and intent. The team has been aggressively cranking out code, delivering key features with tight deadlines. Please download the builds, play with them, build apps and tell us what you think.

Here's an incomplete list of new features or enhancements in Silverlight 1.0 Beta:

VideoBrush - Used to paint shapes and text with video content.
WMS streaming support
Media markers / script command support
Playlist support (ASX subset)
Improved video playback smoothness
Cleaned-up animation model
- Animations now go in a Canvas.Resources block
Support for downloading and unpacking .zip files
Support for cross-domain downloads
Improved text rendering
Ink support
Improved javascript programming

Enum support
Better error handling
Support for delegates as event handlers
Sandboxed javascript mode

Namescope support
New properties for UI manipulation:
- Z-Index
- Visibility
- IsHitTestVisible
Downloading fonts for TextBlock

Silverlight v1.1 Alpha contains a flavor of .NET, with support for languages such as C# and VB and dynamic languages such as Python, Ruby, VBx etc. The v1.1 Alpha build is a superset that includes the functionality delivered in v1.0 Beta. Unlike v1.0 Beta, the v1.1 Alpha does not give you a Go Live license. We expect that you'll evaluate and explore it and give us feedback on what you don't like and what you'd like to see more of. Get involved. We're listening.

Get Silverlight now!

What does Silverlight mean to you?

2007-04-19T22:32:00.001-07:00

Mike Harsh, fellow program manager on the team and all-round great guy, was manning the Silverlight booth at the NAB Show, doing demos and talking to customers. He says: "I have never been involved with any technology that has this level of excitement and interest, and I’ve never given demos to so many people who’ve walked away with a smile on their faces. After seeing the demos it sinks in very quickly that Silverlight will let them do incredible things with their existing Windows Media assets using all their existing delivery infrastructure." Read that last statement carefully. It touches on what we think is the essence of Silverlight today.

Dave Wolf from Cynergy says "[The] entire RIA market just became real and it is about to explode, and it is thanks in large part to Microsoft and Silverlight... Microsoft just justified and legitimized RIA. That is HUGE." I think Dave makes a great point. With a player like Microsoft advocating the agenda, you will see the company's traditional audience of developers and decision makers in enterprises, take RIAs more seriously than they have. This adds to the momentum Adobe (and previously Macromedia) have already garnered. I think with companies like Adobe and Microsoft at the helm, we're at the beginnings of the RIA renaissance.

In that post, Dave also talks about the Microsoft penchant for project code names, but as an insider, I do not see that these names mean that much. Sure they're placeholders on specs, slide decks, share points and distribution list aliases. But that's about it. We laugh when the press and blogosphere influentials weave sinister stories out of these. What matters is action, not name. For clarity, "Sparkle" was never the code name for Silverlight (as some have suggested): it was "Jolt" to the development team and "WPF/E" to everybody else. "Sparkle" was the code name for Expression Blend, the design surface for WPF. I've lost count of the number of times I've chuckled when the tech trade press called Sparkle the Flash-killer. Yeah, like Picasa is the Photoshop killer. Can we please stop with all the killer references?

All of this finally brings me to the core point I'm trying to make in this post. That is: don't believe the hype and the FUD. We're going to announce more details on Silverlight features at the Mix 07 conference. Pick up our next build (coming soon to microsoft.com/silverlight), read the docs, play with the bits and the tools, ask questions on the Silverlight forums, engage with the community and make up your own mind. And do let us know what you think. I'll trade a million articles in tech rags for one post on the forums or your blog where you candidly tell me and the team what we're doing wrong and where you'd like to see us go. Our plans are not set in stone. Silverlight is still pre-release software and there's much we can add and change in this and future versions. My team and I are not looking for toothy grins and thumbs-up signs. We're looking for honest critiques and feature requests. Got any?

PS: I cannot be at Mix 07 this year. I'll be taking it easy that week, but Joe, Vivek, Nick, Mike and others from the team will be on hand to answer questions.

The Hassle Free Commute as a Benefit

2007-04-17T21:28:00.001-07:00

California state no longer issues the decals that allows hybrid cars on carpool lanes even with low occupancy, but the decals are still good. The folks at Kelley Blue Book [as heard on NPR's All Things Considered] have discovered that people in the state are paying a premium of $4000 for hybrid cars with the now out-of-supply, tamper-resistant decals. Hmm, the free market is willing to pay four Grover Clevelands for the luxury of a hassle free commute. I've believed Google's bus service for its employees in the Bay Area was a great fringe benefit helping hire and retain good talent. We now have statistics to back the logical conclusion that people actually desire such a perk.

Silverlight Trivia

2007-04-16T07:24:00.000-07:00

The name

We've been dropping little hints about the name for months now - the MIME type for the browser plug-in in the Feb CTP was application/ag-plugin and the script instantiation used a new agHost(...) call. Ag (short for Argentum) is the symbol for Silver in Mendeleev's Periodic Table of Chemical Elements.

Silver
47
Ag
107.8682

The .NET connection

Yes, Silverlight extends the reach of the CLR and .NET Framework to other platforms like the Mac! Details coming soon.

Whatever happened to "WPF/E"?

2007-04-16T07:15:00.000-07:00

You can stop calling it "WPF/E" now. This morning, Microsoft announces Microsoft Silverlight, a new cross-browser, cross-platform technology for interactive media and rich applications. This is the technology formerly codenamed "WPF/E".

I've been working on Silverlight features for a few months now and am excited about today's public announcement at the NAB Conference in Las Vegas, NV. At the conference, Microsoft will reveal it's brand and announce partner support for Silverlight. Then at the Mix 07 conference on April 30th, the company will unveil and discuss the breadth of the Silverlight developer and designer ecosystem.

We live in interesting times.

WPF College Courses

2007-04-14T09:20:00.001-07:00

I was happy to learn [via Lee] that the FootHill College of Los Altos, CA is offering introductory courses on Windows Presentation Foundation and other .NET technologies. The courses include one on .NET Deployment that I'm guessing (I couldn't find a syllabus for that) includes ClickOnce, the most superior application deployment technology out there for rich client apps.

This is a great opportunity for anyone in the Bay Area wanting to pick up on Microsoft's next generation presentation sub-system and framework APIs.

Cal Schrotenboer, the instructor for these courses, says the cost for California residents is $100 for a class. And since these classes are also offered in an online format, you can enroll from anywhere.

Software Branding

2007-03-17T08:00:00.000-07:00

I was pleased to see the updated Windows Vista User Experience Guidelines introduce a section on Software Branding. I firmly believe the secret sauce behind every successful software application is the emotional chord it strikes in the end user. Too often we, the sausage makers, focus too much on the technical aspects and too little on the emotional aspect of the software we build.

For something that is frequently overlooked or gotten wrong, this article on software branding is chock full of common sense. Although the examples use Windows artifacts, the guidelines apply very broadly to software we all create.

On another note, I am happy to see this idea dawn on folks across Microsoft. Now if we can strike the right balance between the whole technical v/s visceral v/s behavioral v/s reflective aspects, it'll portend good things to come. The innovations in the Shell in Windows Vista, and platforms such as WPF and WPF/E will surely help.

Expression Blend is Release Candidate

2007-03-17T07:34:00.000-07:00

The Expression Blend team quietly announced their excellent designer surface for Windows Presentation Foundation went to Release Candidate status. The new build has a bunch of fixes but no new features (that I'm aware of) over the most recent CTP. It does however introduce some spectacular starter samples built using Blend. If you have a creative bone in you, I really recommend downloading Blend RC and taking it for a spin. Either way, check out the ClickOnce powered online samples that the ever resourceful Karsten has posted. I know Robbie and Nathan are impressed.

Times Reader Goes Subscription

2007-03-17T07:14:00.000-07:00

The New York Times announced that the Times Reader application's Beta period ends soon and it will be be converted to a $14.95 / month subscription service that will include Times Select and Premium Crosswords, which were previously paid content anyway. Also apparently home delivery customers of the paper will now get the Times Reader for free. Rob gives his perspective on the pricing. I suspect the Times is just testing the waters here. Of course they're in the subscription business to stay, but I wouldn't be surprised if they factor in usage data and tweak the model to accommodate the potentially diverse user base. Let me tell you, there's more method than madness behind SKU differentiation.

Shopaholic

2007-03-08T19:04:00.000-08:00

You know your significant other is really into this whole online shopping thing when you come home to this:

Live Traffic Gadget

2007-03-06T21:04:00.001-08:00

I'm a minimalist when it comes to the gadgets on my Vista Sidebar but as a Seattle area resident, this I couldn't resist. The Traffic gadget by Live Search Maps is now available and it supports over 20 U.S. cities.

The blurb for this gadget says:

Don’t get stuck in gridlock or be late to your next appointment. Traffic by Live Search Maps is a quick and simple way to see real-time traffic conditions in your area. Shortcuts to driving directions, local search or full-screen traffic view on maps.live.com are also easily available from the gadget. All information within this gadget can also be found at maps.live.com

You can get it here.

Using WCF In An XBAP

2007-03-05T07:08:00.000-08:00

Steve Maine confirmed to Rob and me that Windows Communication Foundation (WCF, codename "Indigo") will work in partial trust in upcoming .NET Framework v3.5. This means you can now use HTTP binding in WCF from within a XAML Browser Application (XBAP).

What does this mean? Well, using WCF you will now get parity for things for which you have been using ASMX within your XBAP. Secure communication is possible via transport layer security only.

Not all WCF features are available from within an XBAP though. This means you cannot currently host services, have duplex communications, use non-HTTP transports, or use WS-* protocols. Please use the WCF Forum or the WPF Forum to tells us what you think. We'd love to hear your feedback on this feature.

For the differences between ASMX 2.0 and WCF, see this article. If you already have ASMX services for which you were using an ASMX client, here's how to migrate ASMX to WCF. I should add, you are already able to access a WCF service using an ASMX client.

Using Economics to Predict a Flu Pandemic

2007-03-02T20:15:00.000-08:00

Markets have proven their effectiveness in predicting future prices and economic conditions. This is the bedrock on which our stock and futures trading institutions rest on. The Chicago Mercantile Exchange has a weather futures that allows traders to wager on weather conditions using measurements like heating day degrees (HDDs) and cooling day degrees (CDDs). Farmers have long relied on the Merc's ability to predict prices from items like Lean Hogs to Dry Whey.

Iowa Electronic Markets is a futures market operated by the business school at the Univ. of Iowa for research and educational purposes. For a dozen years, they've accurately predicted election results, and have roundly beaten opinion polls at that. In fact today, March 2, 2007, trading began in the markets based on the 2008 U.S. Political Conventions of the Democratic and Republican parties.

Now the IEM takes on the flu pandemic. No, seriously. They have a program where health professionals can participate in a pandemic futures market. However, unlike some of their other prediction markets, this market does not use real money in line with legal constraints and medical ethics. It remains to be seen if real money is the secret sauce behind the wisdom of crowds in the predictions markets. My (Ayn Rand infused capitalist pig) gut says money, the fear of losses and the prospect of gains all have an important role in influencing human behavior. These sentiments either directly influence or at the very least catalyze your decision to buy or sell or hold. When one or more of these aren't involved, the results might be skewed. By how much, it remains to be seen. You can bet I'll be tuned in.

Eneagled

2007-03-02T20:00:00.001-08:00

Noticed on The Colbert Report opening sequence, the word ENEAGLED. My subconscious was expecting to see FREEM but a quick rewind and pause on the Tivo showed me otherwise.

This replaces the just-as-made-up FREEM which I expect meant "Freedom without the DO". Is this possibly a blend of "engulfed" and "eagle" or perhaps "enabled" and "eagle"? With Stephen Colbert being a renowned eagle fancier, at least one substrate is easily established.

What do you think "eneagled" means?

WPF/E vs DHTML vs Flash vs WPF performance test

2007-02-27T20:54:00.001-08:00

Rob sent a link to this post by Alexey Gavrilov who did some benchmarking on a variety of client technologies: DHTML, Flash, WPF/E and WPF. Alexey summarizes the test results thus:

Here are results I got testing with 16 [animated bouncing] balls on my Pentium M 1.7 laptop:

Browser DHTML Flex WPF/e WPF

IE 6.0 56 61 84 99

Firefox 2.0.0.1 55 52 58 -

Opera 9.01 94 50 - -
[...] WPF/e is much faster in IE than in Firefox, which seems equally slow for all three tests. The expected result is that WPF runs faster than anything else. The unexpected is that WPF/e is faster than Flash despite the fact that it’s been in the market for years.

Since the tests focus on a narrow animation sample, one would be cautious to put too much into the results. Regardless, the findings are very interesting. Alexey has posted sources for the tests so you can run them on your own machine.

Banning the light bulb

2007-02-20T19:12:00.001-08:00

Australia pulls the plug on old bulbs reports the BBC, referring to the proposed plan to completely phase out the incandescent light bulb by 2010 and replace them with fluorescent bulbs. A similar proposal is being considered by California. I understand the energy savings and reduced greenhouse gas emissions resulting from this switch but don't fluorescent bulbs contain mercury? Is there a plan to accommodate tons of fluorescent bulbs in recycling centers? It'd be a tragedy to have millions of these bulbs in our landfills with the potential of seeping into the ground water. I'm curious if Australian citizens are asking this question.

In search of the smokin' pipe

2007-02-08T21:33:00.000-08:00

When I first heard of Yahoo! Pipes it evoked memories of the brilliant conception from Sun Microsystems of JXTA - pronounced Juxtapose - from a few years ago. I remember being really excited about an idea whose time had come: JXTA was UNIX Pipes on steriods. Of course, there's many a slip 'twixt the cup and the lip. The fact that almost no one has heard of JXTA six or so years since, is really telling. I do think Y! Pipes is a cool idea though. I have had trouble accessing that site until a few minutes ago. Even now, not all "popular" sample pipes seemed to function. Yahoo is working on increasing capacity after site had a period of downtime ostensibly due high demand on the servers.

There's a lesson to be drawn here for all of us pundits who think web apps will just replace desktop apps this weekend while we aren't noticing. It's one thing to move an app to the web and totally another to make it scale. A Google executive was quoted in this Reuters story as saying:

The Web infrastructure, and even Google's (infrastructure) doesn't scale. It's not going to offer the quality of service that consumers expect.

Companies everywhere are working on solving these tough problems in a variety of ways. Until we learn how to scale serious applications, they'll continue to be written for and executed on the desktop. Tip to those of us that work to further the cause of desktop apps: Don't let this lull you into complacence. Things could really change this weekend.

Open Standards, not Open Source

2007-02-08T20:44:00.000-08:00

Miguel has a very insightful post on the OOXML v/s ODF meme. He says:

Open standards and the need for public access to information was a strong message. This became a key component of promoting open office, and open source software. This posed two problems:

First, those promoting open standards did not stress the importance of having a fully open source implementation of an office suite.

Second, it assumed that Microsoft would stand still and would not react to this new change in the market.

And that is where the strategy to promote the open source office suite is running into problems. Microsoft did not stand still. It reacted to this new requirement by creating a file format of its own, the OOXML.

It is amusing to see the reactions of people who shouted from rooftops that Microsoft wasn't open or wasn't transparent, now that Microsoft is doing something to remedy that. The shrill voices that said "we do not have enough information on Microsoft's proprietary protocols to interoperate well" have now changed to "gee, at 6000 pages the spec is too large...too much information". There's also the dishonest comparison with the ODF spec that comes at 722 pages, conveniently ignoring the little fact that ODF references other specs like SVG. Miguel postscripts with this gem:

For example, many years ago, when I was working on Gnumeric, one of the issues that we ran into was that the actual descriptions for functions and formulas in Excel was not entirely accurate from the public books you could buy.

OOXML devotes 324 pages of the standard to document the formulas and functions.

The original submission to the ECMA TC45 working group did not have any of this information. Jody Goldberg and Michael Meeks that represented Novell at the TC45 requested the information and it eventually made it into the standards. I consider this a win, and I consider those 324 extra pages a win for everyone (almost half the size of the ODF standard).

Depending on how you count, ODF has 4 to 10 pages devoted to it. There is no way you could build a spreadsheet software based on this specification.

To build a spreadsheet program based on ODF you would have to resort to an existing implementation source code (OpenOffice.org, Gnumeric) or you would have to resort to Microsoft's public documentation or ironically to the OOXML specification.

...

Christian Stefan wrote me to point out that the OOXML specification published by ECMA uses 1.5 line spacing, while OASIS uses single spacing. I quote from his message:

ODF 722 pages
SVG 719
MathML 665
XForms 152 (converted from html using winword, ymmv)
XLink 36 (converted from html using winword, ymmv)
SMIL 537 (converted from html using winword, ymmv)
OpenFormula 371
----
3,202

Now I'm still missing some standards that would add severall hundred pages and changing line spacing to 1.5 will bring me near the 6000 pages mark I guess. This is not very surprising (at least for me) since both standards try to solve very similar problems with nearly equal complexity.

That's a kick in the pants if there ever was one.

...It is a duck

2007-02-04T07:55:00.000-08:00

I noticed a very peculiar line in the article "Viacom Tells YouTube: Hands Off" in the New York Times:

Whether YouTube is stealing content by serving up clips of copyrighted programs is very much up for debate.

I wonder if the Times would take as measured and conciliatory a stand if its own Times Select content were served up on another site and read by thousands of visitors, accruing brand value for that site and ad revenue to boot, but with no tangible returns to the Times itself.

I think it is easy to take sides in most such issues because they seem to involve Joe Public on one side versus big companies, record labels and other Hollywood entities that haven't exactly been upstanding citizens, on the other. In this case, it’s a tussle between Viacom and Google: both big boys who are potty-trained and can take care of themselves. Either way, people lose sight of the content creator - who sometimes is an average guy without an army of lawyers at his disposal - and is the rightful owner of his creations. The content creator gets to choose how his content can be distributed or copied and enjoys the profits that arise from that creation. This is how capitalism works. If we love its benefits, we must be prepared to pay the price it asks.

Windows Vista in a browser using WPF/E

2007-02-02T05:29:00.000-08:00

From the Microsoft Slovenia team with assistance from local agency Renderspace, here's a Windows Vista demo using WPF/E. Very cool! Requires Feb 2007 CTP of WPF/E which went live yesterday.

Great apps powered by ClickOnce

2007-02-01T08:57:00.000-08:00

I've posted previously about XBAPs, but here are a couple links to standalone Windows Presentation Foundation (WPF) applications that use the ClickOnce deployment model.

ITN has a cool new news -video application called ITN Hub Player, accompanied by a Windows Vista sidebar gadget. See http://www.itn.co.uk/vista/

OTTO, the 2nd largest online retailer in the world, just went live with a very impressive ClickOnce-deployed WPF application which completely changes the online store as you know it. See http://www.otto.de/vista

This app also uses Windows CardSpace and Windows Communication Foundation (WCF), both .NET Framework 3.0 components and part of Windows Vista.

I love seeing ClickOnce being used in mainstream consumer oriented applications, and will be posting about these more often. And that's not just 'cause my team owns WPF Deployment and works closely with the ClickOnce team. Having had my share of munging around with MSIs, I think ClickOnce is by far the most superior application deployment technology out there for rich client apps on Windows. It provides a sophistocated update mechanism for your apps, taking the pain out of that process. If you haven't heard of it before, or aren't using it in your .NET apps, I think the apps above will make you reconsider.

Windows Vista: Now In A Store Near You

2007-01-30T07:32:00.000-08:00

After "the biggest product launch in Microsoft's history", Windows Vista is now available in a store near you and via fine merchants online. This is a culmination of years of work done by my teams and countless others in Microsoft, hardware & software partners and OEMs. In the WPF team, as elsewhere, we've fervently believed: "if you build it, they will come". So although I don't claim to speak for Microsoft on this blog, above all, a big shout out to all of the developers and creative professionals who patiently evaluated our CTPs, Betas and the like and gave us great feedback; and to the people who continue to bet their businesses on our platforms, frameworks and APIs. Thank you for your support. Please keep telling us what we're doing wrong, and what we're getting right. Here's to building applications we've dreamed of!

Tags: Windows Vista, WPF, WinFX, NetFX3, Microsoft

Windows Presentation Foundation, is the next generation presentation sub-system and managed code framework for Windows. It is a .NET Framework 3.0 component, present on Windows Vista and a free download for Windows XP SP2 and Windows Server 2003.

Xceed WPF DataGrid - For Free

2007-01-25T19:29:00.000-08:00

For real. WPF didn't ship with a DataGrid control in .NET Framework 3.0. The fine folk at Xceed Software recognized that and have now released an enterprise strength WPF DataGrid control to the community. They have a beautiful demo XBAP called Xceed DataGrid for WPF LiveExplorer that lets you see the control in action and use it for yourself.

Get the Xceed DataGrid control. [Requires .NET Framework 3.0 or Windows Vista]

Thanks to Mike for the tip.

Tags: WinFX, NetFX3, WPF, DataGrid, Xceed, XBAP

Dominoken

2007-01-25T15:12:00.000-08:00

KF sent us a link to this beautiful XAML Browser Application (XBAP) created by Bascule for the Windows Vista launch in Japan:

DOMINOKEN

Requires .NET Framework 3.0 or Windows Vista. I've seen it several times, changing the camera angle and zoom settings. Never gets old!

Tags: WinFX, NetFX3, WPF, XBAP, 3D, Windows Vista

The new Yahoo! Messenger for Windows Vista

2007-01-08T09:41:00.000-08:00

It has been tough to keep this one under wraps but I can finally talk now. Yahoo! is shifting the communication and instant messaging landscape. The new Yahoo! Messenger for Windows Vista is one of those seminal applications that demonstrate what good user experience really is. See the video and decide for yourself. This application is built on Windows Presentation Foundation (a .NET Framework 3.0 component and part of Windows Vista).

This isn’t just a re-skinned version of the existing messenger app... this was built by Eric and his ace team from the ground up. A tip o’ the hat to Karsten for tirelessly making sure all of Yahoo!’s questions and concerns were responded to promptly; whether he was hunting us down via discussion lists or on the phone or even setting up face to face meetings, Karsten was a bull-dog you couldn't get away from. Props to the good folk from frog for the kickass design.

This app is a powerful showcase for WPF and Windows Vista features and a testament to how designers and developers can work together on building great applications.

Tags: Yahoo, Yahoo Messenger, WinFX, WPF, Windows Vista

Link dump

2007-01-06T17:08:00.000-08:00

MSDN Wiki for the Windows Presentation Foundation SDK: If you find yourself stumbling into WPF esoterica that isn't adequately covered in the SDK, with the new MSDN Wiki features, you now have the ability to add your content to the SDK. Michael's post on the SDK blog has details.

Comparing WPF on Windows Vista v/s Windows XP: This question comes up often; in fact we had an interesting thread on the internal discussion list recently. Tim provides a great perspective on this topic. He also highlights the less known story about how WPF made its way to downlevel platforms like Windows XP and Windows Server 2003.

Building consensus: Brad Abrams has a multi-faceted post on building consensus in the workplace. Pick your favorite tips or post yours on the comments section.

Stop Digital Amnesia: The Center for Digital Amnesia Awareness says they have a cure. Details tomorrow night.

Tags: WPF, wiki, management, CES

The Rich Internet Application straw man

2007-01-01T11:51:00.000-08:00

Via Mike Chambers (Apollo product mgr at Adobe), comes this snapshot of a comment made by Mark Anders of Adobe:

If you look at what Microsoft is doing with WPF, they say it's really about rich Internet applications but actually, I don't think it is, because I think rich Internet applications are not about Windows only. I think the Internet is about a multitude of machines and you do not always know what they are.

Mike then goes on to extoll the qualities of a true "rich internet application" and how <insert Adobe buzzword> is the shiznit. Naughty! Naughty! Macromedia/Adobe coined the term rich internet application (RIA) and can frame it to mean whatever the heck they want it to mean. Cross platform? Sure! Compelling experience? Yeah why not! Target a layer above the platform? Well, duh! Makes the OS irrelevant? Was it ever relevant to anybody outside Redmond anyway?

Students of logical fallacies will recognize Mark and Mike's argument as a classic Straw Man Argument. The modus operandi is thus: create a position that is easy to refute, then attribute that position to your opponent. Simple. But not straight.

Windows Presentation Foundation (WPF) is part of .NET Framework 3.0, the new managed code programming model for Windows. As a member of the WPF team, and specifically as one of the co-owners of the XAML Browser Application (XBAP) story, I haven’t made the connection between WPF / XBAPs with the so-called rich internet applications. I doubt anyone else on my team or others in Microsoft who swim in the WPF pool have ever positioned WPF/XBAPs as such.

But there’s no reason to let facts get in the way of a good Microsoft bashing.

Tags: WPF, RIA

Is Data Dead?

2007-01-01T09:54:00.000-08:00

Some things never make it out of Beta. Recently, Google deprecated their SOAP-based Search API (Beta) in favor of an AJAX Search API. With this sudden announcement, Google is no longer issuing keys and has even pulled their SOAP API SDK out.

Want to integrate web search into your app? The SOAP APIs let you dispatch requests to the search servers and get responses (think ordered lists), that you could display however you choose to, or generally do whatever you wanted with them. Google’s new AJAX API replacement is much in the mold of AdSense and YouTube APIs: it occupies an “island” on your user interface real estate. Context and basic customization options aside, you have no control over what gets shown in that island. [Update: I stand corrected on this last statement. Mark L clarifies that the AJAX API offers other options giving you some control.]

Tea leaves
For a variety of reasons, developers have found this to be a worrisome turn of events. Apparently, in addition to the loss of flexibility, there wasn’t any advance notification on this decision, nor a REST or GData replacement API. The AJAX APIs (currently) allow 8 results only, a departure from the flexibility of the old SOAP APIs. Google’s Terms Of Service forbid you from hacking on the AJAX API and screen scraping results or manipulating the server to give you the data and not the UI with it.

From an API use perspective, this is a step forward for novice web developers and folks who could care less about aesthetics and user experience on their web sites. With that audience, it is difficult to argue against the idea of adding search to a website with just a couple lines of script and markup. By sheer numbers, I suspect that demographic makes up the 80% of Google’s audience for these APIs. Moreover, by supporting only the AJAX model instead of multiple alternates, Google seems to be marshaling the proverbial 20% of their resources to this effort. So the Pareto principle (80/20 rule) seems to be in full play here.

Web developers of the world, all is not lost! Live Search offers you a SOAP-based API. Yahoo! Search offers REST-based APIs. If you care about sanctity of APIs or just want complete control over results, you should consider moving over. Both these are excellent search services from very developer-focused companies.

Geeks need to take a chill pill
The blogosphere is rife with conspiracy theories and some folks make this out to be a technical battle between SOAP and REST or SOAP and AJAX or APIs and widgets. I do not think that is the case at all. Google’s decision seems to be based on business decisions, not technical. As a data and service provider, Google is looking for a way to monetize the service. This way, they can inject ads and cross-promotions into the results widget. If this snowballs into a trend, it portends an end to the days of building mashups by freeloading on data from the cloud. But again, Google has probably calculated that mashups account for almost nothing on their bottom line.

Tags: Search, SOAP

It's time

2006-11-30T09:17:00.000-08:00

This morning, Windows Vista, Office 2007 and Exchange Server 2007 were released to businesses and volume license customers. This is a big milestone for Microsoft. Now to the consumer launch in another 60 days.

Tags: Windows Vista

RE: What I Hate About XBAPs

2006-11-27T10:51:00.000-08:00

In his post titled What I hate about XBAPs, Charles Petzold rips me a new one. Among other things, my team owns the packaging and deployment mechanism for XBAPs. I think Charles is right on some counts but not all. In this post, I’m aiming to address his concerns as well as highlight some other factors that influenced our design and implementation. At the outset though, I must thank Charles for blogging about his concerns with XBAPs. My team and I appreciate the feedback and solicit this kind of feedback. If you "hate" anything in WPF, we’d like to know so we can look at rectifying the pain points.

Scenarios have their own pecking orders
Let me begin with the clichéd but true "we operate in a world with limited time and resources". Sending XBAPs via email and launching attachments wasn’t a Priority 0 scenario for the first-generation Windows Presentation Foundation offering. I would go as far as saying it wasn’t a priority 1 which sums up the nice-to-haves. And in this world too, natural selection is judge and jury.

I look at XBAPs as browser-hosted WPF applications that operate in a security sandbox. Apropos, then, the word "application": how many times a day do you get applications as attachments in your email? Not images or documents, mind you, but applications. In comparison, how many times do you navigate to content from within your browser, oblivious of the file extension or type being launched, but expecting it to launch in the browser. No, I’m not trying to present a (false) dichotomy. These are real considerations we have to weigh when we plan features.

Feature prioritization factors in a number of things, most importantly, customer feedback on how critical the scenario is to their application/business goals and end-user experience. Consequently it is not fruitful to architect XBAPs around scenarios our customers do not care about. Consider a couple examples of several such scenarios that heavily influenced our current design:

Tuppy Glossop authors an XBAP and publishes it to a network share or web server. Consumers access the XBAP via the browser by clicking on a hyperlink. Each time someone launches the XBAP, they see the latest version of the application published by Tuppy.

Bingo Little is an ISV who authors XBAPs for corporations who in turn host it on their own servers with their branding. They do this by updating the non-executable contents of the app, (resigning the manifests) and propping the application files to their web servers.

XBAPs do not exist in a vacuum
We’ve attempted to offer a broad set of options as far the application and content models in WPF go. It spans un-compiled XAML files to XPS documents to XBAPs to Standalone applications, with control flavors and inter-op sprinkled in between. The former two are best suited for being sent as email attachments. I try to resist the temptation of making XBAPs everything for everyone.

Launching EXEs is so 1990s!
As Charles correctly points out, email programs and corporate policies may prohibit launching EXE attachments. For this reason, .NET Framework deployment (specifically ClickOnce) provides the MapFileExtensions project property. When set to true, the built application’s executables and binaries have the extension ".deploy" appended to the actual file extension (.exe or .dll). This gives you another benefit of configuring only one blanket MIME content type mapping .deploy to application/octet-stream (which is the default on many web servers anyway). You can send people attachments that have a .xbap, a .exe.deploy and a .exe.manifest. In the same vein, you can deploy these files on a web server. When the .xbap is launched, the .NET Framework 3.0 deployment mechanism will recognize the other files.

Customer feedback influences future course
The WPF team does not understand your business or your customers. In fact you understand those best. And we work hard to understand you and your needs. If you, our customers tell us you really do care about scenarios that involve sharing WPF content via email, we focus on delivering that solution in the best way and timeframe possible.

However, I don’t believe the implementation matters so much. For instance, I can see this specific sharing scenario as being fulfilled by un-compiled XAML + code. That code can be inline or a referenced file. It can be script or C#/VB. This is all open to debate and the merits of any proposed implementation would dictate our approach. Right now, I’m taking Charles’s post as customer feedback on this scenario and am logging a work item in the product database to consider a solution. Needless to say, this feature is prioritized against the numerous others that are currently on the team’s radar, and is subject to feedback from other customers and partners. But I am confident that we can work out a good solution in a future version.

Tags: WinFX, NETFX3, XBAP

DevConnections at Las Vegas

2006-11-06T06:33:00.000-08:00

I'll be at the Visual Studio and .NET DevConnections conference at Las Vegas. If you are attending, be sure to stop by #704 (the Windows Vista section) and say hi. Arik, Paul David, Karen Franco or I would love to talk about Windows Presentation Foundation or .NET 3.0 or Windows Vista.

Tags: WinFX, .NET, NETFX3, Windows Vista, WPF

Internet Explorer 7

2006-10-19T07:07:00.000-07:00

Internet Explorer 7 has now been released. I'm not going to tell you to Spread the word. Or to plug it on your sites and magazines; to go out and get buttons; to bash the competition on silly metrics; to sign petitions in support or think up propaganda campaigns. Internet Explorer 7 is just a browser. A damned good one too.

Tags: IE7, Internet Explorer

Notes from the Mozilla team's visit to Microsoft campus

2006-10-09T06:33:00.000-07:00

Last week, the Mozilla team was on campus. I've been following their visit via the journal that Vladimir Vukićević has maintained on his blog.

Redmond, Pt. 1: Says he hopes to figure out the 2D rendering in Vista and some Direct3D aspects.

Redmond, Pt. 2: App compat, UAC, DPI awareness and the XBOX 360 room

Redmond, Pt. 3: By this time he's amused and slightly irked that just about everybody he meets is a Program Manager. Talks about CardSpace, Windows Installer and WiX, Watson, IE and running in Low Integrity Level, and closes with a SuperFetch rant

Redmond, Pt. 4: Clarification on SuperFetch and UAC. No he's not drinking the Microsoft kool-aid just yet. WPF/E, parental controls in Vista, IE again, and has some good advice for us on WhatWG.

Missing pieces: He's excited about Low Integrity Mode with UAC and a project to integrate CLR languages with Firefox as first-class scripting language providers.

Tags: Mozilla, Windows Vista, Microsoft

Desktop 2.0

2006-10-05T07:39:00.000-07:00

Kevin Gjerstad pointed us to this post by Brian Romanko who thinks we might be on the verge of Desktop 2.0. I hate buzzwords, and particularly despise the lazy little creations with version numbers. Yes, Web 2.0, you're on notice.

But if you look beyond that facade, I think you'll see the truth in Brian's statement. The past decade has seen the mercurial rise of applications on the Web. Most of the applications you use everyday have made their slow voyage to being online solutions. But Mac OS X and Windows Vista usher in an age of the resurgent desktop application. They help highlight the areas where the browser solution falls apart. I'm not for a minute suggesting that the web world cannot overcome some of the limiting factors (readability, offline applications, local storage etc.). But until a year or so ago, few would suggest that anything in the desktop world could stem the flow of applications into the web world.

With Windows Presentation Foundation (a .NET 3.0 component and part of Windows Vista), we've strived to blur the line between desktop applications and web applications. In many ways I see that as my charter and that of all my Application Model team mates. To developers, the same programming model used to develop a desktop app can be employed to develop a web app, or vice versa. To administrators, deploying the desktop app is about as simple as deploying a web app, taking the pain of installers away. To consumers, the richness and user experience one expects from the desktop world is now possible within the browser. Our work has just started though and we haven't achieved nearly enough.

Footnote: Miguel de Icaza, who has been known to be skeptical about WPF, now seems to be pleased with what we've done after he saw the New York Times Reader. Maybe we just do bad demos, and need to tone down the gratituitous use of animations, 3D and transforms. But the proof of the pudding is in the eating.

Tags: WinFX, NetFX3, WPF, XBAP, Mac OS X, Desktop

Web design patterns: Navigation

2006-10-03T22:28:00.000-07:00

I was thinking of web design patterns that may be candidates for controls for use in Windows Presentation Foundation (WPF) apps, specifically the browser-hosted application flavors (XBAPs). I figure I should list the ones that I think are prevalent on the web first.

Bread crumb bars
This is what got me started. Hua and I were talking about this sample she started working on. Bread crumbs tell you where you are within a web application or site.

Each label in this pattern is a hyperlink, making it easy to jump back to another level. This is especially suited for sites that have a structured hierarchy, usually 3 or more levels.

Bread crumbs tell users exactly how they arrived at the current location but do not tell a user where they can go from here.

Directory-based navigation
If your site or application has categories and sub-categories, this is a good way to display them to users and facilitate navigation. This gives users a broad overview of functionality offered by the app, and the ability to switch between items in the same category. Directories are not suited for sites or apps that have deep hierarchies (i.e. >2) or fragmented sub-categories.

Doormat
The Doormat is another pattern used to direct users to the appropriate section of the site. This works well if you have a small number of categories, with each having small number of sub-categories. The typical use of this pattern is on a landing page or home page.

Fly-out menus
The Fly-out has an old standard at Microsoft.com. It conserves space well because menu items are generally hidden, and when exposed the fly-out menus overlay the page content. These were made popular on the web mainly with DHTML where the menu functionality could be made fast enough to not be an irritant. These fly-out menus can be horizontal or vertical.

Horizontal and Vertical navigation
This consists of a horizontal bar with hyperlinks laid side to side. Usually appears at the top of a page. Use this when you want the navigation item to be visible throughout your site or app. The current page is usually highlighted on the horizontal navigation bar. The position of this navigation bar at the top of the page can be a hindrance if your page content requires users to scroll down.

When sub-categories exist, it is not uncommon to employ the double horizontal navigation pattern. The law of diminishing returns applies with each added level.

Another variant is the Vertical Navigation menu. These menus suffer some of the same disadvantages as their Horizontal cousins. However, their main advantage is in their scalability. Scrolling vertically is seen as less of an irritant as scrolling horizontally.

Tabbed navigation
Tabs extend the horizontal navigation menu concept further. They allow categorizing content where top level items are fairly static. They also provide visual cues that suggest ownership over a page's content. The double tabular form has two levels where the top level is static and the bottom level changes based on top level selection.

This post does not aim to be comprehensive. I hope it got you thinking about navigation paradigms. So in closing...

Questions to the WPF community:

Would you consider it valuable if there were high-level, native support for these navigation patterns in WPF? If so, which ones?

Would you like to create one or more controls based on these patterns? If so, drop me a comment. I'll be happy to post them to the WPF community site.

Are there other important navigation paradigms that I missed? Any that you'd like to see WPF versions of?

Tags: WinFX, NetFX3, WPF, XBAP, RIA, Web Design Patterns

How do I get the .NET Framework directory?

2006-10-02T07:54:00.000-07:00

Let's look at several ways to slice this one:

Hard code the path
Use %WinDir%\Microsoft.NET\Framework\v2.0.50727
This method is fragile and involves knowing the several things not least the version of the Framework. If you were looking for simplicity, say in the WiX configuration file, you might go with this. Otherwise, there are much better options available.

HttpRuntime.ClrInstallDirectory
If you're in ASP.NET or otherwise already have a reference to System.Web.dll, you may want to use the HttpRuntime.ClrInstallDirectory property. Otherwise, this may not be worth loading yet another assembly.

GetCORSystemDirectory
The GetCORSystemDirectory method, in mscoree.dll, returns the fully qualified installation dir of .NET Framework loaded into the current process.

HRESULT GetCORSystemDirectory ( LPWSTR pbuffer, DWORD cchBuffer, DWORD* dwlength );

pbuffer - [out] Buffer in which the runtime returns a string containing the fully qualified name of the installation directory of the runtime

cchBuffer - [in] the size in bytes of pbuffer

dwlength - [out] The number of chars returned in pbuffer

Of course, if your managed code file needs this info, you'll need p/invoke.

RuntimeEnvironment.GetRuntimeDirectory
My personal favorite. The RuntimeEnvironment class is in the System.Runtime.InteropServices namespace. I'd use RuntimeEnvironment.GetRuntimeDirectory() simply for elegant, readable and maintable code. Plus, it is in mscorlib.dll.

This post is by no means comprehensive. If you know of a better way to do this, please drop a comment.

Tags: NetFX, CLR, How to

Letting your users do your bidding

2006-09-29T07:16:00.000-07:00

When all you have is a hammer, everything looks like a nail. User-submitted content (user-generated content, to some) has its value, but is not the stuff that brands are made of.

NPR's business news show Marketplace, reports on Frito-Lay's and Chevrolet's plans on involving amateurs - like you and me - in the making of their Super Bowl commercials. Now this in itself isn't that remarkable; its been done before. But these companies hope to virally spread this ad campaign via YouTube, MySpace etc. Ostensibly this buys the commercials an extended shelf life online, which can be very expensive to achieve in traditional media.

But I think this is a recipe for disaster: you're driving the Chevy down a cliff with a bag of chips. A brand is built from an accumulation of experiences with a product or service. Advertising and design have great impact on the brand's image. Merely the user experience isn't enough: advertisers have long sought to appeal to you at an emotional or psychological level. When done right, this increases the brand's perceived value in the user's mind. This is why you covet your favorite brand over the dozens like it in the same aisle at the grocery store.

If you forgo editorial control over the brand's image, you risk losing the brand's equity - the value built up over time. For instance, what prevents someone from creating a parody of the product and posting it to YouTube as if to ride the competition wave. After all, you don't need to be Frito-Lay's official nominee in order to get eyeballs on YouTube. Chevy seems to have learned from its folly from last year's contest, which created numerous ads that criticized its SUVs for being gas guzzlers and contributing to global warming. This year they're asking for written ideas only and their professional branding guys will make the ads. Not being able to see and vote on others' submissions, well, is not really user-submitted content. Aww, does that break your product's buzzword compliance?

Why not just take the boring route of making good, entertaining ads that sell your message and then post them online with a liberal license on copying and reusing?

Tags: user submitted content, user generated content, advertising, social software

What's in a name?

2006-09-17T13:54:00.000-07:00

This past week it was announced that "Atlas", the cross-browser, cross-platform, web development technology will be have a few new official names as part of it's release:

Microsoft AJAX Library: the client-side "Atlas" javascript library
ASP.NET 2.0 AJAX Extensions: the server-side functionality
ASP.NET AJAX Control Toolkit: formerly the "Atlas" Control Toolkit

When I first heard this, I almost cried out "Why? Why? Why?". I thought Atlas was a cool name. Easy to pronounce, memorize and recall, and not offensive either. It was totally in the vein of "SmallTalk" and "Java". No, this was "Avalon" revisited!

Just as I sometimes jump headlong to conclusions, I am also capable of calm calculation. And I proceeded to do just that. I may be oversimplifying the problem, but I will say that the mechanics behind choosing a good product name are different for consumer products than for platforms and frameworks. You are not going to sell a technology to astute developers and decision makers based merely on its name. "Atlas" by itself wasn't very informative. But the terms "ASP.NET" and "AJAX" are more widely known, and tagging them along gives the audience clarity on what "Atlas" actually is. Although, one could argue there's one too many buzzword in there (and herein my bias against the term "AJAX" rears it's ugly head again!).

A name may be used be to inform the product's audience about it's function. For example, the "No Child Left Behind Act". However, this isn't a necessary condition for a name, and may sometimes even backfire on you as aforementioned piece of legislation allegedly has. On the other hand, using sterile, non sequitur names have proven to be very successful for some people. Take for example Toyota Camry. To a potential customer, the name does not hold any special sway. It does not highlight the virtues of the car or even how Toyota engineering places this car high among the most popular in the world. I doubt the car would be any less or more successful had it been given a different name. [Ref: my post on bad car names]

A cool name does not a cool product make. Prefixing an i to an everyday word does not automatically get you a fanatical following. You need to back it up with functionality and make it relevant to your audience. "Atlas" has seen over 250,000 downloads this year. That is a big deal for beta software. The number of people who downloaded this software mistaking it for content on Greek legends is likely statistically insignificant.

I won't lose sleep over developers running away in droves just because the new names are a tad, well, boring. Developers and decision makers care about breadth and depth of functionality, quality of APIs, extensibility, ease of use, performance and sundry other things. With Microsoft AJAX Library, ASP.NET AJAX Extensions and ASP.NET AJAX Control Toolkit, that remains unchanged despite the million more syllables added to the name.

But there are downsides too. There can be no advantage in making a name a mouthful for people to utter. The phrase spreading the word now no longer applies. People will soon seek acronyms and abbreviated forms to refer to the name. Case in point: WPF. And that just negates your branding efforts; plus your argument of making the name meaningful no longer holds.

I'm sitting on the fence on this one.

Achievement unlocked

2006-08-24T06:44:00.000-07:00

It is the little things in life that matter much. Yesterday, I successfully argued for a bug fix in the Windows Shiproom.

This was my first time in that august place and at first I was a bit overwhelmed. At 3pm I entered this large conference room which was already packed to the rafters and the meeting had just begun. At the center of the room was a large table with what seemed like 18 people - an assortment of architects, project managers etc. - seated around. No, Brian Valentine wasn't there although that'd have been the icing on the cake. I've never had the pleasure of arguing with him. Around the fringes of the room were about 10-12 more chairs, all taken. There were people standing and leaning against walls; others were seated, with some squatting, and still others like me with their feet stretched forward, getting in the way of people bustling into the room. If there was one common thread tying everybody in this room, it was that everybody had an opinion and was willing to let you have it. Good, I like it when they're aggressive. It tells you they care about what goes in and what stays out.

One wall was lined with clocks showing the current time in places around the world. There was a large map of the world on one side. None of these implements were used in the time I was there, but like in a tasteful B-movie, I thought they added to the ambience and elevated the importance of the place. An adjacent wall had a poster recording the "Longhorn build release counter" which listed the number of consecutive dates that a build has been released from the main Windows branch, compared to the all time record. The wall opposite the clocks was lined with several posters, each with a classic cop-out or explanation like "Oh, its only a one line change in the [manifest | XML file]" that the Shiproom has heard one too many times.

The Windows Shiproom is the final arena where your Windows bugs are approved or rejected. In the typical development cycle, your bugs do not get escalated to this level. But when the product - in this case Windows Vista - goes to escrow, it is effectively under lockdown, and only high value changes are considered by feature/component teams and brought up to the Windows Shiproom. Once these bugs are fixed and exhaustively tested, one goes to through the various Shiprooms for approval. In the case of this bug in question, that journey involved the feature team triage, dev changes and test work, the Avalon Shiproom, the .NET Framework (WinFX) Shiproom and culminated with the Windows Shiproom.

Aside from procedural questions and quality gates questions, one is asked for a problem description as an end-user scenario, the nature of the bug, the nature of the fix, the risk of the fix, the risk of not taking the fix, the amount and quality of testing that went in, etc. Most times at the local Shiproom, you are asked what other such problems could/will occur and what you're doing to prevent them. Because the playing fields and system interactions are so different between the feature level, the component level and the OS level, different sets of experts need to scrutinize the fix and give approval. This is especially important when the product is locked down and considered stable. Fixes that pose lowest risk to the product and highest value to customers are the ones that survive, while the others die by the wayside, at the feature team triage or local Shiproom levels. My bug came for consideration toward the end of the meeting and a couple minutes later the Shiproom gave its approval.

This couple hours was an important experience for me and taught me a great deal about shipping products. The motivations behind your decisions are different based on where you are in the product's development cycle. You do everything you can to make sure your customers have the best possibile experience. Only, it is manifested in different ways at different times. During active development, we go the extra mile to make sure a fix goes in. But when the product is stable and is ready to ship, one needs to take a measured look at what impact one's fix can have on all of the hard work that went in over the years. You're still being true to your customers. You're just showing it differently.

If life were an XBOX 360 game, I'd see the little notification message that says "nerddawg: Achievement unlocked".

Tags: WinFX, NetFX3, Windows, Vista, Avalon, WPF, ProjectManagement

Debugging Windows Presentation Foundation applications

2006-08-16T12:44:00.000-07:00

Windows Presentation Foundation (WPF) apps, like other managed code applications, can be built on the command line as well as within an IDE like Visual Studio. The Visual Studio IDE environment with "Orcas" tools provides for sophisticated debugging features. Since there are some nuances to debugging, I figured it merited a post. I will try to keep this live, as things change.

The F5 debugging

People familiar with managed code debugging will see that the process of debugging WPF apps, whether standalone or browser-hosted, is pretty much the same. Within VS, you hit F5 to start the app in debug mode.

WPF browser-hosted apps (XBAPs), unlike their standalone counterparts, do not have a main method in the application executable. They are therefore launched by PresentationHost.exe, an out-of-process document object host, which is the registered Shell and MIME handler for .xbap files. The XBAP project file lists PresentationHost.exe as the program that needs to be launched when you debug XBAPs (via StartProgram project property). The StartArguments property lists the command line parameters passed on to PresentationHost.exe. The notable item here is the -debug argument that tells PresentationHost.exe, "You are running in debug mode. Here's the XBAP you need to launch. Be a darling and don't induct it into the ClickOnce store".

There are some notable differences you need to understand:

When you debug an XBAP, your app is not ClickOnce-deployed; meaning, the app is not inducted into the ClickOnce app store. This allows you to rev your application without revving the version numbers.
Because of the above, the app will not return ApplicationDeployment.IsNetworkDeployed as true.
The app is launched from your project's OutputPath (bin\Debug folder) and that location is treated as the "site of origin" for the app. Any remote resources need to be manually placed at that location.

Debugging by attaching to a running process

This is like attaching to any other running program in Visual Studio, except that you attach to PresentationHost.exe, not the XBAP or its executable. Assuming you've set breakpoints in the source files, the actual debugging steps are:

From a command window run: %WinDir%\system32\PresentationHost.exe -debug
Within Visual Studio, click project Properties -> Debug
Check Enable unmanaged code debugging. Save your changes.
Click Debug -> Attach to Process
Select PresentationHost.exe from the available processes list
In the Attach To section, hit Select and check Managed Code and Native Code
Click Attach
Double click on the XBAP from your project's bin\Debug folder

The app will launch in your default browser. All your break points should get hit.

If you have multiple XBAPs running, make sure you attach to the right PresentationHost instance. It is easier if the XBAP being debugged is the only XBAP running. Also, the next time you want to debug the same XBAP, make sure you've cleared the ClickOnce app store (using mage -cc) or incremented the app's version.

Files at site of origin

If your app needs to access files or web services residing at it's site of origin, you can still use the F5 debugging method. Only, you need to tell Visual Studio to debug the app as if it were deployed from that location. Say, you have an app that is intended to be deployed from http://www.yoursite.com/apps/. Now, that location is deemed the application's site of origin. Suppose you have several data files and a web service running at that location, that your WPF app needs to access. You need to:

Navigate to project Properties -> Security tab -> Advanced button
Make sure the "Grant the application access to its site of origin" option is checked
Type in the location from where you want VS to believe the app is deployed. In our case, it will be http://www.yoursite.com/apps/
Click OK
Hit Ctrl+Shift+S to save all files
Close the solution (File -> Close solution)
Re-open solution
Hit F5 to debug

Steps 6 and 7 are required because currently these properties are applied only on project load. These actions modify the project's StartArguments property. Please do not edit its value separately.

Debugging XBAPs to be run within Media Center

Assuming you have the Media Center SDK and by extension the XBAP templates for Media Center installed on your development machine, here's how you debug an XBAP meant to run in MCE:

From a command window run: %WinDir%\system32\PresentationHost.exe -debug
From within Visual Studio, hit F5 to debug your XBAP

A .MCL file is created and the MCE Shell (ehshell.exe) is launched with this file name as parameter. You will see your XBAP load and all your breakpoints should trigger.

There are one issue you need to be cognizant about: While running or debugging your XBAP (created with the MCE template), you will notice that changes you made to the app are not reflected when the app is run. This is because the app run outside of VS was somehow cached in the ClickOnce app store (unlike with conventional XBAPs). You can work around this issue by incrementing the version number of your application, or by using mage -cc to clear your ClickOnce app store. Make sure the MCE shell is closed when you do this. Mage.exe ships with the .NET SDK or Windows SDK.

Happy debugging!

Tags: WinFX, NetFX3, Orcas, WPF, Avalon, MediaCenter, Debugging

WPF deployment errors and what they mean

2006-08-15T09:26:00.000-07:00

Platform Requirements Not Met

During deployment, the pre-requisites and references listed in the WPF browser application's (XBAP's) manifests are matched against the libraries accompanying the application (reference assemblies) or those installed in the Global Assembly Cache (GAC). If one or more references in the application manifest cannot be located, the "Platform Requirements Not Met" error is shown.

If you build your WPF app using one version (or CTP) of .NET Framework 3.0 but have another version on the client machine, you will see this error. In addition, you will see a "Get .NET Framework" button so you can download and install the right version of the platform in order to view the app.

Trust Not Granted

The "Trust Not Granted" error typically indicates the app is asking for more permissions than are available to it based on its deployment zone, or using features not supported safely in the sandbox. This is the sandbox refusing to run the app. As a workaround, I'd recommend running it from a different zone, say intranet or even Local Machine. If your app however does need to run in that specific zone (say, Internet zone), then you must re-factor the pieces of code that require elevated permissions or rely on features not enabled to run in the XBAP's partial trust sandbox.

Some time ago, there was a bug in the XBAP deployment mechanism of a .NET 3.0 CTP that resulted in the "Trust Not Granted" error showing up in place of "Platform Requirements Not Met", which shows up when your application requires one or more libraries not installed on the client machine. That has since been fixed but if you have older CTP bits of WPF on your client, you could be seeing the error because of this.

New Mac TV Ads. Not!

2006-08-11T17:47:00.000-07:00

Kam, Robbie, Jennifer and I were talking about the Mac ads, featuring John Hodgman and that other pretentious ass, getting heavy rotation on television. I love those ads! They make me wanna run and buy a new PC. Maybe I just identify with John's character. Well, apparently a few guys from The Best Week Ever had too much time on their hands and the result is this spoof on the said Mac ads. Here it is. Worth a look.

Touché!

Tags: Mac, PC, Advertising

The JSON RFC and JSONRequest

2006-08-07T11:53:00.000-07:00

The JSON RFC (4627) was recently submitted by json.org. They are also proposing a JSONRequest which will be similar to XmlHttpRequest but allow two-way XML data interchange with cross-domain access securely.

I think the RFC speaks of good tidings, but I have mixed feelings about the JSONRequest particularly since the Web APIs WG recognizes the problem and intends to support cross-domain access. Besides, does this model of having FooRequest and BarRequest for every little detail really scale?

Tags: JSON

Want to test drive Office 2007?

2006-07-27T19:06:00.000-07:00

If you want to test drive Office 2007 but don’t want to install it, try this. Requires Internet Explorer.

Otherwise, get the Beta here.

Tags: Office, Office12, Office2007

Sudoku

2006-07-27T16:34:00.000-07:00

I just posted an entry on the WPF community site for a sample that uses .NET Framework 3.0 technology to create a peer-to-peer version of Sudoku, the popular number logic game. This was originally posted by Shy Cohen on the WCF community site. Thanks, Shy.

It uses Windows Presentation Foundation (WPF) for its stunning graphics, Windows Communication Foundation (WCF) to enable P2P support and Windows Workflow Foundation (WF) powers the game generation logic. The package contains source code for both the standalone and browser-hosted (XBAP) flavors.

Tags: WinFX, WPF, WCF, Workflow, XAML, NetFX3

Is this the beginning of a trend?

2006-07-26T19:41:00.000-07:00

AOL's Netscape.com recently started offering to pay top contributors to major social news/bookmarking sites $1000 a month to contribute content at Netscape. As anybody who's participated in any community knows, a small percentage of members create content that is consumed by and benefits the vast majority of the community. This is aptly reflected in all things from content on Wikipedia and contributions to the Linux kernel. I think AOL made a smart business move for the newly redesigned Nescape.com; some would say predatory in its targetting of contributors to competitors like Digg and Reddit. In Jason Calcanis's words:

Before launching the new Netscape I realized that Reddit, NewsVine, Delicious, and DIGG were all driven by a small number of highly-active users. I wrote a blog post about what drives these folks to do an hour to three hours a day of work for these sites which are not paying them for their time. In other words, they are volunteering their services. The response most of these folks gave back to me were that they enjoyed sharing the links they found and that they got satisfaction out of being an "expert" or "leader" in their communities.

A lot of Web 2.0 -type pundits have deplored this move saying that people contribute content without monetary motivations. But this doesn't make sense to me. I'm sure these same critics do not work for free. This isn't about charity at all. It's business.

When you contribute content to one of these sites, they host ads and make money off of your content. Now if one of these sites offers to remunerate you for the time and effort, is it such a bad deal for you? Sure you love the props you get for flaming Micro$oft on Slashdot. But props with dollars to pay the bills are welcome too, right? Over the years, I've heard from many c0d3 hax0r colleagues, words along the lines of, "I can't believe they're paying me for doing something I love!". AOL's move will likely spread that cheer. I think this is a sign of things to come.

Tags: social-bookmarking, Netscape

Browser	DHTML	Flex	WPF/e	WPF
IE 6.0	56	61	84	99
Firefox 2.0.0.1	55	52	58	-
Opera 9.01	94	50	-	-

Even a chimp can write code

Of Crashing and Sometimes Burning

What conditions can cause crashes?

Further reading

A word on diagnostics

Four scores!

Can you access a loose XAML file from LoadComponent?

Well, why not?

How does one work around this?

Stepping outside the browser with Silverlight 4

Silverlight out-of-browser apps: Remove

Silverlight out-of-browser apps: How Updates Work

What the app author needs to do

Gotchas?

What the app publisher needs to do

Three Years and Three Versions

User-initiated operations in Silverlight

Silverlight out-of-browser apps: Local Data Store

What can you do with this power?

Internals

Quotas

Encryption

Gotchas

Saving files outside of Isolated Storage

Silverlight out-of-browser apps: Network Awareness

The API

What This Feature Is

What this Feature Isn’t

Gotchas

Silverlight out-of-browser apps: Launch

Application id

The app launch sequence

Was the app locally activated?

Silverlight out-of-browser apps: The Install

Silverlight out-of-browser support: What kind of apps can you build?

Connectedness

Fully disconnected app

Occasionally connected app

Connected app

User experience

App behaves exactly the same in browser and out

App shows different UI in-browser and out-of-browser

Approach

Porting an existing Silverlight 2 app to run offline/out-of-browser

Building a new offline/out-of-browser app

Introducing Offline and Out of Browser support in Silverlight

Search Engine Optimization for Silverlight applications

Silverlight 2 RC0: Here's what's new

Death, Taxes and Latency

Pages in Silverlight

How to tell a Silverlight assembly from a .NET Framework one?

Beta 2 of Silverlight 2 has just shipped

WPF 3.5 SP1: Don't let the SP moniker fool you

Silverlight 2: Layout and Rendering engines

How to tell the screen resolution from within a Silverlight app

Silverlight 2: Demystifying URI references for app resources

Transcoding media files for Silverlight

How to pass initialization params to a Silverlight 2 app

Silverlight 2: Application model

British Library's Turning The Pages project now in Silverlight

Unwrapping Silverlight 2

Free Microsoft Software for Students

Life at Microsoft

Olympics online coverage to be powered by Silverlight

Popfly: Now open to all

Nothing beats shipping: Silverlight 1.0 is here!

Tafiti - Search Visualization with Silverlight

Silverlight 1.1 controls from ComponentOne

Barry Bonds hits 756th homer

Silverlight 1.0 Release Candidate

nibbles: snack tutorials for hungry designers

Silverlight links

Outlook 2007 look and feel with WPF

Why is XAML case-sensitive?

Joel Spolsky's brush with Vista's SuperFetch

Eyes On Darfur

Google Gears and Silverlight

Everybody Hates The London Olympics Logo

Surface As Inspiration

Microsoft Surface: What WPF Can Do For You