Besides agreeing with the other reviews all I can say is that this text has made me a better programmer. Truly.

Though this book is filled with debatable opinion and redundant information, it's an important read. Read it if only to keep software engineering topics fresh in your head. Otherwise, if you are already experienced, it's kind of elementary.

There is probably not a whole lot to say about this book that has not been said already, but it certainly deserves another positive review nonetheless.

I bought this book thinking that I did not have a whole lot to learn from it. I was certain I had read enough 'better coding' material in the past to know what good code was and how to produce it. I am sure you will not be surprised when I say that I ended up having a great deal to learn from this book.

Almost all of the coding advice, design strategies, and debugging techniques are backed up with real research data. At the very least, this means that even if you know the advice is sound already, you can more easily introduce the topic to other programmers, or even to management, and it has a greater chance of being taken in to consideration.

After reading this book, my code quality has definitely increased. I discovered that even the good practices I knew of before were not being put to effective use.

The book is very specific. It does not typically give you vague advice that sounds good if you don't think too hard about it. It gives you very specific, concrete advice, with examples and data to back it up.

The author seems to have put a great deal of effort into writing this book for every type of programmer (and even for people in software management positions). Every chapter introduction describes who should definitely read the chapter and who might benefit from simply skimming it over. He will also direct the reader to other chapters or specific sections of the current chapter based on the reader's knowledge and experience levels.

Finally, as others have said, I consider this a must read book for any programmer.

Code complete is the right title for this book. Sadly most people find it extremely hart to read it. Its great as a reference but reading it word for word is as interesting as watching grass grow. Don't get me wrong. This is a great book. Everyone should at least hold it for once. But do not try to read it as a book. The first 300 pages will be boring. When the actual code chapters begin it gets better but still tends to be tedious.

A great book for beginners but a little boring read for advanced users.

When I bought this book, I couldn't believe all the 5 star ratings in the reviews. But, now that I've finished it, I have to agree with them. Simply put, this is probably the best computer-related book I've read. In the book's 850 pages, I found a grand total of five minor problems: one was grammatical, two were typographical and two were minor disagreements with how some things were presented. All trivial. Content-wise, if the universities would teach this material and if programmers would follow the methodologies contained in the book, the world of software would be far, far better off. I HIGHLY RECOMMEND this book and rate it an Excellent 5 stars out of 5.

for all programmers. Shall I say Application Developers? Software Engineers? Whatever the title is, programming jobs are alive and well! This book provides a solid foundation. It is too bad very few American students are interested in this profession.

The average students are all studying business marketing. The good students are studying finance.

At Harvard University, they do not teach Accounting. The best ones, study Economics. There are only 21 students studying Computer Science at Harvard. Yet, parents are paying $220,000 to Harvard and other Ivy League. Truly amazing!

Is there anyway we can change this trend?

This was a great book both for me and my team. I've been in the software industry for many years. I started building a team of developers and needed an easy way to bring novice and experienced programmers together on a similar set of standards. This book provided us with the perfect framework from which to start our team. We've developed several major projects using the principles in this book and have experienced a great deal of success.

One warning, the book gets a bit tedious after the first half. If you're looking to improve your C programming skills, it gets really detailed into pointers and other fun, or not, stuff. Also, the examples are in VB.NET...but you still get the point.

If you're an experienced software developer or a newbee in the world of commercial computer programming this book will give a good kick in the right direction. Steve McConnel will keep you hooked by mixing the right guiding concepts with real-life knowledge and examples.

I'm currently studying computer science and have been reading this in my spare time. Skip your lectures. Just read this book! If you want to construct software in a timely, efficient, and complete manner--this is the definitive book to read. Not dry at all, Steve McConnell covers topics for all experience levels. Even if you're an experienced programmer, you will learn something from this great piece of literature.

I've only gone through the first few chapters thus far. So pending finishing my reading, I'll update this review. Unfortunately this might never happen as I find myself re-reading portions of the book to pick up new ideas and details for software construction!

it's a book that all programmers must to read. it explain a lot of interesting things about how to made good software!

I started by reading the first edition of this book. I got the second edition when I was almost finished with the first edition of this book.

After getting the new version of the book I decided to continue reading the old one because I found that there are quite a few differences between the old and the new edition.

This is perhaps one of the best books that I have ever read on programming in my life. The author Steve McConnell has put together a book that is independent of what ever programming language that is used. In the authors words. He wanted to write a good book on software construction because he had looked around and had not found any good books out there on the subject. I would have to agree with him there are not a lot of books on good programming technic. There are hundreds of books on this programming language or that programming language.

Code complete is so good that I feel every programmer should read it. It would be best if in the first year of college every single student read the book. I just don't know how it could fit into a regular curriculum. Even if it does not fit that well into a regular curriculum what is taught in this book is probably more important then what most people learn at school.

I like the book and would advise it to anyone that programs.

I am looking forward to the new edition because the old book didn't have much advice about object oriented programming. Mostly because it was a new way of programming when the book was first written and he didn't want to commit much information to it when object oriented programming was so new. He does talk a little about things that are outdated but the book is still one of the best.

I will wait a while before I read the second edition but I expect to be as satisfied with it as I was this one.

Great book that should be in every programmers library.

This is an excellent resource for any one who wants to go past simply writing code. Managers from a non software background who are put in charge of software teams would do well in reading this as it gives a very thorough description of what good software is all about.

Often called "'The Joy of Cooking' for coding", Code Complete is an excellent book that doesn't say HOW TO code, but is ABOUT coding. Considerations with project size and complexity, coding style, comments, testing strategies, even developer communication are all touched upon.

Many things won't click with people who don't have at least a year or two of development under their belt, but for any kind of programmer, this book contains many gems that are worth referencing for years to come.

This is a great book for all programmers, from beginners to experienced. It covers a wide-range of practical topics on producing better code, many of which have been around for years - but were known only by a select few.

The book is very simply wrtten and doesn't attempt to preach - it just provides lots of practical examples of writing better code. You don't need to read it cover-to-cover, just find what you're interested in and it's there.

Given the demands of today's software development environment, namely high-quality code in ever-decreasing timeframes, I recommend this to anyone who is serious about their profession.

The first edition was one of the few books I keep within arm's reach. This update is even better. If you're a programmer, you probably need this book.

This book covers a lot of great ideas. It is easy to read because it is full of relevant examples. It is not dry or boring (Even if you have an understanding of the topic). It also gives guides on what you can skip over if you are familiar with the topic.

We use this book in our Software Design and Analysis class. Everyone seems to find it useful. And although it is a Microsoft Press book it gives examples in other languages. It is mostly Java and C/C++.

This book is targetted for software programmers. It advocates that the primary goal of the developer is to manage complexity, and I fully agree with that! It discusses several topics while providing good and bad examples: naming, coding style and organization, code tuning, refactoring, requirements and planning, testing debugging. I highly recommend it!

This book is quite simply a must read for anyone in the programming field. The chapter on debugging is worth its weight in gold. My copy is riddled with sticky notes marking key topics. McConnell's writing style is entertaining and very educational; he says what he needs to say and doesn't bore you along the way. There is really no other way to put it: if you must buy one programming book this is it, at least until the third edition comes out.

Buy it. Study it. Live IT. Your career will take off because of the insight provided.

If you're looking for a humorous, clever tome about coding, this is not your book. If, however, you are looking for thorough, well laid out, research-backed coding solutions and advice, then this book is an excellent addition to your library. The examples are based upon C, but suggestions are readily understandable by coders using any OOP compiler.

My only disappointment was to find that some coding practices I've been using for the last 10 years or so he is now recommending against. Actually a few of them I would be glad to give up (large comment blocks at the beginning of scripts) but others are well ingrained. I can see his argument, but it will take a while for this old dog to relearn those new tricks.

If you are writing software today (I don't care what language you are using, or what hardware) you should own -- and read -- this book. I have not found any other book that even compares.

It goes through how to write maintainable, readable code, with excellent descriptions of why to code that way. Plus it is language agnostic (the book uses a couple of languages for illustration purposes, but you have to start somewhere).

One side note: if you are doing function programming, pick up the first version of this book. This version was written for all of the object oriented languages out there.

I encountered the first edition of this book back in the mid 1990's. The opinion I had of it at that time has not changed: Steve McConnell's "Code Complete" is a "must read" book for anyone developing or maintaining software, particularly those in senior and leadership roles - Sr. and Lead Developers, Software Architects, Managers, etc.

"Code Complete" is a distillation of years of experience on Mr. McConnell's part, backed up with research and references from a wide variety of sources, including research papers, journal articles and books. His style is easy to read, he focuses on the practical aspects of the development process, presenting the pros/cons and applicability of each of his recommendations in a solution-focused manner. This isn't a book marketing some theory of what's best, but really concentrates on what works, what doesn't, and how to excel as a software development professional. His points and recommendations are clear and well-supported - and will often be eye-opening material for the reader, no matter how experienced they are in this industry.

"Code Complete" focuses on software development as a discipline, and encourages the reader to think of it as a major component of the overall software development process, including not only the initial specification / design / build / test and deploy cycle, but designing and building the code to enhance its long term "maintainability" and "enhancability". --- The initial deployment of an application is only the first step in its lifecycle: Mr. McConnell makes the strong case that designing and building an application without concern for its long term impact and viability is an expensive mistake.

It's been so long snce I read the first editon "Code Complete" that I cannot compare or contrast the two, but I can say that reading this edition has reinforced and expanded-on many of the practices I adopted years ago as a result of reading this volume and Rapid Development. It is clear the author has kept abreast of the latest research and best practices as the science of software development has evolved since the first edition was published.

When this book first came out, I strongly recommended that my team read it, and have recommended so many times for new developers and especially senior members of subsequent projects I've led. That recommendation stands - and, if anything, is even stronger: frankly, anyone who aspires to a leadership role in software development efforts and who has **not** read this book is needlessly handicapping their ability to succeed in this industry.

I have not heard of this book being used in a college course, which is perhaps understandable, given that it is designed for the benefit of professionals already out "in the field" - but it should be!

It is quite rare that one of those books comes along that is about as close to perfect as possible, but this one definitely fits! I think that anyone who programs at all should be REQUIRED to read this book. I cannot even begin to describe how much my coding skills improved by applying what I learned in Code Complete. Steve McConnell's writing style is extremely effective and easy to follow, and he gives countless real-world examples to illustrate his points. The world really needs more software books like this one.... heck, any book like this one. I'd give it 10 stars if I could.

Inded, this is the ultimate guide to software development in the industry. Covering all general practices in development while maintaining good platform independence (though some understanding of .NET is a good idea). If you're a developer and need to buy one book, buy this one, the rest of it's online somewhere but this stuff is "expert experience in a book".

This is a great book for those who work in software development. It covers a lot of ground (from design to loop, from debugging to naming variables) and it's very easy to read.

I cannot tell more comments as almost all have been covered in other reviewers'. But, truly, purchasing this book will not waste your money at all! Very good coverage on how to do good software construction, from very beginning. It is really from practical perspective, not from academic perspective (which sometimes unrealistic when it goes to real implementation).

Now I can see which ones are good software developers and which ones are not :-)

This is by far the most important book for anyone who writes code. After reading this book you'll feel like the best programmer around. I used to think I wrote good code until I read this book. It has really showed me how to write great code. If you have never read this book you absolutely have to.

When I first bought the book I started in the chapters about variable names and comments and eventually went back and read the earlier chapters. If the first few chapters turn you off to the book try hopping around at first and come back to those chapters.

Code complete is an excellent insight into the mind of an experienced developer and what a successful software project must have. Certainly required reading for anyone running large to small software projects.

fantastic book. good for anyone who programs. even people who suck at it will take this book and love it. unless you are really stupid. but i doubt that. i bet you are very smart.

I feel that this book has some holes in it. In some areas where I do have some understanding of the topic, McConnell I believe misses the mark. As an example, let me contrast CC2E's advice on speeding up your programs with with advice provided by by Alex Martelli (Martelli is "Uber Technical Lead" at Google). In Martelli's excellent book Python in a Nutshell, when discussing optimization, Martelli focuses almost exclusively on a dicussion of the big-0 (how an algorithm is proportional to N; log N, N, N log N, N squared, etc). He goes on for pages in detail about the topic and says "do yourself a favor and watch out for the big-O: all other performance issues, in comparison are almost always insignificant." The book "The Pragmatic Programmer" also dissusses O(N) issues quite a bit as well. In Code Complete 2nd edition, there is no discussion of the big-O at all that I can find, or any mention of algorithms being proportional to some function of N. I cannot find it even mentioned. This is an incredible oversight. If CC2E is missing something that important, then I'm suspicious of what else it is missing.

I feel that this book has some holes in it. In some areas where I do have some understanding of the topic, McConnell I believe misses the mark. As an example, let me contrast CC2E's advice on speeding up your programs with with advice provided by by Alex Martelli (Martelli is "Uber Technical Lead" at Google). In the Martelli's fantastic book Python in a Nutshell, when discussing optimization, Martelli focuses almost exclusively on a dicussion of the big-0 (how an algorithm is proportional to N; log N, N, N log N, N squared, etc). He goes on for pages in detail about the topic and says "do yourself a favor and watch out for the big-O: all other performance issues, in comparison are almost always insignificant." In Code Complete 2nd edition, there is no discussion of the big-O at all that I can find, or any mention of algorithms being proportional to some function of N. I cannot find it even mentioned. This is an incredible oversight. If CC2E is missing something that important, then I'm suspicious of what else it is missing. Another piece of advice McConnel offers is regarding the use of exceptions: he says only use them for truly exceptional cases. This is more bad advice, as the traditional "Look Before You Leap" (LBYL) has many defects that the "Easier to Ask Forgiveness than Permission" (EAFP) approach does not have. Google "python eafp lbyl" and you will find excellent discussions by Alex Martelli of why EAFP is superior. I just feel this book is out-of-date, even in it's 2nd edition; I have the 1st edition too and there has been very little updating, certainly not much at the level of programming paradigms.

This book turned to be exactly what I expected. It's one of few books that I have that is fun to read. It's not just a practical guide for software construction, but it also points out everything you need to know about software development cycle if you don't already know them.

The actual talk about software construction starts at chapter 5. The chapters before this is an emphasize on the importance of software prerequisites and its impact on projects success.

The book is a must for anyone involved in software development. And it's an extremely important guide for new project managers as it points out all steps involved in the software development process

This book provides an insightful read for programmers of all skill levels. It has already helped me improve in my quality by applying some of the thought processes to my work and I'm only half through the book!

Quite an odd book. I can understand why it's so highly rated BUT
reading it cover-to-cover is tedious. However, what sticks in the mind *does* make a difference when coding. If you can't remember the actual advice it's enough of a prompt to dip back into the book.
If the point of the book is to enable a more experienced programmer to create more then it delivers hence the 5 stars I have given it.
However, it's format might put some people off and the first read through for, perhaps, beginners, might be hard going.

Good service, recieved the item in exactly the same shape as said on the site.

This is a must read for all software developer who wants to write production level code.I have read this book Cover to Cover once and plan to do it once again.
I am sure your code will improve day one if you strongly believe what is written in the book and follow the advice

This book is a must-have for the professional developer. It contains an excellent collection of knowledge items which will give you a better grasp of the bigger picture.
We all have "seen the trees", plenty of them. But sometimes you ask yourself: How big is the forest? This book gives a rough idea of the knowledge scope for a decent software engineer.
In addition, many ideas or suggestions you might have come up with throughout the years, this book will validate/destroy. If you are good, you will keep "agreeing" with the book, cursing the fact that you did not read the book before you came up with your own solution. If you are not so good, this book will teach you how to better yourself.

Don't think twice, just buy this book. This book has the knowledge that they didn't have the time to teach in all those computer science classes. Its worth it just for the overview of software architecture and use of pseudocode. If you write code, buying this book is a no brainer. Thanks Steve McConnell!

Code Complete is full of great information about quality coding practices. It should be required reading for any programmer.

It's amazing how much common sense, best practices and good advices is packed in this book.

This book presents numerous tips, hints and practices that minimize the effort needed to understand and maintain software code. The author seems to be a strong advocate of self-documenting code that doesn't need comments to explain its purpose. As a result, his suggestions are mostly centered around this idea. Sometimes he tends to take things to the extreme (e.g. declaring a class that includes a separate object that implements it), but most of his ideas and propositions make sense.

The author sometimes repeats a lot of his suggestions and tips in some form or the other, which may get annoying. This does however, allow the reader to read the book in a non-sequential fashion.

Occasionally, the book may present contradictory suggestions. At one point for example, the author strongly advocates passing individual parameters to routines in order to enhance decoupling (instead of passing objects that contain these parameters). At a later point however, he argues (correctly) that passing objects into routines is OK if it satisfies the abstraction of the routine. A more consistent picture would be nice to have in future editions.

Overall, a great book for those looking to improve their coding styles and practices.

This dense tomb has insights on software development packed into every page. You could base an entire career off of it.

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.

I first read this book when it was published, and I was just graduating college. Since then I've built software in C, C++, and Pascal. I've built hardware with verilog and VHDL. I've built testbenches with Vera and E. This is the most relevant book, and I still have it on my shelf to loan to new graduates. It helps you to understand all of the most important concepts for developing hardware and software with any language imaginable. With all this, you would think that it is hard to read. But this book is written in an enjoyable style, a rare quality in engineering of any kind. Read it!


Marina Kushner
Author
The Truth About Caffeine: How Companies That Promote It Deceive Us and What We Can Do about It

As the title specifies, this book is COMPLETE, yes, sometimes is too generic, but I'm impress of the amount of information it contains. Very well organized, I recommend to read it and then keep it as reference (it contains a lot of information links as well to keep improving)

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 aweful 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 habbits. 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 coarse!"... 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 habbits 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.

I have spent the last few weeks reading this book. On one hand the book is easy to read and presents a lot of good material. But it really reflects mainly what I learned in my undergraduate curriculum. I did not see a lot of new material, but I have also met many who did not practice these things. The best thing about the book is the checklists. They are great starting points for making your own checklists and put together a lot of things that are easy to overlook in the moment of creation.

If you're serious about taking your programming to the next level, converting from being a programmer to an analyst, this book is for you. It spends a little time describing the problem definition / requirements gathering / architecture specification processes, but where it sinks its teeth in is in developing both solid and maintainable code. I've been writing code for years as a primarily self-taught individual and this book really nails down best practices for developing code. I'm so happy with this book that I'm ordering Rapid Development by the same author.

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.