David Treadwell On Longhorn, Managed Code, WinFX, IronPython, and VS2005 Whidbey Release Schedules

Just got off the phone with David Treadwell, Corporate Vice President of the .NET Developer Platform. Naturally, we started and ended the talk with the blogosphere’s current buzz about “.NET 2.0 Breaks Apps” and “Longhorn Isn’t Being Built On Managed Code.” Along the way, we touched upon languages, optimization, and the future of managed code.


Warning: This is “I didn’t have time to make it shorter“ stream of consciousness.


Is it scandalous that Microsoft’s next generation OS isn’t being built upon a foundation of managed code? Coming out of PDC ’03, it seemed like a set of boxes neatly fitting into each other: Longhorn will be built on top of WinFX, which will be built on top of Managed Code / the .NET CLR. But that never really could have been the whole story. Take Avalon, the new display stack: it simply couldn’t be the case that you could achieve those levels of graphics achievement (video streams mapped onto objects rotating in 3D space and so forth) within the realm of managed code. The CLR just doesn’t abstract the hardware to that extent.


Of course, as Moore’s Law marches on, it’s natural to think that we can achieve more functionality without necessarily modeling the complexity of the underlying hardware. For instance, maybe we don’t have to worry about individual pixels anymore when drawing text, maybe we have enough processing power now that we can draw a good-looking ‘t’ that’s really 14 points high without worrying about pixel density. So maybe you could move the operating system’s text subsystem into managed code. Maybe, maybe not. Flicker-free text (for instance) is not trivial, but if Microsoft stood up and said “In 5 years, the hardware will have gotten to the point where we can move all logic associated with text rendering into managed code. Of course, the final blt to screen will be handled by an unmanaged device driver, but that’s at a level where no non-games application developer will every worry about the unmanaged component.” I’d say “Okay.” And I think some people came out of PDC ’03 feeling that Microsoft did say that about everything.


But it never made sense. You cannot do Avalon-y sorts of graphics in a world where memory is an abstract concept; you can’t turn a videostream into a relocatable array of Color structs and map them into a dynamically sized array of Triangle structs while playing a sound constructed from a loop that’s calling Math.Sin(). The CLR doesn’t model on-board graphics memory and GPU capabilities and bus speeds and interrupts or lots of other things that make a difference when dealing with multimedia.


It’s always been a case of “How thick and how good are the managed abstractions?” For instance, Windows Forms does a great job of abstracting away Windows’ message loops and HWNDs and probably 99% of Windows Forms developers don’t have to deal with those unmanaged resources, even though they still exist. Some may not even know they exist and a sizeable percentage certainly don’t know the details. As luck would have it, I’ve been spending a lot of time dealing with Managed DirectX lately, a set of APIs where the abstractions are not nearly as thorough: you need to know about (for instance) message loops and you need to explicitly manage certain resources just as you once had to explicitly manage memory. Managed DirectX is hard. Not as hard as unmanaged DirectX, but hard enough to still be a barrier to some kid with a great idea for a game. To the extent that WinFX / Longhorn exposes APIs that have abstractions as powerful as WinForms, the cause of productivity advances. But if they just slap a managed wrapper around something and say “Ta da!” it’s not worth praising. “Managed” is no guarantee of productivity or comprehensibility nor does it inherently provoke innovation.


So what Treadwell clarified is that there are certain parts of Longhorn that will not even have thin managed wrappers. On the other hand, WinFX is “all about managed code,” so to the extent you work with Avalon or Indigo, you ought not to have to worry about P/Invoke or breaking out unmanaged C++. He said that WinFX is “our deepest platform bet on managed code,” and compared it to the bet they took with ASP.NET, where they achieved something pretty inarguably great. Of course, is API design in WinFX great or shabby? Are the unmanaged APIs for those portions of Longhorn that don’t have wrappers great or shabby? These are the issues, not whether those APIs are in or out of the CLR.


I used Managed DirectX as an example of a challenging managed API and he said look, WinFX is trying to hide things like unmanaged resource lifecycles but it won’t be 100% for 100% of developers in the first incarnation. Over time, more and more developers will be able to use more and more managed APIs to achieve more and more functionality. But that’s the only promise.


So if the concept coming out of PDC ’03 was the nice boxes fitting each other, now you have Longhorn as off to the side, but WinFX is still a box that holds nothing but managed code. As Treadwell explained, WinFX’s schedule is coupled to Longhorn’s schedule, but technologically, they’re not as coupled as they were (I can’t believe that Longhorn could be totally uncoupled technologically from WinFX).


I asked about the concern that Avalon and WinForms could create two developer “tracks,” each developing in a different paradigm. I wondered if one would be more appealing to corporate developers and the other more appealing to shrinkwrap. He didn’t go for it; instead, he insisted that the two are designed to work well together. He said that the first release of Avalon will not be as good as WinForms for certain things (and, of course, vice versa). There’s going to be a “longer transition” to Avalon. He said that it’s going to be a “case-by-case, capability-by-capability” thing rather than two clearly defined tracks.


“Realistically, the use of Avalon will be minimal in Office 12,” He said, although he mentioned that, for instance, SharePoint has managed components. He claimed not to know if Office 12 will have killer Tablet PC support. (Dammit. All I want to hear from someone is “Yes, Larry, you can write your novel in ink.” Speak to me, secret sources: lobrien@knowing.net)


Since we were talking about abstraction levels and so forth, I asked if the CLR had gotten to the point where it would begin to be the place where we see major innovations or if those were still strictly in the realm of native code. He said that for the foreseeable future it would “be at both levels.” He mentioned superfetch (aggressive pre-fetching of files into RAM according to system prediction, presumably using the same general family of algorithms used by CPUs) as something that’s fundamentally native and contrasting that with JIT technologies. (I asked about Phoenix and he perked up — it’s clear that’s coming along well — although Phoenix is apparently not inherently bound to either a native or CLR environment.)


Finally, I asked about IronPython. He said that Microsoft’s strategy for dynamic languages is “a little up in the air,” and they “don’t know what our [IronPython] strategy will be.” I said that although I loved IronPython, I would have preferred Ruby. He laughed and said he didn’t want to get into religious issues.


Oh yeah: he promised that Visual Studio 2005 will ship “later this year” and not in 2006.

$46B To Deploy $50B Of Technology

Tim Bray says that of $96B in gross revenue, IBM’s consulting services earned $46B.

This is one of those datapoints that could fit into a couple of preconceived notions: supporting the OS business model (“The money’s in consulting / support, not software sales!“), damning the OS business model (“If they used Windows, their TCO would be lower!“), supporting the OS technology model (“If only they used JBoss, it would be better!“), damning the OS technology model (“Linux is hard to deploy!“), etc.

I agree with Bray: What it mostly proves is that our industry is woefully inadequate in providing what is asked of it.

Visual Studio 2005 Pricing and Bundle Changes

Rick LaPlante just announced that:

  • A version of Team Foundation Server will be included with all role-based SKUs (no additional purchase)
  • MSDN/U subscribers can upgrade to Team Suite for $2300 and “Renewals continue at the promotional price for as long as you are an active subscriber.“

Once again proving: Larry speaks, Redmond trembles.

(Note to self: Write column on how XBox 360 should be bundled in MSDN Subscription)

Instant analysis: This is exactly the right move: they haven’t lowered the price on new sales, they’re rewarding existing MSDN/U subscribers, the exact “key influencers” hurt by the previous pricing, while hardly dinging their future sales profits. This is such the right move (Microsoft insults loyal customers, loyal customers scream, Microsoft changes behavior and rewards loyal customers, loyal customers feel all warm and glowy) that I’m sure the conspiracy theorists will say the whole thing was a … what’s the word or phrase? … “feint” isn’t quite it …

Whidbey Beta 2 Ate My Newsgator?

Anyone else experience sudden Newsgator flakiness after installing Visual Studio 2005 Beta 2? Suddenly, Outlook regularly puts Newsgator into it’s “disabled” list (Accessible via “About/Disabled Items”. I then have to restart to get Newsgator back running, but it’s prone to disappearing again.) Also, it looks like my posting plug-in has broken.

Microsoft Reverses Stance on Diversity!

Steve Ballmer concluded that: “diversity in the workplace is such an important issue for our business that it should be included in our legislative agenda….Accordingly, Microsoft will continue to join other leading companies in supporting federal legislation that would prohibit employment discrimination on the basis of sexual orientation – adding sexual orientation to the existing law that already covers race, sex, national origin, religion, age and disability. Given the importance of diversity to our business, it is appropriate for the company to endorse legislation that prohibits employment discrimination on all of these grounds.”

a) Bravo for Microsoft.

b) The one thing that most impresses me about Microsoft is their ability to recognize mistakes and reverse course. The most stunning technical example, of course, was the Internet turn-around of 96-97, but this is comparable. This decision is not going to be painless for Redmond — they will get grief from the well-organized and vocal hate-mongers (I wish I could draw, because I could get dozens of cartoons from the prospect of evangelical and Linux zealots attempting top band together).

c) Ctl-A, Ctl-Delete on a column that I’d just finished…

Getting Things Done With OneNote Flags

Chris Pratley has a great blog entry on Note Flags in which he discusses “the awesome power of Note Flags Summary.”

I thought I’d supplement that with my “Getting Things Done”-inspired OneNote organization. First, I’ve customized my Note Flags to be color-coordinated and GTD-like:

Second, I organize my notebook into “areas of concern.“ The idea is that these are things that involve multiple projects, especially if they’re concurrent. Sub-notebooks are used when I generate a lot of notes and projects. (“Getting Things Done“ defines a ‘project’ as anything that requires multiple steps to accomplish. Managing a lot of concurrent projects is the essence of the GTD system.) Here, you can see my catch-all “General,” section, my “Arcs of Fire” sub-notebook, and some others:

The first page of each section is an “Overview” page. Every project in a particular area of concern goes on this page (marked with a Note Flag as “Urgent,” “Ongoing,” or “Deferred”). I may also have stand-alone tasks marked with “@Next Action”, “To Do,” and “Someday / Maybe” here, but in general, stand-alone tasks are placed, as they occur to me, on whatever page I happen to be working in. This is my “Overview” page for this Website (as you can see, big plans, little time):

I use the “Note Flags Summary” taskpane to gather and sort all of my tasks and projects (note that they’re color-coded as well: green means “Urgent Project” / “Next Action, blue means “Ongoing” / “To Do”, yellow means “Deferred” / “Maybe”). Note that tasks can be marked as done directly in the taskpane, a nice touch. Also note that ink shows up in the summary! Here’s my current next action list, mostly blurred, but showing my next actions in my “Birding“ and “SCUBA Maintenance“ projects (both part of my “Recreation“ section)

Part of my weekly review is tidying up all of my notebooks and rejiggering all of the projects and to-do’s (Ctrl-0 clears all note flags, so I can typically re-prioritize something with two chords: Ctl-0, Ctl-1 makes a task “Next Action,” for instance). I still haven’t figured out the optimum way to deal with completed actions. Some subnotebooks have a “Recycled” section. Other times, I just delete them. Sometimes, I just leave ’em (since the Note Flags Summary taskpane filters them out).

I’ve been using this as my main organizational tool for about six months now and find it quite effective. Of course, there are improvements I’d love to make, but OneNote doesn’t have a powerful enough API (yet?) for that. One improvement that I know is possible within the constraints of the current API is automatically importing voice notes from my SmartPhone (It’s a “Someday/Maybe” project in my “Sofware Projects” section).

Criticisms and improvements highly encouraged!

Moore’s Law Footnotes

I just wrote an article on Moore’s Law (it’s not available online yet). I ran long and am using this as a “one-to-many” footnote link: