Winter Driving Best Books of the Month Valentine's Day Shop Learn more nav_sap_SWP_6M_fly_beacon Chi-Raq easycohice_2016 All-New Amazon Fire TV Subscribe & Save Valentine's Day Cards Create an Amazon Wedding Registry Amazon Gift Card Offer chiraq chiraq chiraq  Amazon Echo All-New Fire Kindle Paperwhite Prime Exclusive Savings in Video Games Winter Sports on Amazon.com SnS

Your rating(Clear)Rate this item


There was a problem filtering reviews right now. Please try again later.

on May 2, 2011
The tragedy for books that become classics is that there are many more people who have heard of them (or perhaps also bought them) than people who have read them. In this case, the fact that Steve McConnell's "Code Complete" is approximately 900 pages long doesn't help, either. Even so, this is a book that not only deserves to be read, but also rewards multiple readings.

The Good: McConnell deserves credit for writing the first (and only?) readable encyclopedia of best practices on software quality, covering topics such as how to build classes, use data and control structures, debug, refactor, and code-tune. Yes, it would be nice if the book was updated to include substantive material on languages like Ruby or Python (cf. p. 65, Python "also contains some support for creating larger programs") but, in the words of Gertrude Stein, "Not everything can be about everything" -- though Code Complete does come pretty close. This book contains an astonishing number of practical points on a variety of topics. Here is a quasi-random selection: a) don't use booleans as status variables (chs. 5, 12), b) when you feel the need to override a function and have it do nothing, don't; refactor instead (ch. 6), c) when choosing variable names, avoid homonyms (ch. 11), d) if you decide to use a goto, indenting your code properly will be difficult or impossible (ch. 17), e) trying to improve software quality by increasing the amount of testing is like trying to lose weight by weighing yourself more often (ch. 22), f) make your code so good that you don't need comments, and then comment it to make it even better (ch. 32), and finally the oft-repeated g) you should try to program into your language, not in it (ch. 34). McConnell also sprinkles the text with classic words of wisdom, e.g. "The competent programmer is fully aware of the strictly limited size of his own skull" (Edsger Dijkstra), "Never debug standing up" (Gerald Weinberg), "Copy and paste is a design error" (David Parnas), "Any fool can defend his or her mistakes -- and most fools do." (Dale Carnegie). It is important to point out that even though this volume is encyclopedia-like, it does have both a sense of humor (e.g. "the encryption algorithm is so convoluted that it seems like it's been used on itself") and a clear authorial voice (e.g. "Though sometimes tempting, that's dumb."). Another example of the latter: in ch. 33, after quoting Edward Yourdon at length, McConnell adds "This lusty tribute to programming machismo is pure B.S. and an almost certain recipe for failure".

The Bad: overall the writing is very good, but the occasional infelicity reminds us that McConnell is human (e.g. p. 369 "A loop-with-exit loop is a loop in which", p. 809 "A program contains all the routines in a program."). In a technical book of this breadth, minor mistakes are bound to creep in. For example, in ch. 10 McConnell mentions the different possible levels of a variable's scope in C++, and then adds that in Java and C# one can also use namespaces, thus effectively ignoring the existence of the namespace concept in C++ (which is baffling, given that he then discusses precisely that topic in ch. 11). Another example, this one more serious, is McConnell's recommendation that you should use a pointer - not a reference - if you want to pass by reference in C++ (ch. 13), something which is contrary to C++ best practices (see e.g. Sutter & Alexandrescu, "C++ Coding Standards", Item 25). A less technical point: in ch.2 McConnell criticizes Frederick Brooks for writing (in 1975): "Plan to throw one away; you will, anyhow". I found this to be bizarre, given that in the 1995 edition of "The Mythical Man-Month" Brooks states in no uncertain terms that he has changed his mind on this: "This I now perceive to be wrong" (p. 265). Given that Code Complete 2 was published nearly 10 years later (in 2004), criticizing Brooks for his publicly repudiated former opinion seems improper. On a different note, although some of the on-line accompanying material is fascinating (e.g. the links to the original Dijkstra and Lawrence articles in ch. 17) many of the links are just electronic versions of McConnell's checklists or bibliographies, while some are simply disappointing. To name only a couple of these, as of this writing the link on p. 856 on the economics of XP is a dead link, while the one on p. 76 is downright embarrassing (it links to a google search for "emergent design"). Finally, even though the book has a dedicated website, no list of errata is provided there. If you dig deeper, you can find one on the O'Reilly website, but that is woefully inadequate, e.g. it contains no information on separate printings.

The most common criticism one hears about this book is that any decent software developer should already know the material covered in it. Ironically enough, this is true. To quote Dr. Johnson: "People need to be reminded more often than they need to be instructed".

Alex Gezerlis
33 comments188 of 190 people found this helpful. Was this review helpful to you?YesNoReport abuse
on July 23, 2004
It was a pleasure to find out that this book had been updated when I reads news of it. CC2 is a great one-stop 'place' to go to when you want a great excuse to apply Stephen Covey's 'Sharpen The Saw' principle. This updated version has some solid, fantastic, expert instruction on designing from scratch, whether it's OO, writing better routines, psuedocode, nested loops, or at the higher level: agile methods, etc..
McConnell's approach of talking to you, the programmer, is ideal: not too much humor, and an easy to read, but professional approach in the way he donates the contents of his brain: i.e. McConnell's lengthy experience in the field.

I read just a couple of paragraphs in a chapter before work one morning, and the advice I picked up saved so much time that same day. And it wasn't even specific to coding instruction. It was a piece of advice on a philosophy on how he personally determines how much upfront design he should settle on before coding.

Reading Software Construction material of this caliber, as compared to some, yet another, new book on a specific language that might look impressive to know, is what makes for a solid programmer.

Refreshing your overall S/W construction knowledge gives you so much more of your life back, because you will have way less bugs and a lot more fun maintaining the high-quality code you are now writing because of CC2.
I mentioned already that he covers OO, but I wanted to emphasize the excellent material he offers in this area. I am now seeing the benefit of measuring the quality of your classes by this guideline: are they true Abstract Data Types. ( rather than just trying to use the syntax that the language provides to its potential).
Great job on a rather thorough re-write of a S/W development staple.
22 comments275 of 295 people found this helpful. Was this review helpful to you?YesNoReport abuse
on August 4, 2006
I don't know how much more I can say about this book that hasn't been said already but I will do my best to describe my experience with this book.

Have you ever looked at a class, or a method that seems to work fine but it just doesn't "feel" right? For some reason it seems as if that method or class may be hard to debug in the future or that the code is hard to understand. Or have you gone back to a class file you wrote months ago and you spend an awful lot of time trying to figure out what the heck is going on with that class file? Maybe the methods in the class are spaghetti like in nature, or maybe the names of your methods don't have a very good description so it's hard to figure out how everything ties together. I have had this problem. This book will teach you how to get out of those habits. You will learn what a solid class or method looks like. You will learn how properly naming your classes and methods can greatly reduce complexity in the long run. Everything is backed by hard evidence. I should also mention that this is just one chapter in this wonderful book.

This book really drills down proper programming practices. A lot of times you may read a passage and think to yourself "well, of course!"... but then you realize you don't practice what's contained in the passage you just read. This book is great for both new programmers and experienced programmers alike. New programmers benefit greatly because they will learn how to construct software properly without having to go through all of the hoops. Experienced programmers will also learn a great deal, as well as be reminded that some of their habits that they've developed over the years can hinder production and cause software development to become more complex then it really is.

Steve writes in a very clean style. It's very easy to read. You don't need to memorize anything in a book like this, instead you just need to gain an understanding of the concepts he brings forth. After reading this book I definitely follow a lot of his advice. When I build a new class, method or what-have-you I get a certain feeling of when it seems right and when something seems wrong. I am now much better at analyzing my code and figuring out what doesn't seem correct and I take his advice I learned in this book to help me to figure out - and correct the problem. After reading this book I feel like a lot of my rough edges as a developer have been rounded out. I feel as if I gained a years worth of experience just by reading this book.

This book is friendly for any software developer. The concepts he presents apply to all languages. This is a book that teaches you how to think about programming better and how to construct good solid code. This is one of the best books I've ever read. If you're even thinking about buying this book, then buy it.
44 comments135 of 145 people found this helpful. Was this review helpful to you?YesNoReport abuse
on October 21, 2006
Code Complete pops up regularly on the lists of the 'read this book or you'll never get a job and everyone else will laugh at you' genre, so if you're easily influenced, like me, you may approach this book with an air of duty rather than anticipation. Fortunately, despite its heft, this is well worth the plaudits that have been heaped upon it. I actually enjoyed this more than The Pragmatic Programmer and Programming Pearls, two books often mentioned in the same breath as this tome.

CC covers pretty much every part of the software development lifecycle, from planning to code reviews to testing. These are all pretty good discussions, but the best bit is definitely the chapters on coding. Most of the examples are in Visual Basic or Java, so you'd do well to know one of those languages.

When it comes to object modelling, there's actually a reasonable set of guidelines harvestable from literature, and languages tend to diverge more on issues of packaging, so CC is at its best at the lower level procedural details of code layout, formatting, loop construction, optimisation and so on. Many books claim to provide coding guidelines, but don't do much beyond stating the obvious like (for Java) "use camel case for variable names", "start class names with capital letters" and "avoid Hungarian notation". CC is different because it actually provides useful recommendations. As an example, there's a very good discussion on when and where the use of loop-breaking constructs like break and continue ('next' in Ruby and Perl) are appropriate. Few (if any) other books provide this sort of practical detail.

It's well-written, with just the right amount of humour in its exhortations - the withering references to coders who investigate loop bugs by randomly adjusting the termination criterion up or down by one until it works raised a wry smile from this reviewer.

To summarise, this is a collection of best practices distilled from a pretty huge amount of reading, and is genuinely helpful. I would certainly point any programming beginner at this book.
0Comment23 of 24 people found this helpful. Was this review helpful to you?YesNoReport abuse
on July 23, 2004
Code Complete, first edition, has long been regarded as ?The Bible? for software development. Dare I say, CC2 is even better than the original. It has been thoroughly updated to include OO, internet and web development, as well as new best practices such as test-first development, pair programming, and refactoring.

Steve McConnell provides a balanced, thoughtful discussion of competing approaches to software development. He also provides a wealth of references to additional materials covering specific topics in more detail. In a field that is often defined by religious arguments, CC2 stays objective on most topics. At the same time, McConnell does not shy away from stating his conclusions on topics that he believes have a clear-cut ?best choice?.

Overall, this book is as much of a ?must have? as the first edition and destined to become just as famous.
0Comment30 of 34 people found this helpful. Was this review helpful to you?YesNoReport abuse
on August 15, 2009
A very well-written, seminal book on software construction. It very effectively covers almost all of the important topics in software construction. This book partly also served as a revision of my software engineering classes in university. It very effectively, in fact blatantly reminds us that software engineering is all about managing complexity. However at the same time I have to be honest also in that it is not as "must have" as it is often projected. It also comes from the fact that for someone with 3-4+ years of professional experience, this book is not going to offer that much (though still recommended). With some 3.5 years working in industry, I already knew roughly some 70% of things told in this book. For example all those chapters on coding and naming conventions are not going to offer you much if you haven't already learned these things in first few years of your career. Many practices this book recommends are too good that are too obvious and many practices it condemns are too bad that make me wonder if people are really using them. Some chapters are really awesome, like "Design in Construction" and "Working Classes", some are very good such as "Managing Construction", most of them are good such as "Using Conditional" and "Unusual Control Structures", and a few are so so, e.g. "Layout and Style" , "Refactoring". Another problem with this book is that it is unnecessarily long, and verbose. It is composed of 35 chapters. In places it feels too redundant. In my opinion, the size of the book could have cut down by fixing these redundant things. e.g. why to include chapter 34, and why those Checklist sections? Also note that this book is more about coding than programming, e.g., it does not even remotely discuss data structures or algorithm analysis (Big O and stuff) etc.

Summary: Highly recommended to beginners in professional software development, moderately recommended to people with some experience, and not necessarily recommended to veterans.
0Comment15 of 16 people found this helpful. Was this review helpful to you?YesNoReport abuse
on July 23, 2004
Code Complete 1 completely changed the way I wrote programs in the mid 90s. Reading CC1 made me realize that I was still an amateur programmer and reading it marked the beginning of my career as a professional programmer. In more recent years, much as I liked CC1, the book began to show its age, and the examples especially started to look dated.

I pre-ordered CC2 and have spent the past 2 weeks devouring its contents. CC2 does not disappoint. McConnell has once again distilled his insights into a practical handbook that should be on every software development professional?s bookshelf.

CC2 provides numerous benefits: it?s a complete software-construction reference. It provides dozens of checklists. And it contains no hype. It?s valuable to beginning programmers, team leads, and technically oriented managers. The tone is conversational with just the right amount of humor. Throughout the book, it?s clear that Steve has ?been there, done that.? Thank you Steve!!!
0Comment14 of 15 people found this helpful. Was this review helpful to you?YesNoReport abuse
on March 23, 2006
Code Complete by Steve McConnell is the convergence (the crossroads) of experience, research, and theory. This book is invaluable, the Holy Grail of programming reference books. McConnell's writing style is clear, concise, easy to understand and often humorous.

Programmers on every level (from introduction to master) will benefit from reading this book. Programmers at the introduction level may find some topics advanced, but references to additional resources are close at hand. This book covers a broad range of interconnected topics ranging from: variable names, code-tuning, personal character, managing your manager, gonzo programming and much more. The emphasis is always on successful software design techniques.

McConnell doesn't shy away from presenting hard data and details; he nails the "whys" that so many other texts avoid.

Selected quotes from Code Complete:

"People have already made all the mistakes that you're making now, and unless you're a glutton for punishment, you'll prefer reading their books and avoiding their mistakes to inventing new versions of old problems." (Chapter 35)

"Once a programmer realizes that programming principles transcend the syntax of any specific language, the doors swing open to knowledge that truly makes a difference in quality and productivity." (Preface)

"The value of hands-on experience as compared to book learning is smaller in software development than in many other fields" (Chapter 35)

It's interesting to note that Code Complete is a required read to become a practitioner (intermediate) level employee in McConnell's company (Construx).

Code Complete is often compared with The Pragmatic Programmer: From Journeyman to Master [Hunt, Andrew, and Thomas, David]; the topics covered in the Pragmatic Programmer are a small subset of Code Complete. Code Complete is consistently written at a higher level, and offers more references for continual research and professional development. But don't take my word for it; read both, the Pragmatic Programmer makes a good prerequisite to Code Complete.

Hailing this book as "The Holy Grail of programming references" may seem fanatical, but I have yet to find a book that remotely measures up to Code Complete.
0Comment27 of 32 people found this helpful. Was this review helpful to you?YesNoReport abuse
on October 17, 2011
I bought this book in papaerback and I thougt it was OK, not great but I have been slinging software for forty years mostly on mainframes so very little is totally new, I then got a kindle version and I am really dispointed since the charts and graphs are pretty much useless and cost of the Kindle version is high compared to other books (I have 290+ kindle books). I cannot recommend it.
1111 comments48 of 59 people found this helpful. Was this review helpful to you?YesNoReport abuse
on September 24, 2004
When the first edition came out, I grabbed it off the shelf and read every page. The second edition is updated and even better. It includes current technologies and approaches and updates the information, not like some "updates" that just change a couple new words here and there. This is the new bible for code development. Excellent gift idea for anyone that doesn't already have it. I passed the first edition on to someone else and the second edition took its place on my bookshelf.
0Comment68 of 85 people found this helpful. Was this review helpful to you?YesNoReport abuse