Archive for September, 2005

09.15.05

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.

PDC Day 2 (short version)

Posted in General at 5:41 am by jw

DirectX 10.  Watch this space for more details.  Blame Reyek for taking me out to this awesome bar for the lack of updates…

09.13.05

PDC Day 1

Posted in General at 4:01 pm by jw

The keynote, as expected, was a pretty amazing show.  I’m sure the video of Bill Gates and Napolean Dynamite will become somewhat of an internet classic, probably even more so if someone cut/pastes it up.

Some of the more interesting points:

  • Office 12 and Windows Vista will be released in the same timeframe, currently H2 ‘06.
  • Vista has a gadgets bar on the right which is extensible, much like some of the stuff Apple did recently with Tiger.
  • IE7 is tabbed (which we already knew), but in addition it includes “quick tabs” where it tiles a preview of each tab on the screen and lets you choose between them.
  • IE7 has “shrink to fit” printing, and quick buttons to remove the header/footer if you want.
  • The RSS store IE7 uses is actually a part of Vista and accessible from any application through standard APIs.
  • Office 12 has a new interface paradigm, with menus replaced by tabbed toolbard much like 3d Studio Max.  It also has all sorts of pretty GUI junk that managers will just die for.
  • Outlook 12 has tasks better integrated with “flags” on emails and other tasks throughout the OS.
  • Outlook 12 has native RSS integration.
  • Outlook 12’s search is integrated with the Vista search features.
  • Outlook 12 will download Sharepoint documents for offline usage.
  • Sharepoint will act as a store for all office documents and allow all sorts of advanced file sharing (demo was sharing individual powerpoint slides through Sharepoint).

From Jum Allchin’s keynote:

  • Jim still can get an XT running with Windows 1.03 on it.
  • The PC will always be ahead of the game consoles, in Jim’s opinion.
  • There was a demo of Crytek’s efforts with Vista/DirectX 10 which allows some pretty amazing graphics from what appeared to be their new Far Cry engine (trees all have detailed shadow, etc.)
  • Vista does all sorts of cute 3d stuff with the windows.
  • The default user on Vista is not an administrator – this can very well break stuff but at least it makes it more secure.
  • “Superfetch” is a really cool technology that will use unused memory on the system to prefetch applications based on prior usage patterns.  It will even load stuff onto free space in a USB Flash Disk for faster loading…
  • Vista provides a configurable sandbox for applications which can prevent IE, ActiveX controls, or pretty much anything from accessing parts of the filesystem or registry.
  • Infocards is Microsoft’s new Passport effort, which is a front end to any internet or local identification system, including Passport’s competitors.
  • The “People Near Me” service looks kinda cool, but really like an extension of NetMeeting which allows P2P connections for files etc.

Don Box and some of his lackeys gave a presentation on LINQ, Atlas and Avalon:

  • SQL-style queries are native withing C# (and I assume other .NET languages), which can span data sources which includes any IEnumerable element.
  • Indigo wires up easily with these queries.
  • A bunch of demos showed all the cool stuff you could do with very little coding.

Following lunch, I went to the breakout sessions.  First was a cool tutorial on writing a compiler for .NET, which was really interesting but not at all worth writing stuff about in the blog.  The next talk on monad was incredibly good though, and makes me really keen to get a hold of it and try it out:

  • Monad is the new command line shell for Windows (will probably be called Microsoft Shell or ‘msh’).
  • Monad provides an incredibly flexible interface which uses an object I/O model instead of the standard stream based I/O.
  • The Monad object system is fully extensible by third parties through the use of Cmdlets and Providers.
  • Cmdlets are command that run in the monad pipeline (like “ps”, “where”, “sort”, format-table” etc.)
  • Providers appear as “drives”, which can be registry hives, databases, WMI trees, environment variables.

Windows Storage advances in Vista:

  • NFS will be part of Windows.
  • Symlinks will be fully implemented in Windows Vista and Longhorn Server.  The only issue is that if you aren’t using Vista/Longhorn on both client and server (assuming symlinks are on a shared folder) then you won’t be able to use those symlinks.
  • Remote Differential Compression allows syncronization from any Vista/Longhorn machine to any other and does so without copying entire files (does diffs with minimal network bandwidth).  Great for keeping folders synchronized between two machines.  This technology will be ported to the DFS copying system as well.
  • Transactional support for file read/writes and registry read/writes that can participate in any distributed transaction.

Was a long day today with lots of stuff I had to go through.  Picked up the PDC ‘05 build of Windows Vista which I’ll probably put onto my laptop at some time in the future.  Some of the stuff does make me think Vista will be a good platform after all for upgrading to.

PDC – Preconf Day 2

Posted in General at 3:01 am by jw

I had this big thing half typed up.  Then I put my machine into hibernate to save the battery and it froze when I started it up again.  It’s been doing that a lot lately – guess it’s time to install Vista so I get a fresh system.  I’ll try to write it out again, but that’s probably a good thing as things are always better the second time around.

Today I spent my time going to the Visual C++ Internals conference.  It was kicked off by Stanley Lippman, who was basically the original C++ developer after Bjarne Stroustrop.  His history of the C++ language and definitely the number of anecdotes of those times were a great way to start the morning off, and despite the fact he went overtime and didn’t even manage to finish all his slides it was still very much an enjoyable and educational time.

Following Stanley were 4 other members of the Visual C++ who discussed in depth the features and pitfalls of the compiler as it relates to the new C++\CLI language, interop and performance scenarios.  Some of the things I learned were:

  • In VC2005, C++ is a full fledged .NET language which can produce pure IL from native C++ code.
  • Multiple inheritance is possible, even when targetting the .NET runtime.
  • The compiler manages an awful lot of the Disposable semantics for you, using them to provide both destructors (X::~X) and finalizers (X::!X).
  • You can declare managed objects “on the stack” now, but it really puts them on the managed heal anyway.
  • Destructors are not guaranteed to be called, especially when the class is used from another language, like C#.
  • You have to be careful in all sorts of places within mixed mode code to avoid traps the interop layer lays around the place for you.
  • There’s a whole bunch of optimization “hints” that are available which I didn’t know about (eg __restrict).
  • The compiler puts all sorts of cookies and stuff into the stack to attempt to detect stack smashing.

During the talk, the power even managed to go out for about 45 minutes thanks to a worker cutting the wrong line somewhere.  Made the talk which was already going long end up about an hour later than scheduled, but that’s all ok because it was very interesting stuff.

Later in the evening I went to some of the “Birds of Feather” sessions where they basically set aside rooms for people to talk about similar things.  Here’s a quick summary of the three sessions I attended:

.NET/Java interop

  • Web services are the recommended way to go, at least people seemed to be having the most success with it.
  • Use simple types and avoid anything much more difficult, look at WS-I’s basic profile.
  • IKVM.NET is an interesting method of interop that recompiles Java bytecodes into .NET CIL.
  • EAI vendors have translation APIs and implementations.
  • Microsoft seems ahead of the curve on standards implementation for web services.
  • JNBridge allows Java classes to be called from .NET.
  • Some people talked about using RMI to talk to Java but no one had a good solution that actually did it.
  • JBImp is a Microsoft provided tool with J# that converts really old bytecodes.
  • Visual Mainwin was mentioned but no one had any real comments about it.

DirectX

  • OpenMP is an interesting technology being pushed to allow developers to better take advantage of multiple execution units, primarily for XBox 360 development.
  • DirectX 10 (on Vista, with LDDM drivers) will provide for multiple Direct3D apps running at once without having arguments about who owns the primary surface.
  • Companies seem to be supporting DirectX much better than OpenGL, at least from a developer perspective.
  • Devs shouldn’t attempt 3d modelling.  It’s hard.
  • XNA is a really cool thing for game development houses that supports their workflow process and even has hooks for non-Microsoft toolsets (such as PS3, GC etc)
  • Managed DirectX for .NET 2.0 should be available for beta testing soon.

Debugging

  • Apparently windbg is pronounced “Windbag”.  I hadn’t heard that one before.
  • Dump files are really cool things for debugging (which I already knew).
  • Debugging concurrency stuff is hard (which I also had a lot of experience knowing).
  • Someone hinted there was a way to drill into the STL in the VC2003 debugger.
  • Debugging concurrency stuff is really hard.

We had to leave the Debugging talk a little early because the shuttle busses decided their last run was 10:30pm.  I barely made it out in time.

Off to sleep for me now.  Have to listen to Bill Gates’ keynote tomorrow morning at 8:30am.

09.11.05

PDC – Preconf Day 1

Posted in General at 11:31 pm by jw

The PDC itself is pretty amazing.  It’s only the first day of pre-conference and there must be over 2000 developers there already.  They have a huge hall set up just to feed us all, and it’s also shared with a whole bunch (like 200 or more) of desktops running Vista and XP just so we can all connect to the internet at once if we want to.  The entire place is wired with WiFi so getting online with our own laptops is also a snap.  I just couldn’t really write up a good summary as the sessions were going on even though the internet worked fine – the stuff was just too interesting (for me).

If today was any indication, this is going to be an awesome conference.  Today was a 6 hour session with David Solomon and Mark Russinovich on Windows Internals – it really was a great look into how the Windows kernel works and what developers should and shouldn’t do to take advantage of it.  They also went into some detail on what’s new “under the hood” in Vista which looks interesting, but I’m not sure it’s particularly compelling yet.

Couple of interesting tidbits I learned (and probably will forget all too soon):

  • Vista is collapsing everything back into a single (multiprocessor) kernel executable.
  • XP-64 is really the same kernel as Windows 2003, not XP.
  • 64 bit Windows does funky stuff with directories and the registry when running 32 bit programs
  • Vista gets rid of the kernel memory limits (aside from the standard 2G limit) – there’s no more fixed sizes for stuff.
  • Vista uses the 2003 model for having independant run queues for each CPU.
  • The default login session is no longer ‘0’ – might make some apps that assume that break.
  • People still remember Mark from when he figured how to turn Workstation into Server, and he got Dave into trouble even though Dave did nothing and didn’t even know Mark at that stage.
  • You can DoS windows by creating a whole bunch of kernel objects.
  • userinit.exe is the process that does all the group policy assignments.  This gives me evil ideas.
  • Vista will have fast user switching on domain accounts.

There’s a bunch more stuff I have in notes, but to go into all that would take forever.

I noticed a room full of 64 bit Alienware PCs (looked like 64 of them) playing the 64 bit Far Cry on the way out.  Was pretty interesting and running very, very smoothly even at high resolution.  Looks like they were all networked together though I’m not sure if it was all playing the same networked game.  AMD is definitely getting good traction on their 64 bit CPUs in the dev community.

More tomorrow…

Next entries » · « Previous entries

This blog is protected by Dave\\\\\\\'s Spam Karma: 14312 Spams eaten and counting...