Rating: 
Summary: The single best programming book I ever bought - NO fluff
Review: I cannot understand the previous reviewer's complaints about this book. It is a dense, somewhat demanding read, but I found NO fluff at all - yes, there is some theory, but I found it all very logically explained and completely practical and applicable to my everyday life as a programmer. The careful study of this book will pay great dividends. I'm largely self taught, and found I still had a lot to learn when I got my first programming job. This book has made my life as a programmer MUCH easier, and I believe has made me a much more valuable asset to my company. Most of the other reviewers have said it all - I cannot recommend this book highly enough. Thank you, Steve McConnell!
Rating:
Summary: If you don't have it, get it!
Review: Out of the dozens of programming books I've read, this may well be the most useful. It covers basic software engineering practices that every serious programmer should adopt. Unless you're coding in a cave and never look at old code, you owe it to yourself and coworkers to read and apply the principles in this book.
Rating: 
Summary: Full of fluff Waste of time reading, waste of money buying
Review: This book seemed like an interesting book upon skimming, but as I tried to delve deeper into it I realized there was little in this book that can really help me write better code. It's all theory and abstract suggestions. A much better book is 'Writing Solid Code' (also in the same series) which is only half as thick but probably has 100 times more 'meat'. I'll bet most of the reviewers here wrote their reviews before actually digesting much of the book!
Rating:
Summary: Excellent practicle book
Review: Though it's been over 6 years since I read this book, I still rate it as the most effective book I've ever read to improve my coding skills. This is truly a classic that every programmer or programmer wanna-be should read.Not only is the content excellent, but the writing makes it a thoroughly enjoyable book to read. You'll see errors you (or the coder next to you) have made highlighted throughout the book. Another coder and myself read the book at about the same time, and we literally used it as our Coders Bible for the next 2 years. We had countless arguments (more intense than most religious doctrinal debates) on the best way to construct our code. This book was the accepted final authority for us. I highly recommend this book to every junior programmer I come in contact with (or hire). It will help them avoid many of the errors most of us have learned the hard way.
Rating:
Summary: A Definitive Guide to Software Development Fundamentals
Review: More time spent getting the fundamentals of software development right could save industry a fortune, certainly more and switching to the latest language or develpment technique. I've been developing software in various languages for twenty years now. In all that time I've found that there are very few books about software development (as opposed to language manuals) that have stood the test of time. Steve McConnell has written two of them this and 'Rapid Development'. Code Complete contains an absolute wealth of information and guidance on how to develop commercial quality maintainable software. Everything is covered from designing to naming conventions to reviewing to testing to deploying. The impressive thing is that there is very little advocation of particular techniques (it's more important to have one than what it is). I've made a two page tick list of checks that I regularly print off and hand out to people before code reviews and it's surprising how often the reviews are postponed so that people bring their stuff up to scratch. None of the items on the list are particularly specific (e.g. Are loop index names meaningful (except for small loops)? or Do all method and functions include comments explaing their purpose?). Unfortunately, there are very many programmers out there who can write code for small tasks (e.g. exam questions) but who struggle when it comes to a commercial project and the situation hasn't improved over the years. It's not because they're stupid but because they're not being given a proper grounding in the fundamentals. Lots of companies send their programmers on courses to get them up to speed on particular languages but few spend any time making sure the programming basics are up to scratch. Given that the situation isn't likely to change very fast, this book goes a long way to redressing the balance. It should be on every programmer's bookshelf (regardless of the programmin language they use) along with Rapid Development, Design Patterns and Refactoring.
Rating:
Summary: A gift to the software community
Review: Every software developer should read this book. It is concise, well written, and useful at every stage of software construction. There are at least 3 copies floating around the office. As developers browse through other people's copies, they realize that it's a great book to have. The only drawback, and this is just a sign of the book's age, is that it works primarily for procedural driven languages. This is almost assumed from the beginning, since Object oriented languages were much less developed then. An updated version for OO is necessary and would definitely be welcome. The book describes practices how an individual programmer can make themself better at building software. By necessity, this overlaps other facets of software development, including managing projects, but the bulk is for the individual programmer. I can't tell you how much this has effected my personal practices. It makes a world of difference, especially to the middle of the road programmers, which is the biggest group in the software community. As Mr. McConnell says, the best programmers take a lot of this material for granted, and the worst think that they don't need it or that it doesn't exist. As a result, a lot of the practices go undocumented and are lost to those who could benefit from them. They are in this book and clearly spelled out and well organized. If you are programming for a living, and want to get better at it, this is the book for you.
Rating:
Summary: Great Book; Even Applicable to Web Development
Review: The book is fantastic. I have no formal training as a programmer, so this book helped me develop a much stronger understand of not just how to program, but how to program well. As for the applicability of this book given the advent of the web: the book is still useful. A web application may not be one big compiled program, but it is, some claim, an object that has urls as methods and get/post/cookie data as arugments. While web programming is different from monolithic programming in may ways, the lessons I've learned from this book have helped a great deal in the development of several web applications. Sure, a new edition would be welcomed, but it is not required.
Rating: 
Summary: A classic
Review: You can see all the other comments to determine if this book is for you. (As far as I'm concerned that group includes everyone who is a programmer who has not read it yet (). While most of the advice does not age, the internet and WWW as we know them today have happened since this book was written, and distributed (i.e. web, client/server, etc) programming has all but eclipsed monolithic software. An update showing the important principles of sanely developing distributed and web apps would be very appropriate - particularly since web development is new and easy to get started in, and therefore attracts new or inexperienced developers in droves.
Rating:
Summary: Good but very verbose
Review: This book goes over development practices that all programmers should know. The only problem I have with this book is how verbose it is. There is alot of repitition of ideas. This book should really be half the size of what it is.
Rating:
Summary: Professional Development
Review: For those that have been in the software game for some time know, most "professionally" written code isn't! If you are serious about your professional development, this book is a must for your library. Its "common sense" approach to software construction, backed up by key studies, data, and observations, is something that most professional programmers (I've seen) lack. It has changed several of my habits for the better and has allowed me to indoctrinate newly hired programmers in fundamentals that might otherwise have taken them years to discover and internalize.
| 
