30. March 2004 07:10
Often I see somebody complaining that some API, class or library is broken. Windows forms list views are broken because they allow you to put anything into them. Webforms are broken because they are not as rich as winforms. Winforms are broken because they are not the same as webforms. Value types are broken, Xml Serialization is broken, enums are broken, regex is broken. Broken Broken Broken. It is amazing that any software gets written at all considering all these half baked frameworks, ill-conceived APIs and shoddy implementations. Are all these things really that bad? This is the real world: software has bugs, and there are a finite amount of resources that can be brought to bear designing and developing any piece of it. However I think in most cases the most broken thing is the developer's understanding of the thing which they claim is skrewy. It seems that some people truly believe that if they don't understand it, or if it doesn't work the way they think it should then it is crap. Some people will even discount things without reading the documentation (shame on me, I've done this one too).
Often it seems that the key piece of information that is missing is understanding. In .NET I occasionally find some part of the framework and just can't figure out why it is the way it is. Xml Serialization is a good example - at first I just couldn't understand why the XML serializer seemed so limited. I knew it was possible to write something that allowed "full fidelity" type serialization to XML, so why didn't the XML serializer do this? It was only when I realized that the intention of the XML serializer was to serialize types to XML where .NET may not be running on the other end (ala web services) that I finally understood why it was the way it was *. Understanding the why of certain libraries (either their intended function, or some restriction they are required to operate under) can help a great deal when using them.
I'm not sure why people do this - maybe they have been burnt before and have learned to expect sub-standard things, maybe it is a form of ego protection, but I think developers do themselves a great dis-service when they write something off as broken after a relatively brief exposure to it. They rob themselves of a chance at better understanding by "flipping the bozo bit" and moving on. Using something while understanding the zen of it is a lot easier than constantly wrestling with a class or API that you just don't properly understand.
* Note: It seems that Microsoft is aiming at improving the interoperable xml serialization capabilities in .NET for Indigo, so maybe Xml Serialization (as it currently stands) is a little broken compared to what is to come.