March 2004 Blog Posts

Microsoft Service Pack 6 for Visual Basic 6.0, Visual C++ 6.0 with Visual SourceSafe 6.0d addresses known issues with Visual Basic 6.0, Visual C++ 6.0 and Visual Source Safe 6.0. This service pack does not contain fixes for Visual InterDev 6.0, Visual FoxPro 6.0, and Visual J++ 6.0, as the mainstream life-cycle for these products has ended. This SP replaces SP5 for developers using Visual Basic 6.0, Visual C++ 6.0, and Visual SourceSafe 6.0. Developer using Visual InterDev 6.0, Visual J++ 6.0, and Visual FoxPro 6.0 should continue using SP5.

Eric Gunnerson: When we decided the using statement, we decided to name it "using" rather than something more specific to disposing objects so that it could be used for exactly this scenario.

Joshua Allen has a nice post about data normalisation. He suggests that sometimes it is necessary for performance and scalability reasons that you don't fully normalise your data schema. This is something I've run into occasionally too but, as I recall, isn't something that was taught in the academic database design courses I attended way back when.

In a well reasoned follow-up post, Scott Hanselman explains why storing ViewState in an ASP.NET Session isn't as easy as it first appears. Amongst other good stuff, he makes two points I want to reiterate:

  • Spend less time writing wrongheaded plumbing code to replace ViewState, and instead learn how to use it effectively and efficiently.
  • Buy Fritz's book. (This is such a well written and easy to read book - I say it is a must have.)

I've been interested in Instant Messaging and Presence for some time now. A number of protocol groups were spawned from the IMPP effort including XMPP, an XML based protocol that is the core for the Jabber project.

Now, separately, an array of specifications have been written for web services, which are fundamentally about exchanging messages with support for security, reliability, addressing, routing, and subscriptions amongst other things; in fact, most of the things in the requirements document for IMPP RFC 2779. Once all the tools support for these specifications appears, it would be interesting to see how little code would need to be written to construct an interoperable IM protocol. In the meantime, Bruce Williams has a blog post describing the WS-Eventing specification.

A great interview going behind the technology to the personalities involved in the Windows User Experience team at Microsoft. [via Chris Sells]

830320: This article lists and compares the features that are included in Microsoft Windows SharePoint Services and in Microsoft Office SharePoint Portal Server 2003. [via LauraJ]

Andrew Cencini: In this article, I will not focus as much on the fairly extensive 'baggage' that is involved in supporting the IFilter interface (there are many approaches to hooking the various pieces together), but rather, I’ll spend more time explaining how to get everything working so you can experiment further with your IFilters and fine-tune the techniques employed to make these components available in C#. [via Don Box]

I've worked on writing managed components supporting IFilter in order to process metadata into Microsoft Index Server for querying both as part of a full text search and an extensible data store. This is one of the things that I hope WinFS will improve but for now this is a good example as an introduction to IFilter.

Joel on Software: There's UCS-4, which stores each code point in 4 bytes, which has the nice property that every single code point can be stored in the same number of bytes, but, golly, even the Texans wouldn't be so bold as to waste that much memory. [via Eric Gunnerson]

Raymond Chen: Imagine if somebody took away your current editor and gave you a new one with different keybindings. "But the new one is better."

Hmmm..., ever upgraded to a new version of Visual Studio?

Okay, VB.NET has a more concise syntax for checking reference equality without calling out to Object.ReferenceEquals:

"If c1 Is c2 Then..." vs. "if ((object)c1 == (object)c2) {...}"

Okay, VB.NET gets this one; I'm not yet persuaded however and my preference is still for C# given the choice.

Keith Ray: ...because everyone is afraid to modify other's classes, their own classes become kitchen-sinks full of stuff that really belongs elsewhere -- this does make classes harder to understand, because they end up being badly designed and violating encapsulation "in reverse" -- the big fat individually-owned-classes have many "internal" pseudo-objects they depend tightly on, when they should be having looser connections with external classes. [via Patrick Logan]

I've worked on a number of projects where I've tried to move people aware from a sense of ownership of the code they've written. It's not always easy and it is a complex problem trying to get many people in a group to understand how most of a system or subsystem works so they can code against it. However, in the face of more agile programming methods with sufficient unit tests providing the confidence to refactor then the situation improves.

What I find time and again is that when different people look at code that has already been written, mostly they find places where refactoring makes sense in order to simplify the code so that they can understand it. The original developer got too close and knew exactly how things were composed and didn't need further simplification but the system benefitted from the restructuring.

This happens in other professions too. I know that whenever I'm given some kind of document in Word or whatever, I find it much easier to critique and offer editorial changes than it would be to have written the document myself in the first place. In general it is easier to work with something that needs polish than to start from scratch. I say again that changing code can be a dangerous thing but unit tests can give you confidence to make modifications knowing you haven't broken any tested behaviour.