The book contains almost examples of good and bad code. .. What size project will benefit from Code Complete, Second Edition? Code Complete, Second Edition. Steve McConnell Organizing Straight-Line Code. . continually improve our books and learning resourcesfor you. Contribute to marshalljj/book development by creating an account on GitHub.
|Language:||English, Spanish, Hindi|
|Genre:||Politics & Laws|
|ePub File Size:||30.71 MB|
|PDF File Size:||9.75 MB|
|Distribution:||Free* [*Register to download]|
“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. PDF Drive is your search engine for PDF files. As of today we have 78,, eBooks for you to download for free. No annoying ads, no download limits, enjoy . Code Complete 2nd Edition ronaldweinland.info Pages Advanced Dungeons & Dragons 2nd Edition (The Complete Set Pdfdrive:hope Give books away.
Since this book is the first entry on my prioritized list of Recommended Reading for Developers , and Steve is the patron saint of this web site, you better believe I just placed an order for it! Also, if you don't own the first five books on that reading list , shame on you, and get your ass over to site immediately. If I was rich enough to download a copy of those books for every developer on earth, I would. I already own two copies of the original Code Complete; one for work, one for home. There's a list of what changed in the new edition , if you're curious: There are still far more people who talk about good practices than who actually use good practices.
Readable code has a plethora of advantages including lower error rates, being easier to debug and modify, and having shorter development time. Make code readable first, and only optimize when you can make measurable improvements to measurable performance bottlenecks. Do not limit your programming by the features your language supports. Write libraries that will support the programming features you want for the problem at hand.
One example McConnell gives writing an assertion library if your language does not support assertions. Conventions, like processes, do not matter in their particulars. Some conventions are better than others, but for the most part, conventions tend to be arbitrary. However, having conventions makes code easier to read and modify because a convention can communicate a lot without using much space or requiring much thinking. This is a particular method of managing complexity.
Higher level code should be supported by lower level code that hides implementation specific details from the higher level code.
When done well, this makes the code easier to read and easier to modify. 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. 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". Clean Architecture: Martin Series. About the Author Steve McConnell is recognized as one of the premier authors and voices in the development community. Read more. Product details Paperback: Microsoft Press; 2nd edition June 19, Language: English ISBN Don't have a Kindle?
Try the Kindle edition and experience these great reading features: Software Engineering Books. Computer Science. Is this feature helpful? Thank you for your feedback. Share your thoughts with other customers. Write a customer review. Read reviews that mention code complete software development software construction required reading must read steve mcconnell computer science every programmer second edition common sense great book object oriented software developer best practices ever read visual basic naming conventions easy to read experienced programmers hard data.
Top Reviews Most recent Top Reviews.
There was a problem filtering reviews right now. Please try again later. Paperback Verified download. 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 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? Yes, it would be nice if the book was updated to include substantive material on languages like Ruby or Python cf. This book contains an astonishing number of practical points on a variety of topics. Here is a quasi-random selection: McConnell also sprinkles the text with classic words of wisdom, e. It is important to point out that even though this volume is encyclopedia-like, it does have both a sense of humor e.
Another example of the latter: The Bad: In a technical book of this breadth, minor mistakes are bound to creep in. For example, in ch. A less technical point: I found this to be bizarre, given that in the edition of "The Mythical Man-Month" Brooks states in no uncertain terms that he has changed his mind on this: Given that Code Complete 2 was published nearly 10 years later in , 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. To name only a couple of these, as of this writing the link on p.
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. 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. Alex Gezerlis. 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. 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.
Objective and Scientific McConnell backs up most of his claims with scientific evidence referencing the results of different programming studies throughout the book. This builds trust between the reader and the author. 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. 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.
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.
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: 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. Use techniques like abstraction, encapsulation, self-documenting code, and collaboration with other programmers to make your code better.
See all reviews. site Giveaway allows you to run promotional giveaways in order to create buzz, reward your audience, and attract new followers and customers. Learn more about site Giveaway. This item: Set up a giveaway.