DevSource: In the years that you have been a developer, what are the biggest changes you've seen? What's totally different about the development process now? What do you wish had changed, that hasn't?

Sells: I've been programming for 22 years, and have seen remarkable changes in one key area: productivity. Comparing the tools, libraries, runtimes, and development environments that were available when I started, to those available now, is like night and day. The sheer amount of functionality and robustness in today's applications (as compared to the number of lines of code you have to write yourself) has to be several orders of magnitude different. On the other hand, the expected functionality for an average application has increased faster than the increase in productivity, which is why software schedules continue to get longer.

And this leads to the thing that I expected would have changed in the last 22 years: the need to write code at all. Since the first time we started given instructions to computers, we're still doing it the same way, using textual programming languages. We've still got quite a bit of productivity to gain from an increasing library of components and controls, but to really get to the next level, we're going to have to stop hand-crafting streams of characters. Originally, I thought that code generation would take us there. It can help a great deal, but we need some better way to add new capabilities to our computers, other than writing programs, to really break the log jam. Unfortunately, I don't know what that next thing is, but I have high hopes.

DevSource: What about programming do you hate? What about the development process makes you think, at least for a moment, that perhaps this would be a good day to de-frag your hard disk instead?

Sells: The thing that I hate about programming is rewriting a piece of software that's already been written. In my world, every single domain-neutral feature that has ever existed in any application would be available as a component that I could drop into my applications. I like writing code to do new things, but am just too lazy to appreciate writing something again.

Of course, I understand the need for vendors to actually make money on their unique software, so I don't see my Utopia happening any time soon. Still, the huge amount of freely and commercially available libraries that do a ton of the most popular features continues to amaze me, and benefits my personal productivity enormously.

DevSource: What do you see as the benefit to the Longhorn stuff you're doing now?

Sells: The benefit of what I'm doing is to understand Longhorn so that I can explain it to developers. My current thinking on the benefits of Longhorn breakdown into five areas:

• Presentation, a.k.a. Avalon
• Data, a.k.a. WinFS
• Communication, a.k.a. Indigo and RTC
• Fundamentals, like security and deployment
• User Experience, a.k.a. Aero

The level of additional capability for presentation developers in Avalon are at the same level as when we first got desktop publishing, or when we used to get a new HTML feature every other week. Avalon removes the artificial boundaries between applications and documents, between static and dynamic content and between text, media, and controls. Everything about interacting with the user is so new, in fact, that we're not even sure yet what we should be doing with it all. I'm sure that the first few real applications that Microsoft builds that target Avalon will be cool, but it's the stuff that'll be really off the wall, after Avalon has had a chance to sink in, that I'm looking forward to.

As enabling as Avalon is for presentation work, WinFS is just as enabling for developers managing the data that their applications. In the PDC build of Longhorn, WinFS provides a set of hundreds of types that can be shared and manipulated in their serialized state by any number of applications, breaking down the barrier of forcing each application to create and track common data like Contacts. In the future, when WinFS provides extensibility, applications will be able to define their types for use in this common pool, gaining access to the ability to share their data, make it accessible to the shell and to get the rich set of WinFS features, such as synchronization and notifications. And while WinFS provides these new capabilities, it does so while requiring less code, because while WinFS stores the data relationally, it exposes it as a set of objects, making it a natural fit for .NET programmers and removing the need to perform the object-relational mapping that so many developers spend so much time on today (and that keep codegen tool vendors in the green).

On the communications side, Indigo and RTC are evolutions of current APIs. Indigo is a refactoring of COM+/Enterprise Services, .NET Remoting, ASP.NET Web Methods and MSMQ into a single, cohesive whole, letting developers mix and match the features that they want, e.g. security, reliable messaging, transactions, sharing types, sending messages, request/response, routing, one-way messaging, asynchronous messaging and a host of others. But you don'thave to switch programming models to get it, e.g. from .NET Remoting to COM+, to gain transaction support. The Real-Time Communication (RTC) stack in the PDC bits is a wrapper around the existing COM stack, but will expand to include a set of components and controls to enable peer-to-peer, instant messaging-style features in your own applications.

Of course, these new features aren't much good if they aren't secure and if they can't be deployed, which is why Longhorn will provide a secure environment in which to run applications and an even more secure way to deploy and run applications seamlessly, called ClickOnce. ClickOnce first debuts in Whidbey, and will be integrated tightly into Longhorn.

And how do developers know how to put all of these features together and present them to users in the “Windows Way”? Figuring that out, putting those practices to use in the shell and communicating the new way to interact with the user in Longhorn is the job of the Aero team. The Aero team is in charge of the Longhorn User Experience (UX) and is still figuring out just how they want Microsoft and our customers to use all of these capabilities, but they published their current thinking at the PDC.

In fact, it's my job to capture the current thinking of all of the team on Longhorn, including Avalon, WinFS, Indigo, RTC and Aero, and publish it on the MSDN Longhorn Developer Center Web site, which I encourage you to visit.

Do you have questions of your own? For the next few days, Chris Sells will be visiting the DevSource discussion forum. Post a question of your own!