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

By Raymond Chen

Book Overview

"Raymond Chen is the original raconteur of Windows."

--Scott Hanselman, ComputerZen.com

"Raymond has been at Microsoft for many years and has seen many nuances of Windows that others could only ever hope to get a glimpse of. With this book, Raymond shares his knowledge, experience, and anecdotal stories, allowing all of us to get a better understanding of the operating system that affects millions of people every day. This book has something for everyone, is a casual read, and I highly recommend it "

--Jeffrey Richter, Author/Consultant, Cofounder of Wintellect

"Very interesting read. Raymond tells the inside story of why Windows is the way it is."

--Eric Gunnerson, Program Manager, Microsoft Corporation

"Absolutely essential reading for understanding the history of Windows, its intricacies and quirks, and why they came about."

--Matt Pietrek, MSDN Magazine's Under the Hood Columnist

"Raymond Chen has become something of a legend in the software industry, and in this book you'll discover why. From his high-level reminiscences on the design of the Windows Start button to his low-level discussions of GlobalAlloc that only your inner-geek could love, The Old New Thing is a captivating collection of anecdotes that will help you to truly appreciate the difficulty inherent in designing and writing quality software."

--Stephen Toub, Technical Editor, MSDN Magazine

Why does Windows work the way it does? Why is Shut Down on the Start menu? (And why is there a Start button, anyway?) How can I tap into the dialog loop? Why does the GetWindowText function behave so strangely? Why are registry files called "hives"?

Many of Windows' quirks have perfectly logical explanations, rooted in history. Understand them, and you'll be more productive and a lot less frustrated. Raymond Chen--who's spent more than a decade on Microsoft's Windows development team--reveals the "hidden Windows" you need to know.

Chen's engaging style, deep insight, and thoughtful humor have made him one of the world's premier technology bloggers. Here he brings together behind-the-scenes explanations, invaluable technical advice, and illuminating anecdotes that bring Windows to life--and help you make the most of it.

A few of the things you'll find inside:

What vending machines can teach you about effective user interfaces A deeper understanding of window and dialog management Why performance optimization can be so counterintuitive A peek at the underbelly of COM objects and the Visual C++ compiler Key details about backwards compatibility--what Windows does and why Windows program security holes most developers don't know about How to make your program a better Windows citizen

• Format: Paperback
• Language: English
• ISBN: 0321440307
• ISBN13: 9780321440303
• Release Date: December 2006
• Publisher: Addison-Wesley Professional
• Length: 560 Pages
• Weight: 1.80 lbs.
• Dimensions: 1.1" x 7.0" x 9.3"

Customer Reviews

A collection of fascinating insights

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.

Essential reading for the "why" of Windows

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.

Perfect insight

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!

The true insiders guide to Windows

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!

Interesting blend of general and specific Windows history...

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.