CODE COMPLETE BOOK

adminComment(0)

He is the author of several books, including Code Complete and Rapid Development, both honored with Software Development magazine's Jolt Award. “This is simply the best book on software construction that I've ever read. “Steve McConnell's seminal book Code Complete is one of the most accessible. Code Complete is a software development book, written by Steve McConnell and published in by Microsoft Press, encouraging developers to continue.


Code Complete Book

Author:DYLAN DEBNAR
Language:English, German, French
Country:Bolivia
Genre:Health & Fitness
Pages:586
Published (Last):30.08.2016
ISBN:747-9-77983-289-4
ePub File Size:20.78 MB
PDF File Size:9.11 MB
Distribution:Free* [*Registration Required]
Downloads:37539
Uploaded by: TANEKA

Widely considered one of the best practical guides to programming, Steve McConnell's original CODE COMPLETE has been helping developers write better. Code Complete book. Read reviews from the world's largest community for readers. Widely considered one of the best practical guides to programming, S. Learn more about Steve McConnell's best-selling books like Code Complete, Rapid Development, and Software Project Survival Guide.

This section is in list format, but may read better as prose. You can help by converting this section , if appropriate. Editing help is available. Retrieved But the most important take-aways are in Chapter 33, Personal Character: The fastest way to do so is to take on the attitudes of master coders humility, curiosity, intellectual honesty, discipline, creativity , while also practicing their habits many good habits are listed in the book, e.

TechBookReport Reading it means that you enjoy your work, you're serious about what you do, and you want to keep improving. In Code Complete, Steve notes that the average programmer reads less than one technical book per year. The very act of reading this book already sets you apart from probably ninety percent of your fellow developers.

In a good way. I'm quite disappointed, since I'd heard nothing but praise for this book before picking it up. But it's not for me, and I'm now dubious of its value for any programmer outside of a fairly narrow, large-team, waterfall development process involving large numbers of people writing very large quantities of code in languages that aren't very expressive. And, well, in that situation I think one would get more benefit from changing that environment than reading this book.

Steven C.

Code Complete, Second Edition

Construx Software. Retrieved from " https: Hidden categories: Webarchive template wayback links Wikipedia introduction cleanup from February All pages needing cleanup Articles covered by WikiProject Wikify from February All articles covered by WikiProject Wikify Articles needing cleanup from February Articles with sections that need to be turned into prose from February Namespaces Article Talk.

Even at the construction level, this can be done by choosing good class names and abstractions, factoring code into methods to maintain a common level of abstraction, and choosing good variable names. Look out for warning signs, such as classes with an abnormally high number of defects. These warning signs do not necessarily mean that something is wrong with that part of the program, but they are a good indicator that you should be a little bit suspicious.

These warning signs could show up after construction error rate or during construction compiler warning, indications from your self or other that your program is hard to understand.

In addition to being my favorite section heading in the book, this principle emphasizes that iteration is appropriate at all points of the software development process. Requirements are rarely fixed in stone, bugs are always present, and developers can always find a better way to rewrite code.

Iteration gives all of these improvements a chance to actually make it into the product under development. No one convention, process, or tool set is the be all and end all of software development. Developers should be wary of absolutes and try to avoid blind faith in the processes they use. Solutions should be adapted to the problem at hand, not vice versa. The key to keeping an open mind and becoming effective and flexible is experimentation.

Be willing to try new things, measure the effectiveness of those experiments, and be willing to change based on the results. Those are the high level principles. These principles occur over and over again through the seven parts of this book. The first part, titled "Laying the Foundation" discusses the general process of software development and the role of construction a.

Construction is important, according to McConnell, because it is the only part of the software development process that absolutely must happen to produce a working software project. Construction is also an area that, traditionally, has not has as much attention to it as other areas such as high level design or testing. However, McConnell stresses that all parts of the development process are important in creating a successful project and gives pointers throughout the text to resources that discuss other parts of the software development process in more depth.

He notes that pre-construction planning is particularly important since no amount of good construction and through testing can save a bad design. Section two is "Creating High-Quality Code". This section introduces a point emphasized again and again throughout the book. Software's "Primary Technical Imperative" is managing complexity.

High quality code exposes people reading it to consistent levels of abstraction separated by clear boundaries. Complexity is managed by minimizing the essential complexity one has to deal with at any given time and trying to keep accidental complexity from spreading throughout the code base. High quality classes and routines provide consistent abstractions, document their assumptions, and check their invariants defensively; they fail sooner rather than later.

Code Complete, 2nd Edition

Even a simple class or routine is worthwhile if it decreases the complexity of reading the code where it is used. One of the most practically useful facts I got out of Code Complete was learning about the "Pseudocode Programming Process". This process is a way of developing code by starting with detailed pseudocode. When constructing a program, a developer should iteratively write pseudocode that is high level enough to be in the domain of the problem but low level enough for translation to real code to be nearly mechanical.

Developing pseudocode ensures that the developer understands the problem at a low enough level for implementation, encourages the programmer to think about error checking before implementing the nominal path through the code, may indicate what when to factor code into separate routines and suggest names for those routines.

Those parts of the high level pseudocode that the developer decides to leave in provide automatic, high level commenting of code. The third section is entitled "Variables" and discusses the effective use of variables. The chapters in this section discuss data initialization do it close as close to the declaration as possible , variable scope keep it as small as possible , limiting variables to a single purpose, effective variable names keep them specific, use a naming conventions , and tips for using fundamental and more complex data types.

Statements are covered in section four called, not surprisingly, "Statements". This section discusses methods for effectively organizing and using straight line code, conditionals, and loops as well as more exotic control structures such as exceptions, gotos, and various table driven control structures.

This section discusses how deep nesting of control structures tends to make code complex.

If possible, it should be avoided by restructuring the code or factoring the nested code into its own routine. The more paths there are through a code fragment, the more complex it is; the number of paths a developer must consider at a single time should be minimized. Section five, "Code Improvements" discusses a mishmash of techniques for improving code.

It discusses software quality, collaboration, developer testing, debugging, refactoring, and code tuning. One key point of this section is that the goals of a certain construction project should be clear.

Some goals are bound to go against each other, and if developers do not know which are most important, they will do a bad job of trying to optimize all of them at once. The most obvious example of this tendency is that aggressive optimization may make code less readable and prevent beneficial refactorings.

This section also points out that code reviews, testing, debugging, refactoring, and code tuning all have the potential to improve code quality, but it is when they are used thoughtfully in unison that their potential is maximized. Section six, "System Considerations" discusses some higher level issues in constructing a system. As project size increases, project quality and development speed tend to go down in a faster than linear manner.

This is because as the project increases, more and more overhead gets taken up by managing communication and more details tend to get lost in the cracks.

It is for this reason that having a process and conventions becomes more important on large projects; the more that is automatic, the less that quality and and development time will suffer. This section also discusses how to manage programmers and essential tools that every developer should know about and use. This section also discusses several integration processes and emphasizes that which process is right depends on the project being developed.

The final section of Code Complete is "Software Craftsmanship". This section talks about good practices in actually structuring code and how to write good, effective comments and code that documents itself as much as possible. This section also describes the importance of personal character in becoming an excellent developer. McConnell posits that intelligence is less important than other personal characteristics such as humility, curiosity, intellectual honesty, communication and cooperation, creativity and discipline, effective laziness, and good habits.

The point emphasized throughout the discussion on personal character is that a good developer needs to be happy and willing to learn from other developers and be willing to admit when their are right and wrong if they want to earn the trust and respect of others. A useful part of the final section was McConnell's summary of where to find more information. In particular, he presents "A Software Developer's Reading Plan" reproduced below for my future reference.

Note that the plan should be supplemented to the needs and interests of particular developers. Introductory level: Adams, James L. Conceptual Blockbusting: A Guide to Better Ideas, 4th ed. Cambridge, MA: Perseus Publishing, Bentley, Jon. Programming Pearls, 2d ed. Reading, MA: Addison-Wesley, Glass, Robert L. Facts and Fallacies of Software Engineering. Boston, MA: McConnell, Steve. Software Project Survival Guide. Redmond, WA: Microsoft Press, Code Complete, 2d ed.

Practitioner level: Berczuk, Stephen P. Software Configuration Management Patterns: Effective Teamwork, Practical Integration. Fowler, Martin. UML Distilled: Software Creativity.

Testing Computer Software, 2ed. New Yor, NY: Larman, Craig. Applying UML and Patterns: Englewood Cliffs, NJ: Prentice Hall, Rapid Development. Wiegers, Karl. Software Requirements, 2d ed.

Professional level: Software Architecture in Practice, 2d ed. Improving the Design of Existing Code. Gamma, Erich, et al. Design Patterns. Gilb, Tom. Principles of Software Engineering Management. Workingham, England: Maguire, Steve.

Writing Solid Code. Meyer, Bertrand. Object-Oriented Software Construction, 2d ed. New York, NY: Prentice Hall PTR, For more details and up to date reading lists see www. Other interesting things from a quick skim of the bibliography: Baecker, Ronald M.

Post navigation

North-Holland, Reprinted in Yourdon Writings of the Revolution. Disjkstra, Edsger. Knuth's Literate Programming. Paul Oman and Curtis Cook. Schneiderman, Ben. Software Psychology: Human Factors in Computer and Information Systems. Spinellis, Diomidis. Code Reading: An Open Source Perspective. Various by Gerald Weinberg.

Jun 21, Mark Seemann rated it it was ok Shelves: All the while reading this book, I struggled with how to rate it here. In many ways, this is an extraordinary piece of work; it's extremely comprehensive, and reveals a remarkable level of insight.

This second edition is from , and although obviously some of its content may seem a little dated, most of it still holds up well in Given that context, I find it difficult to find fault with most of the book. Much of the advice given is good advice, and as a programmer, you should adopt and i All the while reading this book, I struggled with how to rate it here. Much of the advice given is good advice, and as a programmer, you should adopt and internalise most of it.

On these grounds, the book deserves 4 or 5 stars, so why do I rate it as I do? There are two reasons for this. The first is that, having programmed for some years already, I learned little. Although I think this tome could be indispensable for a so-called junior programmer, I only gained little from it. The second reason is probably an effect of the first, but I was bored to tears most of the way through. Still, I kept reading, a chapter per month or so, since there was an occasional gem here and there.

The rating I've given therefore reflects my experience reading the book, more than the quality of it, which is indisputable.

If you're a seasoned programmer, you may consider skipping it. If you have only a few years of professional experience, you should consider reading it. View 2 comments. May 16, Stijn rated it did not like it. Terribly bloated. Long-winded and trivial.

I do not get the high score for this book; in a related area, but much more crisp is Programming Pearls it even engages your brain, imagine that. Aug 14, Yevgeniy Brikman rated it it was amazing. A must-read for any programmer.

Although I don't agree with everything in the book and a few parts feel out of date, it provides an excellent framework for how to think about programming and software engineering. It can help programmers of all experience levels to focus on the right things: The book is filled with nuggets of wisdom.

Why I Read this book

Some of my favorite quotes, some from McConnell, some A must-read for any programmer. Some of my favorite quotes, some from McConnell, some from other writers that he includes in the book: Managing complexity is the most important technical topic in software development. In my view, it's so important that Software's Primary Technical Imperative has to be managing complexity. A "wicked" problem is one that can be clearly defined only by solving it. It's OK to figure out murder mysteries, but you shouldn't need to figure out code.

You should be able to read it. Eighty percent of the errors are found in 20 percent of a project's classes or routines.

Don't document bad code - rewrite it. Jackson's Rules of Optimization: Rule 1.

Don't do it. Rule 2 for experts only.

Don't do it yet - that is, not until you have a perfectly clear and unoptimized solution. No programmer has ever been able to predict or analyze where performance bottlenecks are without data.

No matter where you think it's going, you will be surprised to discover that it is going somewhere else. The Fundamental Theorem of Formatting says that good visual layout shows the logical structure of a program. Making the code look pretty is worth something, but it's worth less than showing the code's structure. Build one to throw away; you will, anyhow. There is virtually no consideration given to functional programming.

Book Review : Code Complete

This is a shame, as immutable variables, pure functions, and lack of side effects inherently solve or mitigate MANY of the code complexity and readability problems he discusses in the book. I chuckled at a line in the book where he says "Recursion isn't useful often These have had some pretty profound impact on software development that are not taken into account in the book.

View all 5 comments. Nov 07, Aaron Boushley rated it liked it Recommends it for: This book was a pretty good read. Most of what is discussed is extremely valuable information. Although with only 5 years of experience I felt like many of the points that Steve brought up were fairly obvious once you've been working as a Software Developer.

If you are new to programming, want to move to a more professional level of programming or just plain have plenty of time on your hands this is a great book. However, if you already have a fair amount of experience developing software profes This book was a pretty good read.

Other books: CRESCENDO EBOOK

However, if you already have a fair amount of experience developing software professionally, I would suggest you look elsewhere for good reading. Feb 22, Aaron Robson rated it did not like it. Dreadful and dull, get the Pragmatic Programmer instead. Sep 28, Jennifer rated it liked it. I joined a book club for reading this book, and the discussions along the way were some of the most valuable I've had.

It was very rewarding to me to see many of the pieces of advice given reaffirming my own coding practices and the way things are done here at SEP, but I certainly took some new information away.

One of the main lessons taught throughout the book is that code should be easy to understand. Levels of abstraction, clear class and variable names, information hiding, coding standards - they all leave one less detail you have to juggle in your mind when trying to understand the code you're reading.

If you write code that is as close to possible to self-documenting, you'll make your life and everyone else's life that much easier. Mostly this book was just the tip of the iceburg, a good overview of several key topics in the industry. It was very well-researched and cited, though quite a bit of the research was as old or older than I am! There was a recommended reading list at the end of the book which seems very valuable, and I intend to go through it.

This book left me with a feeling of 'just getting started' and seems like it would be a good thing for new-hires to read. Mar 29, Vladimir rated it liked it Shelves: Every idea is explained verbosely, then illustrated with some numeric stats, then with a 3D chart, then with some real-life anecdote, then with a reference to a paper, and finally reiterated in a checklist in the end of the chapter.

Oct 13, Polina rated it it was amazing. For me, the main message of this book is: For example, I was not able to explain why I don't feel good about "hacky code" in feature implementation or why sometimes I read code and struggle to understand what is going on.

Now I see that both of those things add a lot of complexity. I think every developer with years of experience should read this book. Sure it can be dated at For me, the main message of this book is: Sure it can be dated at some places and not always applicable to small companies development capabilities but it definitely conveys ideas that all developers should understand and embrace.

Mar 17, Alan Fay rated it liked it Shelves: I probably got less out of the book, having worked as a developer for a couple of years out of school, than say, a college student or somebody fresh out. Or maybe dinosaurs that are out of touch and need to get back into the game. The second half of the book is pretty much a catalog of refactoring techniques. It's definitely geared towards the aforementioned audiences. McConnell covers a few other topics, related to design, teamwork, testing, and configuration management, but doesn't go into dept I probably got less out of the book, having worked as a developer for a couple of years out of school, than say, a college student or somebody fresh out.

McConnell covers a few other topics, related to design, teamwork, testing, and configuration management, but doesn't go into depth for many of them. Still, it's an excellent book to have around, if there's confusion about what you're trying to explain to someone. Nov 13, Joe rated it it was amazing Shelves: Steve McConnell 's Code Complete is absolutely essential to every software developer. The lessons contained in Code Complete are based on solid, time-tested principles.

The time spent reading Code Complete is time spent bettering your career as a developer. Oct 03, David rated it really liked it Shelves:The Worst I don't want to hate on the book too much or at all really , but I do have some nits to pick.

If I was rich enough to download a copy of those books for every developer on earth, I would. I believe Knuth said that early optimisation is the root of all evil, and I agree. Giving the reader plenty of resources to further their discipline.

The Power of Variable Names Want to Read Currently Reading Read.

LORRIANE from Costa Mesa
Please check my other articles. I take pleasure in three-cushion. I relish studying docunments delightfully.
>