Customer Reviews

The Old New Thing: Practical Development Throughout the Evolution of Windows

5 star:		(3)
4 star:		(7)
3 star:		(0)
2 star:		(1)
1 star:		(0)

 

 

It's a common occurrence as a developer... You go into a program in order to fix something, and you run across some quirky code. "What idiot came up with this?" The reality is that there were likely constraints and limitations at the time that you don't know about. Raymond Chen talks about those issues and many others in the book The Old New Thing: Practical Development Throughout the Evolution of Windows. It's not a book that kept me riveted throughout, but it was interesting nonetheless...

Contents: Initial Forays into User Interface Design; Selected Reminiscences on Windows 95; The Secret Life of GetWindowText; The Taskbar and Notification Area; Puzzling Interface Issues; A History of the GlobalAlloc Function; Short Topics in Windows Programming; Window Management; Reminiscences on Hardware; The Inner Workings of the Dialog Manager; General Software Issues; Digging into the Visual C++ Compiler; Backward Compatibility; Etymology and History; How Window Messages Are Delivered and Retrieved; International Programming; Security; Windows 2000 and Windows XP; Win32 Design Issues; Taxes; Silliness; Index

Chen is a programmer for the Windows operating system, and he uses this book to tell the "history" of Windows development. The chapters are divided up into subsections that are often titled "Why..." The approach is to explain why certain design decisions were made, given the environment of the time. The writing style is conversational and somewhat irreverent, so in large part it's a book that you would sit down and read like an entertaining nonfiction essay. For instance, you'll find out that having a huge dictionary for spell checking isn't necessarily a good thing ("werre" is a proper word in the Oxford English dictionary). You'll learn that staying away from maintaining maps for software sold internationally is a wise move. And why exactly is CR+LF the defacto line terminator, anyway? It's those tidbits and insights that made the book well worth reading for me.

On the flip side, the book gets into a *lot* of Windows API coding, complete with code listings, comparisons, and how-tos. Now, if you're a hard-core Windows developer, you may well find that the sections on the difference between CreateMenu and CreatePopupMenu or what is _purecall are more to your liking. These are the parts where the geeky developer will be able to find out why a certain API comes loaded down with so much seemingly extraneous baggage. As someone who *isn't* into Windows API work, I found these chapter sections less interesting and tended to start skimming over them. Again, it all depends on what you're after when reading this book...

Both the specialist and generalist will have something to like about The Old New Thing. The developer geek will probably get more out of it than I did, but it was worth reading in any case.

Ever wondered why something in Windows is as it is? This is the book for you!

Raymond is a long-time member of the Windows development team and has blogged profusely about many aspects of development, technology and Windows since his first post back in 2003.

This book cherry-picks some of the more interesting and important posts from his blog, edited together to build a comprehensive set of background history and information about why Windows is as it is.

Whilst many developers working on Windows today (and certainly in the future) may never write apps in C/C++ for Win32, the book still provides a great deal of background to help explain how Windows' primary API and it's associated technologies is designed how it is.

One of the most enlightening things to many who perhaps weren't involved in writing apps for Windows back in the Windows 1.0/2.0/3.0/3.1/95 era are the many articles that discuss why Microsoft didn't "fix" what might at first appear to be "obvious" issues in it's API or technologies.

As Raymond clearly points out - Microsoft's obsession with trying to ensure backwards compatability across Windows versions has clearly shaped many parts of Windows and it's API, and is one of the reasons Windows has risen to the position it has - Microsoft goes to extraordinary lengths to NOT break existing apps.

However, at times, it's necessary to cause some breakage. Raymond gives many examples of where things HAD to change in the transition from Win16 to Win32. He also gives several examples of how Vista *HAD* to close down many security holes that it had kept open previously to enable backwards compatability. However, there are many, MANY post-Vista discussions that I hope Raymond includes in subsequent editions or follow-on books of this type.

Thoroughly recommended for anyone building applications on Windows.

As an old C++ programmer, I can appreciate some of the pearls of wisdom in this book. If helps you to understand why some things work they way they do in Windows and other Microsoft software. It has some code in it, but you needn't be fluent in C or C++ to understand it. Chen has excellent storytelling ability, and it's a very enjoyable read. For "long time" developers - this is a "must read". For newer developers, this should be required reading to help understand the guts of Windows and how things operate. I highly recommend this book for all Microsoft developers. Use this as your "fun reading material", for it's not a programming book.

The disturbing aspect of this book is if you remember some of the events that Chen talks about. Especially the further back in time they were. Chen takes a march down the Microsoft memory lane, describing quirks in earlier incarnations of the MS Windows operating system. He demonstrates a deep knowledge of the subject.

The content is a blend of various aspects, and caters to different technical readerships. Some sections concern user interface design, and are fairly non-technical. Could be readily appreciated by a broad audience. But most of the text is actually for an existing or former programmer of MS Windows. With many references to coding techniques. The back cover says that knowing the background of the quirks can make the reader more productive and less frustrated. I am rather uncertain about the more productive claim, though being less frustrated seems plausible.

While it is true that a programmer from another background could understand much of the book, she will probably derive little that can be applied in her context. The kludges (which is probably the best term) are very specific to MS Windows.

This book is a delight to read and it was my second time reading it (the first was during jury duty back in February 2007). Some chapters get pretty deep in programming, so I just skimmed over those. Mostly focuses on the Windows 95 and 3.1 era with a little 2000 and XP thrown in. Basically, this is the book form of Chen's blog "The Old New Thing" with more stories and more details.

One thing that is kind of annoying is the downloadable bonus chapters. The author gives a link to download bonus chapters in the preface. This link goes to informit.com with another link to safari.com. Even after registering the ISBN number on informit.com, it would link me into safari.com and safari.com won't let me look at bonus chapters unless I sign up for a 10 day trial. Of course, they want a credit card number. Why? I already bought the book, so I cancelled out the trial setup and did a little Google searching and found the bonus chapters in PDF format over at the Pearson site.

I went to Chen's blog to contact him about this, but there's no e-mail address in site and no comment box to leave a message. On the blog postings where he mentions the bonus chapters, I was going to leave a comment, but the comments are now closed (too much time has passed I guess). Why can't he post these bonus chapters on his web site? The second chapter is just a reprint of something he wrote in the MS-DOS days. I don't get it!

Raymond has as good an insight as anyone (well, ALMOST anyone) into the history of Windows and the reasoning behind why things are the way they are. This is a fascinating read not just for programmers but for anyone interested in the difficulties of backwards compatibility, the clever solutions required to work in a multitude of different environments, and just some of the more interesting parts of Windows history.

This book is full of highly-entertaining articles on everything from why you can't install Windows via XCOPY to the evolution of Win32 dialog templates. OK, maybe I don't find the bits about dialog templates so interesting, but the rest of the book is full of very interesting topics on how Windows has come to be what it is.

Chen has been in the Win32 world at Microsoft for a very long and really, really knows his stuff. He's very skilled at what he does and is very forthright about what he doesn't know. His show on DotNetRocks was much along the same lines as this book: lots of very deep dives into areas of his expertise with clear disclaimers "That's out of my realm."

So what use will this book be for folks who are outside the Win32 arena? First, it's a nice background on some basic Windows behaviors like why the Shutdown option is under the Start menu, what overlay icons do, why registry files are called hives, and odds and ends about internationalization. There's also a lot of content which is applicable to folks in any domain: taking appropriate care with world-writable files, the impacts of server paging, or general bits about developing sort routines.

Secondly, the book is just plain entertaining. Chen writes in a light, humorous fashion and manages to make most of his articles very interesting. (It's impossible to make a couple pages of example machine code immensely exciting, but Chen comes close.)

Overall the book's a good skim for folks like myself. I'd say it's extremely important if you're involved with Win32 development -- and that means .NET folks who are doing a large bit of Interop programming.

Raymond Chen's book is a technically deep, thoughtful, and delightful view of writing great programs for Windows. He brings the history of the world's most widely used APIs to life and offers first-hand insights as to the why and how APIs do what they do. It is a great book for current programmers using Vista or old-hands just wanting to remember some of the fun of original Windows programming. Read this book and put it to use to make your Windows programs even better!

Chen has been deeply involved in the development of Windows for a long time. This collection of essays is a compilation (with occasional extensions) of material from his blog.

There's something for everyone - from nuggets of Windows history, especially the user interface to deep (really, really deep) programming topics. I expect that most people will be interested in the history rather than the details of the message loop. The breadth of treatment and the presentation mean that the book becomes two books in one: a book for a general geek-ish audience, and a book for programmers.

Well written in Chen's usual fluent style, although lacking his acerbic responses to blog comments, which are often the most amusing part of each entry.

I absolutely recommend this book to every geek interested in Windows history. It sheds perfect light on some "Why is it?" aspects of Windows and also has some nice low-level-stuff related reading.

You will love Raymond's writing style!