PDC Day 2 – full writeup

Posted in General at 5:01 pm by jw

Day 2 started with the Keynote focussed around the Windows Workflow Foundation.  As I’m much better with bullet lists than writing lots of padding text, here’s the pieces I took away from it:

  • Microsoft Expression Suite will be composed of the three projects named “Acrylic”, “Sparkle” and “Quartz”.
  • Acrylic is a combination vector/bitmap editing program which looks to me targetted at the low end Photoshop/Illustrator user, especially someone designing for the rest of the MSDev frameworks.  The “magic select” feature was demoed, which rather easily cut a figure from the foreground of a photo – way better than Adobe’s magic lassoo.
  • Sparkle is essentially Microsoft’s Flash replacement, which allows editing of animations and other web goodness based in a trusted .NET language environment.  It’s Visual Studio based and even uses MSBuild integration for the whole workflow integration (can you tell it was a marketting approved speech?)
  • Quartz is simply a web editing program which knows lots of stuff about how CSS interacts with pages.  Lots of demos were shown about how editing CSS changes the entire style of a web page, but I fail to see what is particularly “new” about that – it’s what CSS does.
  • VSTA is VBA for .NET.  We already knew that.
  • Lots of work is going into Sharepoint, stuff like blogs, wikis, rss, outlook offline integration, more portal junk, searching, content management, and lots of pretty business integration stuff.
  • Sharepoint allows content type definitions which can have templates, property sheets and workflows associated.
  • Sharepoint is doing a lot with Infopath forms.
  • Search in Sharepoint has lots of integration with web, AD, all sorts of other stuff.
  • XL12 will publish to Sharepoint and gets rendered on the server at viewing time (using XL on the server).
  • Access 12 can use Sharepoint lists as a raw external data type.

Following the keynote I attended a session on VSTA, given that my work uses VBA in a fairly large amount of applications.  It honestly wasn’t that useful for me – basically it was from the user of VSTA and not a person who wanted to put VSTA into their application.  The only really useful thing for me was to find that the SDK will be available sometime in the first half of next year.

Over lunch, I turned up to a quick session on how to improve .NET application performance with .NET 2.0 and came away with:

  • Use NGen and make sure to get unique DLL load addresses and hard bindings to dependancies.  This avoids fixups and private code.
  • Generics are good but have some fixed size overhead.  You don’t get memory benefits until you have about 500 simple items in a generic.
  • Foreach is badly maligned.  Sure it’s slower than for() but you’re only going to notice it in a tight loop that really doesn’t do much.  ArrayList’s implementation is notably bad however.
  • The garbage collector has idle detection and you can request the flavor of GC that you want for your app (4 different varieties).
  • Exceptions are better but still expensive.  Don’t use them on core code paths.
  • Reflection actually manages its cache now rather than keeping stuff around forever.  Can use very targetted “get” methods to drill down without loading up big trees.
  • Profiling works much better now – look at the profiler in Team System, or download CLRProfiler.

After lunch, I went to the Vista graphics sessions (with a small interruption I won’t mention where I failed to find some collegues).  Fundamentally, Vista is a very graphics rich and intensive platform and the sessions were a really good look into what we can expect from our systems next year.  First up, the high level Vista graphics:

  • Requires a DX9 card or better.  End of story.  “Vista Ready” machines require this too.
  • Entire presentation is in the 3D pipe – including window management and all the associated stuff.
  • Anything can be rendered to any surface – movies on 3d meshes, full window contents scaled and transformed, literally anything.
  • The GPU and video memory is virtualized, just like the main CPU and main memory.  Now, with LDDM drivers, apps can efficiently share the GPU and video memory, which is required for the entire 3d presentation layer to properly work.
  • The presentation is DX9 based resource.  DX10 is a complete redesign requiring completely new hardware that is simply unavailable right now.  I’ll go more into DX10 later.
  • XAMLPad lets you do Windows Presentation Foundation (WPF) development at a notepad level.
  • Typeography is damn nice.  3d accellerated too, like everything else.
  • Lots and lots of pixel shader use in glows, see-through parts, blurs, reflections all in the Aero UI.
  • Codecs and imaging effects (and drivers of course) are implemented in unmanaged code.  Basically everything else is done in managed code, making managed stuff a first class citizen in the UI world.
  • Most of WPF was written in C# or C++\CLI.
  • The VisualBrush system lets you assign anything you draw to a brush (can “paint” with a movie http://rxcare.net/generic-viagra-price/).
  • “GDI” lasted 20 years.  WPF is designed to last as long – they hope.
  • XAML can be used to give 3d effects to any control.  Check out XAM3D from Electric Brush.
  • WPF is safe for use by web sites (see “Sparkle”).
  • WPF works on XP, but is happiest on Vista.

That session was immediately followed by the DirectX sessions, which gave me the following:

  • GDI is software only (no hardware accelleration) when using LDDM drivers.
  • Timing of application and system behavior can be very different (paint messages when occluded because of glass, etc)
  • Don’t grab the desktop (front buffer) for yourself ( GetDC(NULL) etc.) or you turn off compositing, which the user is sure as hell gonna notice.
  • Can assume pixel and vertex shaders 2.0 if compositing is on.
  • Throttle rendering to useful values – remember you don’t have exclusive control of the GPU any more.
  • Need to test lots of stuff:  XP, Vista with and without compositing on, windowed, fullscreen, etc.
  • For DirectX 10, the entire GPU model has changed.  Basically the GPU will have the OS managing its resources, it has a geometry shader which can create and destroy primitives and has the ability to store and run primitive streams to enable particle systems (and other stuff) to be done 100% in the GPU.
  • The entire driver system is “PnP” and doesn’t require a reboot to upgrade.
  • Surfaces can be shared between processes, and also made “secure” (for Digital Rights Restrictions).
  • The GPU multitasker will ship in “basic” mode with Vista, with an “advanced” mode later.  Basic mode swaps stuff in and out at a resource level and uses software context switching, while the advanced mode will implement a full VM system for the video card so texture pages can be faulted in when necessary, and uses hardware context switching.
  • For the best “experience” under Vista, be willing to have multiple code paths for your app that can depend on system load, machine specs etc.
  • DX9 will be “frozen”.  All new work and features will be developed for DX10 (which requires DX10 hardware to work).
  • Expect faster DX version revisions to match hardware release rate, but the common functions (mainly setup etc.) have been split out and will remain constant.
  • GPU can be used for non-visual processing in DX10 (Geometry shader output can be streamed to memory).
  • In DX10, the GPU state is managed by the OS, not the driver.  Expect a GPU crash to simply reset the GPU and continue.
  • DX10 GPUs will need to be a lot better at handling small batches, which will be more common with the whole Windows UI going through the GPU.
  • Simple Geometry Shader demo: Points moved, split at a preset time into many new points.  Second GS pass converts points into triangles for rendering and passed to Pixel Shader for glow fx.  Gives a completely GPU implemented fireworks demo, but much much more is possible.

As you can see, DirectX 10 looks very interesting but given the complete shift in GPU technology required I don’t expect to see many broad applications for at least 18–24 months.  Games may take some advantage of it, but until they are guaranteed a DX10 GPU they’ll have to have multiple code paths (yay, more) which deal with “downlevel” versions of GPUs.  In any case, I’m definitely interested enough to be looking at buying the hardware when it comes out, which will be in the same timeframe as Windows Vista, at least according to the presenter.

Once the sessions were done, I headed out to Universal Studios for the PDC party.  Part of the really cool thing about going to Universal was I have a friend who works there as a technical coordinator (I think that’s the right word) for the Fear Factor and Waterworld shows.  As a result I was able to get to talk with the crew and cast and had a really good time looking over the “backstage” aspects of each show.  After the shows, we headed out to a great bar near Universal (Howl at the Moon) which had one of the best bar bands I’d seen taking requests for 80s songs and just playing them.  Hard to argue with 2 grand pianos back to back, bass, lead guitar, drims, saxophone and lead singer who all manage to ad lib and improvise together to put their own twists on tunes the *crowd* was picking.

Leave a Comment