Programming Windows: The Windows 7 Developer Story (Premium)

After the first public demonstration of Windows 7 at PDC 2008, Steven Sinofsky ceded the stage to Scott Guthrie for a tour of new developer features. Guthrie, as always, arrived with an in-depth understanding of the content he was presenting. But after the revolution that developers had received with Windows Vista, the Windows 7 developer story was decidedly minor.

On the one hand, this wasn’t surprising: since releasing the Windows Presentation Foundation (WPF, formerly Avalon), Windows Communication Foundation (WCF, formerly Indigo), and Windows Workflow Foundation (WF) alongside the .NET Framework 3.0 (formerly WinFX) alongside Windows Vista in 2006, Microsoft had understandably shipped only minor updates to each. For example, .NET Framework 3.5 shipped in November 2007, providing integrated support for Language-Integrated Query (LINQ), a new way to access backend data sources using .NET languages like C# and Visual Basic rather than forcing the developer to learn Transact SQL or whatever interface was native to the data source.

But the software giant was also experiencing a troubling new trend. For the first time, the adoption of its latest Windows platform technologies had moved slowly, with few major new apps built on modern frameworks and SDKs (software developer kits). And though we later came to understand that a shift was then starting, and that most new app development was shifting to the web and mobile, it was unclear whether developer fatigue from the ongoing Vista drama had triggered a one-time blip. Or perhaps there were just too many choices, between classic C/C++ (Win32), C++/Microsoft Foundation Classes (MFC), classic Visual Basic, .NET/Windows Forms, and now .NET/WPF, causing most developers to simply stick with what they knew best.

Regardless of the root cause, the outcome was the same: there would be no major new developer initiatives with Windows 7. Instead, the developer story would follow the same iterative path that Steve Sinofsky had ordained for the platform itself. And Microsoft would simply make the new APIs (application programming interfaces) for the new Windows 7 functionality available across Win32, MFC, and WPF, letting developers again stick with the technologies that they were already using. This was arguably a good thing: as Microsoft would later discover, bifurcating the developer audience and only making new features available in select environments didn’t work out well for them either. But it also led to a further stagnation of its newest—and, inarguably, best—developer tools, like WPF, at a time when developers were already starting to look elsewhere.

“You can take advantage of the new Windows 7 features regardless of the languages you use,” Guthrie began. “You can use C++ and Win32, [and] you can also use managed languages with .NET. We’ve also focused a lot on interop, and [to] making it possible [for] developers to build applications combining both managed and native code together. And this gives you hopefully the flexibility to make the language choices you want, based on your existing code and investments.” Microsoft, he said, would ship new APIs in the Win32 SDK, via an update to MFC, and via an add-on for .NET 3.5 Service Pack 1 (SP1), which had been released that past summer and would be included in Windows 7.

His first demo was a photo viewer application written in WPF and originally targeting Windows Vista. As such, it would run normally in Windows 7, Guthrie said, but he added some new Windows 7-specific features to it on stage, starting with a ribbon.

Historical sidenote: Technically, the ribbon control that was made available to third-party developers was called the scenic ribbon to differentiate it from the one provided in Microsoft Office.

“What I’m going to do is basically change my root window [in XAML] from being the base window object to being a … ribbon window object,” he began. This is exactly how you still make a ribbon-based application with WPF today, as it turns out. (With the downside being that the ribbon control hasn’t been updated in several years either.)

He then went on to create multiple tabs for the ribbon, each with specific buttons representing application commands. “The ribbon control will tie into the standard WPF commanding architecture, so I can, in my code behind or in a separate class, easily handle commands as those buttons are clicked, as well as hide or show the commands automatically.” He added back and forward buttons that tied into the app’s history management.

What Guthrie neatly stepped around was the fact that ribbon development required—and still requires—a metric ton of XAML source code to accomplish anything approximating the complexity of the ribbon interfaces found in Microsoft Office. So, instead of typing all of the code by hand, as Don Box, Chris Sells, and Jim Allchin had done at PDC 2003, he pasted in pre-made source code, as Box, Sells, and Guthrie had done at PDC 2005. In this case, that was understandable.

With the additional source code pasted in, Guthrie showed off a more complete ribbon with additional tabs, including contextual tabs that would only appear in certain conditions, and many more buttons and related commands. It also took advantage of what Guthrie called WPF’s skinning capabilities, letting the app switch between, say, light and dark themes on the fly.

I will examine ribbon development in a future article in this series, but it’s worth pointing out that the WPF ribbon control didn’t require Windows 7: apps that used it would work fine in Windows Vista as well.

Next, Guthrie showed off how to add a jump list—which he described as a list of “contextualized tasks” that were accessible via the taskbar—to an application, also in WPF. In this case, the feature was supported via the app’s XAML file rather than the main window’s. And Guthrie didn’t write or even paste in any code; it had been added to the app ahead of time. Unfortunately, this demo didn’t really reveal the true power of jump lists, which can change dynamically—similar to contextual ribbons—as needed.

With that out of the way, Guthrie moved on to multi-touch support. And not only was the code added ahead of time, attendees didn’t even see the code. Instead, he showed it off using a version of the same app running on an HP TouchSmart PC, a new type of all-in-one PC that was basically a big touchscreen display on feet. As Guthrie explained, multi-touch support in WPF arrived via a set of new touch and multi-touch events that could be handled like any other events. (The nice thing about multi-touch support is that the basics were essentially “free” in that a tap would register as a click and so on, but developers could also explicitly handle specific touch events and more complicated gestures.)

Then, Guthrie provided a quick preview of the .NET 4 Framework, which Microsoft wouldn’t actually ship until April 2010, or roughly 18 months later. This major release would include lots of improvements to WPF, including deeper multi-touch support and Deep Zoom support (from Silverlight, a light version of WPF designed for creating interactive web apps). But with .NET hitting its fourth generation, Microsoft was also keen to fix some of the fundamentals, which had grown to include problems associated with using multiple .NET versions on the same system.

“With this release [.NET 4], we’re going to allow you to load both [Common Language Runtime] CLR 2 and CLR 4 in the same process,” Guthrie said, alluding to the fact that .NET 3.x versions still used CLR version 2. “That means, if you have an add-in, for example, that was built with a previous release, rather than always have to roll it forward to run on the most recent CLR release, you can now load it at the same time and use a different [version of the CLR] in the same application.”

.NET 4 would also improve the interoperability of managed (.NET) and non-managed code, making it easier to access both COM objects and Win32 code (via P/Invoke) from .NET code. And Microsoft was actually rebuilding the next version of its integrated development environment, called Visual Studio 2010, using WPF. This announcement was met with applause—Microsoft’s developer audience likes to see the company use its own technologies—but it was also a bit of an exaggeration: as a componentized, legacy application, Visual Studio, like Office, is built with multiple types of software components and only the UI of the core application—including its source code editor—was redone in WPF. (Visual Studio 2010, like .NET 4, would not ship until 2010.)

From there, Guthrie moved into developer topics that had nothing to do with Windows 7, including Visual Studio extensibility, various improvements for web developers, and a new Silverlight designer for Visual Studio.

And then Microsoft corporate vice president David Treadwell emerged to discuss Live Services, the part of the new Azure Services Platform that included Live ID for website authentication (formerly .NET Passport), a context API for what Microsoft called the social graph, Windows Live Messenger instant messaging integration on websites, and search and geospatial capabilities. This was clearly a more subdued follow-up to Microsoft’s failed Hailstorm initiative from years earlier, but it was based on open standards and protocols and was thus more interoperable with the broader world of web development.

And the keynote wrapped up with what many thought was a long-overdue announcement: Takeshi Numoto revealed that Microsoft was releasing web-based versions of its core Office applications—Word, Excel, PowerPoint, and OneNote—as part of the Office 14 wave.

That was all very interesting, but those developers who wished to focus on the new features in Windows 7 beyond the few that Guthrie had demonstrated—the ribbon, jump lists, and multi-touch support—would need to carefully choose which sessions to attend during PDC 2008 or turn to the documentation. And there were a few more interesting features available, including:

Taskbar icon. In Windows 7, apps that needed to display some kind of progress—like file copy in Windows Explorer—could display that progress in their taskbar icon, allowing users to see how long a time-consuming task would take without keeping a window displaying that information visible. App icons could also display an overlay icon to indicate status information.

Thumbnail APIs. Microsoft introduced thumbnail displays for application windows when the user moused-over their taskbar icons. But in Windows 7, these thumbnails were interactive, and developers could create small toolbar so that users could access app features—like Play and Pause in a media application—without needing to bring the app window to the foreground.

Improved gadgets. In Windows 7, apps could programmatically add a gadget to the desktop during setup or first-run.

Animation framework. Windows 7 supported an animation framework for managing, scheduling, and executing animations.

Libraries support. Windows 7 finally delivered on the virtualized file system capabilities that Microsoft initially promised in Windows Vista, and it replaced static special folders—like Documents—with virtual folders called libraries that culled their contents from multiple physical folder locations. A Libraries API let developers create applications that could create and interact with libraries.

DirectX improvements. Windows 7 extended the Desktop Window Manager (DWM) technologies from Windows Vista to include Direct2D (2D graphics), DirectWrite (text), Direct3D 11,  and, on LCD displays, color depths greater than 8-bits per color.

Media improvements. Windows Media Foundation was improved in Windows 7 to support MPEG-4 (including H.264) and new types of hardware (including webcams), and there were new higher-level APIs for accessing this functionality.

Windows Biometric Framework. Microsoft laid the foundation for Windows Hello with the Windows Biometric Framework (WBF), an API for developers who needed to authenticate users a fingerprint reader or other biometric hardware.

Sensor platform. Windows 7 natively supported sensors, including ambient light sensors, temperature gauges, and location sensors like GPS devices (using a new Location API).

And that was about it. Windows 7 would be presented as a major release throughout its development, and it would go on to be marketed that way as well. But it was nothing more than a minor, evolutionary update to Windows Vista, one that in the past might have been released as a service pack. But this was the new Microsoft. And for now, at least, Steven Sinofsky would have his way and steer the platform towards a more reliable, but far less interesting, future.

Unrelated, but I got to meet Microsoft legend Raymond Chen at PDC 2008: