high quality Code outlet sale Complete: A Practical Handbook of Software Construction, sale Second Edition outlet online sale

high quality Code outlet sale Complete: A Practical Handbook of Software Construction, sale Second Edition outlet online sale

high quality Code outlet sale Complete: A Practical Handbook of Software Construction, sale Second Edition outlet online sale
high quality Code outlet sale Complete: A Practical Handbook of Software Construction, sale Second Edition outlet online sale_top
high quality Code outlet sale Complete: A Practical Handbook of Software Construction, sale Second Edition outlet online sale__after
high quality Code outlet sale Complete: A Practical Handbook of Software Construction, sale Second Edition outlet online sale__below
high quality Code outlet sale Complete: A Practical Handbook of Software Construction, sale Second Edition outlet online sale__left

Description

Product Description

Widely considered one of the best practical guides to programming, Steve McConnell’s original code complete has been helping developers write better software for more than a decade. Now this classic book has been fully updated and revised with leading-edge practices—and hundreds of new code samples—illustrating the art and science of software construction. Capturing the body of knowledge available from research, academia, and everyday commercial practice, McConnell synthesizes the most effective techniques and must-know principles into clear, pragmatic guidance. No matter what your experience level, development environment, or project size, this book will inform and stimulate your thinking—and help you build the highest quality code.

Discover the timeless techniques and strategies that help you:

  • Design for minimum complexity and maximum creativity
  • Reap the benefits of collaborative development
  • Apply defensive programming techniques to reduce and flush out errors
  • Exploit opportunities to refactor—or evolve—code, and do it safely
  • Use construction practices that are right-weight for your project
  • Debug problems quickly and effectively
  • Resolve critical construction issues early and correctly
  • Build quality into the beginning, middle, and end of your project .

About the Author

Steve McConnell is recognized as one of the premier authors and voices in the development community. He is Chief Software Engineer of Construx Software and was the lead developer of Construx Estimate and of SPC Estimate Professional, winner of Software Development magazine''s Productivity Award. He is the author of several books, including Code Complete and Rapid Development, both honored with Software Development magazine''s Jolt Award.

Product information

Brief content visible, double tap to read full content.
Full content visible, double tap to read brief content.

Videos

Help others learn more about this product by uploading a video!
Upload video
Brief content visible, double tap to read full content.
Full content visible, double tap to read brief content.

More items to explore

Customer reviews

4.6 out of 54.6 out of 5
889 global ratings

Reviews with images

Top reviews from the United States

Brett Sanders
5.0 out of 5 starsVerified Purchase
Comprehensive, scientific, well-organized and monumental
Reviewed in the United States on November 23, 2017
This book deserves 5 stars because it is a comprehensive analysis of software construction, it is objective and scientific, it is well-written and well-organized and it carries a lot of weight in the software industry (yes, this is important). Comprehensive... See more
This book deserves 5 stars because it is a comprehensive analysis of software construction, it is objective and scientific, it is well-written and well-organized and it carries a lot of weight in the software industry (yes, this is important).

Comprehensive Analysis of Software Construction
This book’s scope is the “construction” of software which primarily includes detailed design, coding, debugging, integration and developer testing. According to McConnell, there wasn’t a book written on the construction aspect of programming at the time of writing the first volume (in 1993). Also, according to McConnell, construction is the most important part of programming as it takes up the most time, it must be done, and it has the biggest impact on the success of a project. To sum it up, this book touches on everything you need to know during the construction phase and has a chapter devoted to each topic. My favorite chapters are Chapter 6 (Working Classes), Chapter 21 (Collaborative Construction) and Chapter 33 (Personal Character). Go look at the table of contents if you don’t believe this book is comprehensive.

Objective and Scientific
McConnell backs up most of his claims with scientific evidence (referencing the results of different programming studies) throughout the book. He is also objective and presents dissenting opinions when there isn’t a clear winner. He is also honest when there isn’t much evidence to support his claims (for example, there isn’t actually much evidence backing up his documentation techniques even though they are probably best practice). This builds trust between the reader and the author. We know he has done his due diligence and we don’t need to go fact check everything. His technique of backing up opinions with scientific studies is surprisingly lacking in most software communities. It makes me realize how often we spout opinions without backing them up with hard data.

Well-written and Well-organized
This book might be dry at times, but it’s very well-written and well-organized. You can skip around to different sections and use it more like a reference instead of reading cover-to-cover if you’d like. My favorite parts of its organization are the ‘Key Points’ highlighted throughout the text, the checklists and key points at the end of chapters, and helpful code examples which reinforce his points. Also, I love his metaphor that you should organize your code in a similar logical structure that you would organize a book (with table of contents, sections, chapters, etc.) Some will say the book is repetitive (and it can be), but repetition is important because you rarely remember anything after reading it once. Repetition is the way ideas are reinforced and remembered.

Carries a Lot of Weight in the Industry
Some might argue this shouldn’t be a factor when reviewing a book, but I disagree. When you are newer to the industry (I’ve been programming professionally for around 2 years), you need to learn from the best. The way you identify who is best is by someone’s reputation and status in an industry. This book (and McConnell himself) are held in high esteem by very influential people in the industry. This matters because you can trust the concepts he is advocating and move quicker in your learning.

Conclusion
Overall, this book is a must-read for programmers and will probably have the best ROI for programmers who have been working professionally for 1-2 years (because you’ve seen some of the good and some of the bad practices that McConnell talks about). Yes, this book is long, sometimes dry and repetitive, and some advice is obvious. But it absolutely helps give more confidence when constructing software, when giving code reviews, and when forming a culture of good habits on your team.

The main takeaway is this: your number one goal as a programmer is to manage complexity. Make things easier to understand, more readable and more maintainable - it will save time in the long-run. We spend much more time reading code than writing code. It’s important to think about the programmer who will be reading and maintaining your code (a lot of times it is yourself). We aren’t smart enough to understand entire codebases and we are limited by our brains. Use techniques like abstraction, encapsulation, self-documenting code, and collaboration with other programmers to make your code better.
38 people found this helpful
Helpful
Report
Roger Ngo
4.0 out of 5 starsVerified Purchase
Great for the early career developer.
Reviewed in the United States on September 23, 2017
Here’s another book I read during the earlier years of my Software Engineering career a few years back. Being a remote worker early on in my career meant that it was hard for me to actually get good actual mentorship and advice from fellow engineers. To compensate, I picked... See more
Here’s another book I read during the earlier years of my Software Engineering career a few years back. Being a remote worker early on in my career meant that it was hard for me to actually get good actual mentorship and advice from fellow engineers. To compensate, I picked up Code Complete 2nd Ed. as a recommendation online. 

It’s a dense book, but all is worthwhile information for the developer who is just getting started in the industry. The material spans across all areas of “software construction” — that is, the process of implementation of the software project itself. Areas are not limited to the following: writing high quality methods/functions, variable naming, how to write clear loops, refactoring, debugging and being practical on trade-offs of performance and style (a short debate on GOTO is talked about here) during implementation.

There is a lot of material, and I won’t really spoil it all here. Just keep in mind that it isn’t a book where you would have to read cover-to-cover. I think it’s best read in pieces. Pick out the topics that interest you the most. For me, it was debugging. The scientific method type of approach to debugging described in this book has been my approach to debugging for years now… It has made me effective in fighting bugs and has made me a better
team member in a software team overall.

For the early-career developer, this is what I would almost consider, required reading.

Now, is this the book to read if you have lots of software development experience? Well, that depends. Ask yourself honestly… do you have 10 years of the same 1 year of experience? Or, do you have 10 years of cumulating experience where year-after-year, you are constantly improving yourself? If you are the former and look to moving onto the latter, then definitely read this book.
33 people found this helpful
Helpful
Report
thinkingotherthings
4.0 out of 5 starsVerified Purchase
Great intro to software design concepts
Reviewed in the United States on February 8, 2020
I''ve been programming in data analysis roles for a long time, but without a formal background in computer science or software engineering. I found this book to be a really nice introduction to fundamental software design principles, and it has definitely improved my... See more
I''ve been programming in data analysis roles for a long time, but without a formal background in computer science or software engineering. I found this book to be a really nice introduction to fundamental software design principles, and it has definitely improved my programming. Some people say that data science / machine learning programming is too different from traditional programming to benefit from the same principles, but I disagree. If you do not have a formal background in software engineering, this book (along with Head First Design Patterns) will make you a better programmer.

I gave 4 stars instead of 5 because I would have liked to see more real-world examples of some of the concepts; also there is a good chunk of the book that is not all that relevant for my work. But overall I would still highly recommend this to those that program in their daily work but don''t have a formal CS / software engineering background.
5 people found this helpful
Helpful
Report
Pamela Pierce
5.0 out of 5 starsVerified Purchase
Excellent even though it''s old
Reviewed in the United States on December 3, 2019
Use this book to make a decision for you or your company on the programming standards you want to follow. This provides clear statistics and reasoning behind the choices. Don''t let it be a guess. This is a well-structured book that is easy to grasp for anyone.... See more
Use this book to make a decision for you or your company on the programming standards you want to follow. This provides clear statistics and reasoning behind the choices. Don''t let it be a guess. This is a well-structured book that is easy to grasp for anyone.

This book talks about Java and C++, with some VB and ADA, very little of C# which is what I am using it for, but really the principles are the same for all. It is aimed at programmers and managers, not architects. It covers a lot that is very important to the beginning or advancing programmer, or in my case, someone that wants to create standards for the programmers. Very complete and excellent for that purpose. It was written a while ago, so it needs to be updated. The points it covers are not outdated but still relevant to today. It repeats the main points many times over in different ways, so it is driven in. Excellent as required reading for newer programmers if they want to know why they should follow standards.

Also see books (and videos) by Robert "Bob" Martin, and Microsoft online manuals, among other resources that are more current, more detailed, and in my opinion, more boring. Reading from a variety of authors will provide a solid foundation for a decision on the programming standards you want to follow. The goal for all of these books is quality programming with fewer errors.
4 people found this helpful
Helpful
Report
Nathaniel B. Jack
4.0 out of 5 starsVerified Purchase
Good, solid material, but not exactly an engaging read, and really needs a good editor
Reviewed in the United States on July 20, 2020
This is a highly-regarded book that, at the very least, will either re-enforce what you may already have highly suspected from years of experience, or fill in a lot of fundamental gaps if you''re just starting out. I found myself somewhere in between; honestly, I took the... See more
This is a highly-regarded book that, at the very least, will either re-enforce what you may already have highly suspected from years of experience, or fill in a lot of fundamental gaps if you''re just starting out. I found myself somewhere in between; honestly, I took the most away from the parts on the whys of commenting than anything else. Still, by this point I''ve made enough mistakes to have learned the hard way some of this content.

But reader beware: if there''s one principal this book explains but never seems to apply to itself, it''s being concise. Honestly, a good (albeit determined) editor would probably be able to cut out 30% of the content here. The entire thing seems to stray dangerously into "my book" territory (see his notes on "my program"), and I wonder if this began life as a draft of a college textbook.

I still recommend reading it, but take it in doses; much like how broccoli is good for you but often tastes bland, this book is certainly a "vegetable" of the software world that all should partake of.
2 people found this helpful
Helpful
Report
Alex G
5.0 out of 5 starsVerified Purchase
A wonderfully practical guide to programming
Reviewed in the United States 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,... See more
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
399 people found this helpful
Helpful
Report
Jeffrey Bennett
5.0 out of 5 starsVerified Purchase
Great for fledgling programmers.
Reviewed in the United States on January 17, 2021
This book saved my life when I first started coding classes, trying to understand the math behind Binary and how to render complex formulae, not just on paper, but within the realm of computer science. This book is easy to understand and goes over everything step by step,... See more
This book saved my life when I first started coding classes, trying to understand the math behind Binary and how to render complex formulae, not just on paper, but within the realm of computer science. This book is easy to understand and goes over everything step by step, rather than throwing you in with the wolves.

By starting with the complexity of binary, moving into early logic gates, then focusing on the serious science behind how code works from your basic programs to complex, the book actively guides you along and encourages you to do experimenting on your own by giving you a detailed rundown without holding your hand.

What makes this book special, however, is the depth it goes into - it''s almost a thousand pages long ! It might seem daunting, but it''s the perfect guide for beginners. No matter if you''re going into C, Javascript, Python, or something obscure, this book is an excellent reference to have on hand and an excellent guide to learn from. I highly recommend.
One person found this helpful
Helpful
Report
David Dikman
4.0 out of 5 starsVerified Purchase
I should''ve read this ten years ago
Reviewed in the United States on December 10, 2019
I''m ten, eleven years into my professional career now. Add to that another ten years of coding as a hobby. During this time I''ve picked up most of what is written in this book naturally or through colleagues, mentors and other sources. However, it has still served as a good... See more
I''m ten, eleven years into my professional career now. Add to that another ten years of coding as a hobby. During this time I''ve picked up most of what is written in this book naturally or through colleagues, mentors and other sources. However, it has still served as a good reference and reminder of all the non obvious things that are important in program. That it matters not just what we write but how we write it.

It was however, a rather tedious read if I''m to be honest. It''s a bit dated and though it''s aged fairly well it''s simply a very big book making it tough to consume.

I think at this point we may have other sources such as Clean Coder or similar that are easier to get through in smaller bite sizes. Still, I''m happy i read this and I would recommend it to get the full picture.
2 people found this helpful
Helpful
Report

Top reviews from other countries

Simon Booth
3.0 out of 5 starsVerified Purchase
Good in its day
Reviewed in the United Kingdom on June 15, 2019
Code Complete is a good collection of advice and insight into the practice of developing software, but even the second edition shows its age and much of the advice seems a little antiquated now. In particular the focus on adhering to a waterfall-like process in early...See more
Code Complete is a good collection of advice and insight into the practice of developing software, but even the second edition shows its age and much of the advice seems a little antiquated now. In particular the focus on adhering to a waterfall-like process in early chapters seems thoroughly inappropriate in the modern world - even with the 2nd edition''s nods to the new-fangled agile methodologies the kids are using and the suggestion that the appropriate level of detail for the requirements and design phases depend on the type and size of the project (which is fair). Some of the detailed nuts and bolts advice on construction is sound but in this day and age it seems odd that it needs saying as nobody would consider doing otherwise (would they?). For instance multiple injunctions to consider maybe possibly using source control are hopefully no longer doing useful work on the reader. The notion that Visual Basic is a credible choice of programming language also seems peculiar now, but I can''t remember a time when that wasn''t true 😜 You can easily spot sections that are new or revised in the 2nd edition because they are aware that C# exists. The book still gives a good overview of a range of topics, though many of them are covered better and in more detail in other books like The Pragmatic Programmer, Refactoring (Fowler) and Clean Code (Martin) . I''d like to say that this book is a good introduction and starting point, but without a refresh to bring it more up to date it''s not an easy pitch. I''m not sure there''s anything that''s as comprehensive but more up to date though? The Golden age of books about the art and craft of software engineering does seem to be behind us... I guess with all the resources available online now there''s not enough of a market, but blog posts and video tutorials can never quite replace the insight you get from reading the thoughts of an experienced programmer who''s spent time thinking about what they do and how they do it, and on consolidating those thoughts into a doorstop for communication. There is a perspective, a world view, a joined up pattern of ideas presented here that is more than the sum of the occasionally questionable parts, and there''s value in that.
16 people found this helpful
Report
Benedict Carey
5.0 out of 5 starsVerified Purchase
Definitely worth a read
Reviewed in the United Kingdom on May 23, 2012
I''m really not sure if I''m a veteran or not, writing rubbish code since I was a kid in the 80s and getting paid for it for the past couple of decades. This book is worth a read for all of us, at any level. Ok, maybe a beginner wouldn''t get it, but if you''ve been hacking...See more
I''m really not sure if I''m a veteran or not, writing rubbish code since I was a kid in the 80s and getting paid for it for the past couple of decades. This book is worth a read for all of us, at any level. Ok, maybe a beginner wouldn''t get it, but if you''ve been hacking code long enough to know the modern languages are abstractions and simplifications of what came before then you''ll read through the parts that seem less obvious. Maybe or maybe not a spoiler, but if in doubt, try writing a test case, see how it pans out. Simple and obvious. Most of what is in this book is simple and obvious, but then we do all need that pointing out often and frequently! It''s not a bible of coding, there is no such thing, but it is something we should all have a go at. I didn''t rail against anything Steve had to say (unlike, say, Cooper), but that isn''t to say he or I are right. I do think he is sticking to making sensible observations about what he thinks is worth saying from a lifetime of coding, as oppose to trying to be exciting. For that alone, I recommend him.
9 people found this helpful
Report
Amazon Customer
5.0 out of 5 starsVerified Purchase
A very good introduction to non-computer sciency programming
Reviewed in the United Kingdom on October 8, 2019
If you are looking for a good introduction to take your basic programming skills to the next level, this is definitely your go-to friend! Great book. I bought it a number of years ago when I was a first year undergraduate and I have really gotten good use out of it. I would...See more
If you are looking for a good introduction to take your basic programming skills to the next level, this is definitely your go-to friend! Great book. I bought it a number of years ago when I was a first year undergraduate and I have really gotten good use out of it. I would definitely recommend this book to a friend.
Report
Sam
5.0 out of 5 starsVerified Purchase
Why is this not in your library?
Reviewed in the United Kingdom on April 16, 2017
Every software developer should read this book. Every company that develops software products should have this in their library: you do have a library of software development books don''t you? This last should be the 13th Joel Test.
2 people found this helpful
Report
Amazon Customer
5.0 out of 5 starsVerified Purchase
A book I will be using for years to come
Reviewed in the United Kingdom on September 24, 2018
Amazingly comprehensive, a worthwhile investment for programmers at all levels. This is a reference book you can use again and again. Not the type of the book you will read cover-to-cover, though. If you are looking for a tutorial-level style of literature, look elsewhere....See more
Amazingly comprehensive, a worthwhile investment for programmers at all levels. This is a reference book you can use again and again. Not the type of the book you will read cover-to-cover, though. If you are looking for a tutorial-level style of literature, look elsewhere. I bought the used version and I was very happy with the quality.
Report
See all reviews
Brief content visible, double tap to read full content.
Full content visible, double tap to read brief content.

Customers who bought this item also bought

Brief content visible, double tap to read full content.
Full content visible, double tap to read brief content.

Customers who viewed this item also viewed

Brief content visible, double tap to read full content.
Full content visible, double tap to read brief content.

Pages with related products.

  • computer software engineering
  • construction industry
  • software engineer
  • systems engineering
  • unit testing

high quality Code outlet sale Complete: A Practical Handbook of Software Construction, sale Second Edition outlet online sale

high quality Code outlet sale Complete: A Practical Handbook of Software Construction, sale Second Edition outlet online sale

high quality Code outlet sale Complete: A Practical Handbook of Software Construction, sale Second Edition outlet online sale

high quality Code outlet sale Complete: A Practical Handbook of Software Construction, sale Second Edition outlet online sale

high quality Code outlet sale Complete: A Practical Handbook of Software Construction, sale Second Edition outlet online sale

high quality Code outlet sale Complete: A Practical Handbook of Software Construction, sale Second Edition outlet online sale

high quality Code outlet sale Complete: A Practical Handbook of Software Construction, sale Second Edition outlet online sale

high quality Code outlet sale Complete: A Practical Handbook of Software Construction, sale Second Edition outlet online sale

high quality Code outlet sale Complete: A Practical Handbook of Software Construction, sale Second Edition outlet online sale

high quality Code outlet sale Complete: A Practical Handbook of Software Construction, sale Second Edition outlet online sale

high quality Code outlet sale Complete: A Practical Handbook of Software Construction, sale Second Edition outlet online sale

high quality Code outlet sale Complete: A Practical Handbook of Software Construction, sale Second Edition outlet online sale

high quality Code outlet sale Complete: A Practical Handbook of Software Construction, sale Second Edition outlet online sale

high quality Code outlet sale Complete: A Practical Handbook of Software Construction, sale Second Edition outlet online sale