(Okay, this is a review of a technical book, but since I know that most of my readers are non-technical people (or, at least, people who are technical in a different area), I'm going to do my best to keep things interesting to a general audience up until the part where I have to get into details.)

If you pay even vague attention to computer-related news, you've probably heard of Microsoft's .NET initiative by now. And if you pay anything less than extremely-detailed attention, you probably have minimal idea what the heck .NET is. Part of this is because Microsoft's badly overused the term (for marketing reasons) to apply it to just about everything they're doing now, and part of it's because there are several parts to .NET.

One of the parts (.NET My Services) refers to Microsoft's "Web Services". What are web services, you ask? It doesn't matter, I say. Web services may or may not become a big thing, but until they do, you don't need to pay attention to them (unless you're a software developer, there's no using paying attention to the Big New Thing before it actually hits big; otherwise, you'd've spent all your time learning up on push technology and peer-to-peer, and what a waste that would have been). Web services are kinda vaporish right now. It's possible to create and use them, but I've so far not seen any compelling -- or even really interesting -- web services in actual use.

The other part, and the part I'm going to talk about here, is the .NET Framework. At a fundamental level, the .NET Framework is a dull and technical thing that you'll never deal with -- it's a collection of programming interfaces that software developers will use to create applications. Like I said, dull. Except to developers.

And that's where things get interesting for you, Good Non-Technical Reader. Because, see, in recent years, Microsoft's development environments have been taking it in the shorts. Programming for Microsoft operating systems has been a pain in the ass, as Microsoft's programming interfaces and languages have pretty much sucked compared to the biggest competition out there, Java. For the last few years, Java's been so far ahead of Microsoft in the developer productivity front that it wasn't even a competition, and Microsoft pretty much had only its huge monopolistic installed base to keep it in the game.

That's not the case any more. .NET is a whole-scale, ground-up rewrite of Microsoft's programming interface, and it's very, very good (and, not at all coincidentally: very, very Java-like). Java's advantage is, just like that, entirely gone -- and in a lot of respects, Java is now lagging. Microsoft has used its monopoly powers and huge cash reserves to once again come from behind, steal the leader's good ideas, and dominate.

With the release of .NET, your chances of ever living in a world free of Microsoft's domination just got a lot smaller. The worst part about this is, the Java folks don't even seem to realize that they've just been lapped -- they're still acting as if Microsoft is still back there tying its collective shoes, and they have all the time in the world to cavort and frolic without real competition. It's frustrating, honestly.

But hey, silver lining: At least things under the rule of Microsoft will be better for software developers post-.NET.

Anyway, I was talking about a book here, wasn't I? The book in question is Jeffrey Richter's Applied Microsoft .NET Framework Programming . With any technical book, there are two important questions: First, is it deep?, and second, is it objective? Regrettably, most .NET books have failed both of those two tests; thankfully, this one passes both with flying colors.

(By the way, any non-technical readers who've gotten this far can probably start skimming, or just stop reading entirely.)

With regard to depth, there's a real danger with new technologies that books about them will be shallow, simply because nobody's had time to really use them much or find out things in depth. Richter gets around that by virtue of writing for Microsoft Press, and having inside access to the .NET development team. This means that he's able to explain not only how things are in great detail, but also why they're that way. Richter displays a fine command of relevant detail; any aspiring .NET programmer will be far more grounded in the fundamentals of the .NET Framework after reading this book.

In fact, I'd go so far as to say that this book (or one very much like it) is essential reading for any real .NET programmer. You can do cargo-cult programming without understanding things at a real level, but if you want to do real programming, you need to know what's really going on. If you read this book, you'll know. The quality of information presented is excellent here -- this book is good enough that it could be published by O'Reilly, which is the highest compliment I can pay a tech book.

So, what about objectivity? This was my biggest potential worry going into the book. After all, it is a Microsoft Press book, and the author does seem to know the .NET development team, so there's definitely a potential lack of objectivity there. More, it seems like most of the books out there that cover .NET technologies do so with a complete blindness to all non-Microsoft technologies, which is patently ridiculous -- .NET owes so much to Java that it's inconceivable it'd exist as it currently exists without Java's example to look to, but authors write about .NET as the natural evolution of COM without any reference to its non-Microsoft predecessors. The creeping suspicion one gets is that the author isn't actually familiar with any non-Microsoft technologies, which makes you wonder just how much they really know.

Richter doesn't make you wonder. Somewhat frustratingly, he doesn't talk much about Java, but he does reference other technologies, and (most importantly) isn't afraid to point out shortcomings of .NET, even going so far as to highlist some aspects as egregious bugs or just poor design. There's no suspicion that Richter is in Microsoft's pocket, or that this book has been sanitized for PR purposes.

In fact, the only real fault I can find in this book is that it does neglect Java. The most irritating effect of this neglect is that the book is clearly written for an audience of Windows C++/COM programmers coming to .NET, not for Java programmers looking to .NET. In large part, this isn't a big deal, but it does lead to unnecessarily long and introductory chapters on strings, exceptions, and garbage handling (I wondered at first why Richter spent so much time on these topics, which are very familiar to Java programmers, before remembering that C++ programmers wouldn't be nearly as familiar with them).

Still, that's not a big deal, and it probably had to be written that way, as there's a huge audience of C++ programmers out there, and they need to know this stuff. It leads to a few skimmable chapters for the Java programmer, but the rest of the book more than makes up for it; and even the Java-similar chapters contain enough .NET-specific stuff that Java programmers could stand to learn a bit from them.

If you're a real programmer (say, someone who knows what polymorphism is, which excludes most VB monkeys) and are, or expect to be, programming with the .NET Framework, buy this book and read it.


{{comment.name}} said {{timeAgo(comment.datetime)}}