One of my favorite quotes is the old chestnut about laws and sausages: the less you know about how they are made, the better!

Unfortunately, more often than not, the adage is also perfectly apt for technology endeavors. Any IT pro who has been involved in a major upgrade or development project knows all too well just how many ‘additives' go into such an effort.

Indeed, the Windows OS itself (or any OS, for that matter) is no exception to this universal ‘rule of sausage.' Chances are, if you work in a Windows environment at all, you have wondered (likely in exasperation) just how everything has become so sausage-like.

For some provocative and ultimately useful answers to the question, take a look at Raymond Chen's book The Old New Thing: Practical Development throughout the Evolution of Windows.

You may know Chen from his amusing blog (blogs.msdn.com/oldnewthing), or perhaps his entertaining talks at developer conferences. You may also be familiar with his popular and enjoyable back page column in Microsoft's TechNet magazine.

Chen is indisputably a Windows development veteran. He started out at Microsoft in the early 1990s as a developer of Windows 95. He's still there today, having worked on everything from DirectX to present versions of Windows, and has established a durable reputation as a meticulous and philosophical coder.

His book is an absorbing read: a mix of useless trivia, "oh, that's why they did it that way" explanations, practical strategies for issues like debugging, serious technological history, and subtle tell-all (you won't have to think too hard to recognize some of the lazy software vendors to which he alludes). Chen is justifiably known for his dry wit, and it shines through in his remarkably readable, yet deeply technical book.

However, don't make the mistake of assuming the book has no value beyond trivia or is strictly for Windows pros. While a few topics (such as on 16-bit environments) are somewhat of a nostalgic glimpse backwards , the fact is that the compromises and philosophies discussed in the book still inform the current Microsoft mindset. Chen adeptly describes all the historical baggage that, by necessity, continues to lurk in Windows code, and still matters today. Present day developers and admins ignore this past at their own peril.

As a writer, Chen is enjoyably irreverent, though I at times detect a touch of defensiveness as he explains how some element of Windows came to be such an obvious kludge. But, having read the book, it's only fair to say his defensiveness may be justified-many aspects of Windows now make sense to me in a way they never did before, and I see the necessity of doing some things the way they were done.

Regardless of one's feelings about the platform, the folks at Redmond have clearly put astonishing effort into making Windows work in spite of an awful lot of junky apps put out by sloppy programmers writing for the platform. If nothing else, the book is a worthy reminder of how mind-bogglingly complex an undertaking software is at heart.

The book's target audience would seem to be a strange hybrid of programmer, developer, geek, systems manager, and perhaps trivia-hound. I think it's a beneficial read for anybody who works with Windows professionally, whether that means developing, or managing teams of coders, groups of systems, or help desks.

Roughly speaking, about half the book is appropriate for any Windows manager, and the other portions are intended more for programmers, but not just those working with Windows. Many of the topics are universal issues faced by anybody diving deeply into coding and scripting, although some topics get fairly arcane and hardcore unless you are truly a full-time developer. Fortunately, Chen includes a handy table in the front of the book indicating which chapters are most suited for the area of interest and skill-level of a given reader.

Using myself as an example, although I only do limited hands-on development, I found even the chapters aimed at heavy developers to be informative. I consider my development skill level journeyman, but not expert-yet I rarely felt lost while reading the book.

Some of the most practical lessons I took away from the book I found in Chapter 17 ("Security"). For example, when I'm doing simple troubleshooting or maintenance, I get weary of Windows Explorer asking "Are you sure you want to show Hidden Files?". Although I know the dialogue saves me much grief as an admin by preventing users from throwing away a vital .dll (and so fomenting "dll hell"), it still annoys me. However, Chen explains the risks of these hidden files in a way I'd never thought of; sure, as a developer and admin, I want my critical app components protected and hidden, but the dilemma arises when you contemplate the security risks of undetectable and invisible files. Chen's brief discussion of this surprisingly complex (hint: it's an arms race!) issue is fascinating.

An especially valuable theme in the book is that of memory management and debugging. Both realms are of course a bane to us all, but Chen's in-depth look at how memory management and debugging evolved, and his discussion of architectural issues and strategies for memory handling is an aspect of the book I found tremendously educational.

On the trivia side, did you ever wonder why the Windows registry is called a hive? Well, it happens that one of the original developers of NT hated bees, and another developer on the project chose the term specifically to annoy that person. Although conveniently a logical term, it's also a prank. Ironically, it's also a fitting name since registry problems can indeed pack a potent sting!

I came away from this book feeling as if I understood Windows and development better on many levels, with new insights into the give-and-take that inevitably comprises creating software. Moreover, I picked up some arcane trivia that I just know will make me the life of many a party. For example, do you know why you should only use www.example.com as a sample URL? No? Well, you'll have to read the book to find out, and the amusing consequences of not doing so.

I found myself having epiphany after epiphany while reading this book-everything from new strategies for today's projects to closure on aggravations encountered in projects long since past-and I'm willing to bet you too will be a better Windows manager and programmer for having read it.

The book comes in at about 500 pages, but since it is comprised of brief essays, it's thankfully no slog to read. In fact, it's funny enough that I suspect my wife thought I had lost my marbles while engrossed in it, because I'm pretty sure she's never seen me laugh out loud reading a technical book. That alone may be worth the price!

The Old New Thing is available at any bookstore. If you buy directly from the publisher at the link below and register, there is a 20% discount available. The book is also "Safari-Enabled," and so is available as part of a subscription ‘Online bookshelf.' This is an intriguing option, as it provides access to a wealth of additional IT titles from multiple popular technical publishers such as O'Reilly, Cisco, and Que. You can read more about either purchase option on the publisher's website below.

 

The Old New ThingPublication Details:

The Old New Thing by Raymond Chen

Addison-Wesley Publishing

ISBN:0-321-44030-7

 

More info:

http://www.informit.com/store/product.aspx?isbn=0321440307

 

 

 

Forward this page to a friend

Your Email: *

Your Name: *

Send To: *

Enter multiple addresses on separate lines or separate them with commas.

Message Subject: (Your Name) has forwarded a page to you from NaSPA.com

Message Body: (Your Name) thought you would like to see this page from the NaSPA web site.

Your Personal Message: *

Your vote:

1

2

3

4

5

No votes yet