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

Raymond Chen (Author)

Book Description

Publication Date: January 6, 2007 | ISBN-10: 0321440307 | ISBN-13: 978-0321440303 | Edition: 1

"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

Editorial Reviews

About the Author

Raymond Chen writes The Old New Thing, one of today's most influential technology blogs. A programmer at Microsoft Corporation, Chen has been involved in the evolution of Windows for more than a decade. He also writes TechNet Magazine's Windows Confidential column and has been known to make appearances at technology events.

Excerpt. © Reprinted by permission. All rights reserved.

Much ink is devoted to describing the "how" of using and developing software for Windows, but few authors go into the "why." What might appear at first to be quirks often turn out to have entirely logical explanations, reflecting the history, evolution, and philosophy of the Microsoft Windows operating system. This book attempts to provide knowledge not so much in the form of telling what needs to be done (although there is certainly plenty of that, too) but rather by helping to understand why things came to be that way. Thus informed of the history and philosophy of Windows, you can become a more effective Windows programmer.

The emphasis here, then, is on the rationale behind Windows. It is not a reference or even a tutorial, but rather a "practical history," taking a conversational rather than didactic approach in an attempt to give you an appreciation for the philosophy of Windows through a series of brief, largely independent essays. You can therefore skip freely to topics of momentary interest (or technical expertise). Essays have been grouped into general themes, and there is the occasional sequential pedagogical treatment when a topic is explored in depth; even in those cases, however, the topic is confined to a single self-contained chapter.

Writer and commentator David Sedaris is often asked whether his stories are true. He responds that they are "true enough." Like David Sedaris's stories, the material in this book is also "true enough." The focus is on the big picture, not on the minutiae; on making a single point without getting distracted by nitpicking detail. Key details are highlighted, but unimportant ones are set aside, and potentially interesting digressions may be neglected if they do not serve the topic at hand.

The primary audience is technology-savvy readers with an interest in Windows history. About half of the essays require no programming background. Most of the remaining topics assume a basic background in software design and development, although nothing particularly advanced. Topics specifically related to Windows programming assume reader familiarity with Win32 user interface programming and COM. The table on page xxv provides a breakdown of the chapters for nonprogrammers and for general programmers who do not have an interest in Win32 specifically. Of course, you are welcome to skim chapters not explicitly marked as of interest to you. Perhaps you will find something interesting in them after all.

What will you get out of this book? As noted previously, the primary goal is to convey the philosophy and rationale behind what might at first appear to be an irrational design. You will also understand that when something can't be done in Windows, it's often for a good reason; and you will gain an appreciation of the lengths to which Windows goes to preserve backward compatibility (and why it's important that it do so). And if nothing else, you will be able to tell amusing stories about Windows history at cocktail parties (that is, cocktail parties thrown by other geeks).

Much of the short-essay material here has already appeared in one form or another on the author's Web site, The Old New Thing (http://blogs.msdn. com/oldnewthing/), but is substantially supplemented by new material better suited to book form.

Visit the Web page for this book (www.awprofessional.com/title/0321440307) to download two bonus chapters, "Tales of Application Compatibility" and "How to Ensure That Your Program Does Not Run Under Windows 95." Think of them if you like as the book version of a movie's unique and insightful deleted scenes. The Web page also contains the code samples from the book as well as errata.

Product Details

• Paperback: 560 pages
• Publisher: Addison-Wesley Professional; 1 edition (January 6, 2007)
• Language: English
• ISBN-10: 0321440307
• ISBN-13: 978-0321440303
• Product Dimensions: 7.1 x 1.1 x 9.2 inches
• Shipping Weight: 1.6 pounds (View shipping rates and policies)
• Average Customer Review: 4.2 out of 5 stars  See all reviews (11 customer reviews)
• Amazon Best Sellers Rank: #484,779 in Books (See Top 100 in Books)

More About the Author

Discover books, learn about writers, read author blogs, and more.

Most Helpful Customer Reviews

15 of 16 people found the following review helpful

4.0 out of 5 stars Interesting blend of general and specific Windows history... January 13, 2007

By Thomas Duff HALL OF FAMETOP 500 REVIEWERVINE™ VOICE

Format:Paperback

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.

3 of 4 people found the following review helpful

4.0 out of 5 stars Definitely enjoyable April 2, 2007

By Michael Wiley

Format:Paperback

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.

3 of 4 people found the following review helpful

4.0 out of 5 stars Essential reading for the "why" of Windows October 16, 2008

By Rich Turner

Format:Paperback

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.