09.13.05

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.

Permalink