See buying choices for this item to see if it's one of the millions that are eligible for Amazon Prime.

41 used & new from $0.67

Have one to sell? Sell yours here

Tell the Publisher! I�d like to read this book on Kindle Don�t have a Kindle? Get yours here.

Writing Solid Code: Microsoft's Techniques for Developing Bug-Free C Programs (Microsoft Programming Series) (Paperback)

by Steve Maguire (Author)

3.7 out of 5 stars See all reviews (42 customer reviews)

Available from these sellers.

7 new from $24.95 34 used from $0.67

Customers Who Bought This Item Also Bought

Code Complete: A Practical Handbook of Software Construction

by Steve McConnell

4.8 out of 5 stars (107) $31.49

Rapid Development: Taming Wild Software Schedules

by Steve McConnell

4.8 out of 5 stars (112) $23.10

The Mythical Man-Month: Essays on Software Engineering, Anniversary Edition (2nd Edition)

by Frederick P. Brooks

4.5 out of 5 stars (136) $33.34

Code Complete (Microsoft Programming)

by Steve McConnell

4.7 out of 5 stars (149)

Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley Professional Computing Series)

by Erich Gamma

4.5 out of 5 stars (261) $41.57

› Explore similar items

Editorial Reviews

Amazon.com Review
Any programmer worth their silicon knows that it is wiser to invest time preventing bugs from hatching than to try to exterminate them afterwards. And this is one of the best books for developing a proactive attitude towards electronic entomology. Follow Maguire's advice, and your testers, supervisors and customers will love you. Recommended.

Product Description
"This book has useful things to say and an engaging way of saying them...a worthwhile addition to the shelves of any full-time programmer." - PC Week. Here, from a former Microsoft developer, are super secrets for developing bug-free C programs. Maguire provides examples of how bugs are caught at Microsoft (using actual case histories) and shows how readers can use these proven programming techniques to get products to market faster.

Product Details

Paperback: 256 pages
Publisher: Microsoft Press; 1 edition (May 1993)
Language: English
ISBN-10: 1556155514
ISBN-13: 978-1556155512
Product Dimensions: 9 x 7.2 x 0.9 inches
Shipping Weight: 1.2 pounds

Average Customer Review: 3.7 out of 5 stars See all reviews (42 customer reviews)

Amazon.com Sales Rank: #102,623 in Books (See Bestsellers in Books)
Popular in these categories: (What's this?)
#9 in Books > Computers & Internet > Programming > Languages & Tools > Debugging
#73 in Books > Computers & Internet > Microsoft > Development > C & C++ Windows Programming

Would you like to update product info or give feedback on images?

Look Inside This Book

Browse Sample Pages:
Front Cover | Table of Contents | First Pages | Index | Back Cover

Citations (learn more)

17 books cite this book:

The Unified Process Elaboration Phase: Best Practices in Implementing the UP by Scott W. Ambler on page 47, page 48, and Back Matter
Writing Secure Code, Second Edition by Michael Howard on page 155, and Back Matter
Rapid Development: Taming Wild Software Schedules by Steve McConnell on page 18, and Back Matter
Software Project Survival Guide (Pro -- Best Practices) by Steve McConnell in Back Matter (1), and Back Matter (2)
Hacker's Guide to Project Management, Second Edition (COMPUTER WEEKLY PROFESSIONAL) by Andrew Johnston on page 207, and page 212

See all 17 books citing this book

What Do Customers Ultimately Buy After Viewing This Item?

	72% buy the item featured on this page: Writing Solid Code: Microsoft's Techniques for Developing Bug-Free C Programs (Microsoft Programming Series) 3.7 out of 5 stars (42)
	12% buy Code Complete: A Practical Handbook of Software Construction 4.8 out of 5 stars (107) $31.49
	9% buy Rapid Development: Taming Wild Software Schedules 4.8 out of 5 stars (112) $23.10
	4% buy The Mythical Man-Month: Essays on Software Engineering, Anniversary Edition (2nd Edition) 4.5 out of 5 stars (136) $33.34

Explore similar items

Tags Customers Associate with This Product

(What's this?)

Click on a tag to find related items, discussions, and people.

algorithms(3)

computer science(3)

debugging(3)

programming(3)

oop(2)

project management(2)

software development(2)

development(1)

software engineering(1)

See all 11 tags...

Help others find this product — tag it for Amazon search

No one has tagged this product for Amazon search yet. Why not be the first to suggest a search for which it should appear?

Sell a Digital Version of This Book in the Kindle Store

If you are a publisher or author and hold the digital rights to a book, you can sell a digital version of it in our Kindle Store. Learn more

Customer Reviews

42 Reviews

5 star:		(14)
4 star:		(16)
3 star:		(2)
2 star:		(5)
1 star:		(5)

Average Customer Review

3.7 out of 5 stars (42 customer reviews)

Share your thoughts with other customers:

Create your own review

Most Helpful Customer Reviews

32 of 33 people found the following review helpful:

4.0 out of 5 stars Still Offers Good Advice, December 4, 2002

By	Paul J. Mantyla (Sunnyvale, CA USA) - See all my reviews (REAL NAME)

The negative reviews I've read tend to fall into two categories: 1) Anti-Microsoft Bashing and 2) Nitpicking.

This book isn't a recipe book, and it's a bit dated, having been written during the days of DOS and the first Macintosh, but the underlying themes and general advice are still valid:

- Enable compiler warnings and pay attention to them.
- Use assertions to validate your assumptions.
- Don't quietly ignore error conditions or invalid input.
- For a complicated, critical algorithm, consider using a second algorithm to validate the first. (e.g. validate binary search with a linear search).
- Don't write multi-purpose functions such as realloc (it can grow memory, shrink memory, free memory, or allocate new memory -- it does it all).
- Check boundary conditions carefully.
- Avoid risky language idioms.
- Write code for the "average" programmer. Don't make the "average" programmer reach for a reference manual to understand your code.
- Fix bugs now, not later.
- There are no free features; don't allow needless flexibility (like realloc).
- Ultimately the developer is responsible for finding bugs; he shouldn't write sloppy code and hope that QA will find all his bugs.

Comment Comment | Permalink | Was this review helpful to you? Yes No (Report this)

17 of 17 people found the following review helpful:

5.0 out of 5 stars Please ignore previous negative reviews, November 22, 2003

By	Robert O. Alexander (Bellevue, WA United States) - See all my reviews (REAL NAME)

I was shocked to see this book get some negative reviews. Those that blasted Microsoft missed the point. This book provides invaluable advice in a quick read. For example, "If you have to look it up, the code is not obvious," or, "If you find yourself designing a function so that it returns an error, stop and ask yourself whether there's any way you can redfined the function to eliminate the error condition." This is the book that convinced me to single-step all my code. The heuristics on proactive bug prevention, which are summarized in the appendix by the way, will save your team time and let you move on to adding features rather than fighting fires.

Comment Comment | Permalink | Was this review helpful to you? Yes No (Report this)

67 of 81 people found the following review helpful:

2.0 out of 5 stars Flaws and outdated advice detract from otherwise good advice, January 15, 2001

By	B. Scott Andersen (Acton, MA USA) - See all my reviews (REAL NAME)

Writing Solid Code was first published over eight years ago and concerns a subject, development in C, that hasn't gotten much press lately. In an era where it seems like everything is OO and developed in C++ or Java, the simple truth is C and non-OO development still has a strong place in our industry. This may explain why a book such as this continues to draw attention.

The writing has a feel of the old C classics such as The Elements of Programming Style (Kernighan, Plauger) which also offered lots of advice with little or no formal reasoning or literature citations to back up that advice. As a consequence, the text has a personal, easy flow but contains some recommendations which are questionable at best.

First, I should outline what is right with this work. There are many nuggets of wisdom that seem obvious if not uncontroversial: enable all compiler warnings, use lint, use assertions, and don't wait until you have a bug to step through your code. Enough of these reasonable guidelines appear in the text to lull the reader into a false sense of security with the remainder of the work.

What makes this book dangerous for new developers is the number of points that are either marginal in value or just plain wrong. While it is impossible to give a comprehensive list in a brief review, here is a few: arguments against defensive programming, don't ship the debug version, avoid boolean arguments, and don't clean up code unless the clean-up is critical to the product's success.

Finally, the recommendation "Make it fast, even if it is not guaranteed to be portable" flys in the face of one of the biggest success stories mentioned early in the book: getting Microsoft to build the Macintosh version directly from the newly created Windows source and sharing 80% of the code (with the accompanying savings) in the process. The truth is, a typical piece of software's life is significantly longer than the hardware it was written for and, therefore, will be ported.

It is possible to write C code so it is reasonably portable, readable, and "modern in every way." In the book's defense, this wasn't strictly the purpose and scope of the book. Instead, the book was "Microsoft's techniques for developing bug-free C programs." In the early 1990's, Microsoft had to deliver software on slow processors with a segmented memory model. I got the sense that some of the recommendations in this book were due to those constraints (which are no longer present--even on Windows machines at this point).

Until and unless MS Press updates the work to relax some of the recommendations obviously aimed at managing primative hardware and immature software I can't recommend this book. If, however, such a revision was made that included those changes and the additions of such notions as Refactoring (Fowler) this could be a valuable resource for C programmers or those who which to develop C coding standards.

Comment Comment | Permalink | Was this review helpful to you? Yes No (Report this)

Share your thoughts with other customers: Create your own review

› See all 42 customer reviews...

Most Recent Customer Reviews

4.0 out of 5 stars Excellent read
Certainly no book can cover all the best practices to write best code but this book has done good attempt. Read more

Published 10 months ago by Prashant

4.0 out of 5 stars Good "old school" book
This book quickly reminded me that the "old school" rules to software development will always apply, no matter how many new labels you put on it (e.g. Agile). Read more

Published 17 months ago by Mark Hurley

4.0 out of 5 stars Old but still relevant today
This book has been recently recommended to me by Amazon based on my previous purchase habits and I decided to go take a look at its description. Read more

Published 21 months ago by Olivier Langlois

5.0 out of 5 stars Too old to read, too good to forget
I would not read this book now but I'm so sorry the author does not write an updated one! This book really changed the way I wrote code.

Published on January 24, 2007 by A. Nahir

3.0 out of 5 stars One of the books to read -- though not the only one
You may not be impressed when you see that this is a Microsoft book. You may get bored at the beginning when all the examples are C and most about memory management. Read more

Published on October 24, 2006 by T. Harris

5.0 out of 5 stars Maguire is my hero
This is hands down, my favorite book on software engineering. If you care at all about writing quality code, you should read this book. Read more

Published on April 14, 2006 by A. Page

1.0 out of 5 stars Just look at the publishing date.
You are looking at a 10-year-old book with a bunch of green screens on the cover. What more can I say. I bought it in preparation for an interview with Microsoft. Read more

Published on September 23, 2003 by Mark Twain

5.0 out of 5 stars Should be mandatory for every professional programmer
This is one of the best books on programming ever written. Maguire concentrates on how to eradicate bugs early in the cycle. At first what he says seems so simple. Read more

Published on July 23, 2003

4.0 out of 5 stars Don't buy this book if you ENJOY debugging code!
Having read a number of reviews of this book several weeks ago
I decided to give it a go! After reading just 2 chapters I was
implementing a number of his suggestions... Read more

Published on May 9, 2002 by Trevor Hand

2.0 out of 5 stars Is this book a joke?
Microsoft's Techniques for Developing Bug-Free C ? I did have once a lecture on developing bug-free code where the speaker used experience at microsoft as an example of bad... Read more

Published on January 30, 2002

› See all 42 customer reviews...

.jsOffDisplayBlock { display: block; } .jsOffDisplayInline { display: inline; } .jsOffVisibility { visibility: visible; } .jsOnDisplayBlock { display: none; } .jsOnDisplayNoneBlock { display: block; } .jsOnDisplayNoneInline { display: inline; } .jsOnDisplayInline { display: none; } .jsOnVisibility { visibility: hidden; } .jsOnDisplayBlock { display: none; } .jsOnDisplayInline { display: none; } .jsOnVisibility { visibility: hidden; }