Página InicialGruposDiscussãoMaisZeitgeist
Pesquisar O Sítio Web
Este sítio web usa «cookies» para fornecer os seus serviços, para melhorar o desempenho, para analítica e (se não estiver autenticado) para publicidade. Ao usar o LibraryThing está a reconhecer que leu e compreende os nossos Termos de Serviço e Política de Privacidade. A sua utilização deste sítio e serviços está sujeita a essas políticas e termos.

Resultados dos Livros Google

Carregue numa fotografia para ir para os Livros Google.

A carregar...

Code Complete: A Practical Handbook of Software Construction (2004)

por Steve McConnell

MembrosCríticasPopularidadeAvaliação médiaMenções
2,902224,901 (4.22)5
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 exp… (mais)
A carregar...

Adira ao LibraryThing para descobrir se irá gostar deste livro.

Ainda não há conversas na Discussão sobre este livro.

» Ver também 5 menções

Inglês (21)  Russo (1)  Todas as línguas (22)
Mostrando 1-5 de 22 (seguinte | mostrar todos)
I'm re-reading this book and is still as good. It still deserves a read. The only one bad thing is that it's so short.

Well, the last thing was obviously a joke. I wish it had more content and was instead a series of books, but maybe the content I'm missing is the other books by the same author, which I have not read. I will give them a try when I finish with this.

Best thing of the book is the annotated bibliography at the end of each chapter. ( )
  NachoSeco | Oct 10, 2022 |
Code Complete is a massive work, so this summary is, necessarily, very high level. It is not a book that one can absorb completely in one reading, but one can absorb its high level themes (summarized nicely in the second to last chapter).

"Conquer Complexity". High quality code manages complexity. No one can think of all of the levels of abstraction needed to fully understand a program at once; just admit it and try to make your code less complex. Complexity can be managed at every level of the development process from having a well thought out high level design to choosing good variable names.

"Pick Your Process". Having a process is important. It does not matter exactly what the process is; in fact, the process should be tailored to the problem at hand. The purpose of a process is to allow for coordination between people. When a project is small (1, maybe 2 people), then it is the talent of the individual that matters most. When a project is large, it is managing communication that matters most.

"Write Programs for People First, Computers Second". Computers do not care about programs being readable, but people do, and people are going to read your programs many time. 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.

"Program into Your Language, Not in It". 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.

"Focus Your Attention with the Help of Conventions". 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.

"Program in Terms of the Problem Domain". 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.

"Watch for Falling Rocks". 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).

"Iterate, Repeatedly, Again and Again". 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.

"Thou Shalt Rend Software and Religion Asunder". 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.k.a. programming) in that process. 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". 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, 2001.

Bentley, Jon. Programming Pearls, 2d ed. Reading, MA: Addison-Wesley, 2000.

Glass, Robert L. Facts and Fallacies of Software Engineering. Boston, MA: Addison-Wesley, 2003.

McConnell, Steve. Software Project Survival Guide. Redmond, WA: Microsoft Press, 1998.

McConnell, Steve. Code Complete, 2d ed. Redmond, WA: Microsoft Press, 2004.

Practitioner level:

Berczuk, Stephen P. and Brad Appleton. Software Configuration Management Patterns: Effective Teamwork, Practical Integration. Boston, MA: Addison-Wesley, 2003.

Fowler, Martin. UML Distilled: A Brief Guide to the Standard Object Modeling Language, 3d ed. Boston, MA: Addison-Wesley, 2003.

Glass, Robert L. Software Creativity. Reading, MA: Addison-Wesley, 1995.

Kaner, Cem, Jack Falk, Hung Q. Nguyen. Testing Computer Software, 2ed. New Yor, NY: John Wiley & Sons, 1999.

Larman, Craig. Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and the Unified Process, 2d ed. Englewood Cliffs, NJ: Prentice Hall, 2001.

McConnell, Steve. Rapid Development. Redmond, WA: Microsoft Press, 1996.

Wiegers, Karl. Software Requirements, 2d ed. Redmond, WA: Microsoft Press, 2003.

"Manager's Handbook for Software Development," NASA Goddard Space Flight Center.

Professional level:

Bass, Len, Paul Clements, and Rick Kazman. Software Architecture in Practice, 2d ed. Boston, MA: Addison-Wesley, 2003.

Fowler, Martin. Refactoring: Improving the Design of Existing Code. Reading, MA: Addison-Wesley, 1999.

Gamma, Erich, et al. Design Patterns. Reading, MA: Addison-Wesley, 1995.

Gilb, Tom. Principles of Software Engineering Management. Workingham, England: Addison-Wesley, 1988.

Maguire, Steve. Writing Solid Code. Redmond, WA: Microsoft Press, 1993.

Meyer, Bertrand. Object-Oriented Software Construction, 2d ed. New York, NY: Prentice Hall PTR, 1997.

"Software Measurement Guidebook," NASA Goddard Space Flight Center.

For more details and up to date reading lists see www.construx.com/professionaldev (requires an account, free with purchase of code complete).

Other interesting things from a quick skim of the bibliography:

Baecker, Ronald M., and Aaron Marcus. 1990. Human Factors and Typography for More Readable Programs. Reading, MA: Addison-Wesley.

Various works by Kent Beck

Various works by Barry Boehm

Dijkstra, Edsger. 1965. "Programming Considered as a Human Activity." Proceedings of the 1965 IFIP Congress. Amsterdam: North-Holland, 213-17. Reprinted in Yourdon 1982 (Writings of the Revolution).

Disjkstra, Edsger. 1972. "The Humble Programmer." Communications of the ACM 15, no. 10 (October): 859-66.

Knuth's Literate Programming.

Paul Oman and Curtis Cook. "The Book Paradigm for Improved Maintenance" and "Typographic Style is More than Cosmetic".

Schneiderman, Ben. 1980. Software Psychology: Human Factors in Computer and Information Systems. Cambridge, MA: Winthrop.

Spinellis, Diomidis. Code Reading: An Open Source Perspective.

Various by Gerald Weinberg. ( )
  eri_kars | Jul 10, 2022 |
The focus of Code Complete is software construction, i.e. the coding part of software development. As Steve McConnell notes in the preface, "construction is the only activity that is guaranteed to be done". You can skip almost any step (requirements, testing etc), but if you don't write any code there is not going to be any software.

I bought my copy of the first edition of Code Complete in 1997, and I was immediately fascinated. I had never read anything like it before - a book that concentrated on the actual writing of the code. For example, it had a whole chapter on if- and case-statements, and another chapter on the naming of variables. I had no idea there was so much to learn about these seemingly straight forward activities. It was immediately useful to me, and I started to apply as much as I could of what I learnt from it.

Although it concentrated on coding, it covered a broad spectrum of activities around coding, from requirements and design to testing, debugging and optimization. It also had a great reference section with suggestions of further reading in the area of software engineering. This became my starting point for finding lots of other good books to read, like Peopleware: Productive Projects and Teams and Programming Pearls.

So this summer I decided to re-read this seminal book, partly to see what's new in the second edition, and partly to see if still think it is such a great book.

To answer my own question - yes, it is still the number one book on writing code. It is near encyclopaedic in its coverage of the nuts and bolts of programming. There are chapters on the naming of variables, on organizing straight-line code, on conditionals, on loops, on lay-out, on good commenting and on how to write good methods.

In it, there are frequent references to scientific studies that support the advice given in the book. For example, how long should variable names be? Instead of just giving us his opinion, McConnell summarized the findings of several scientific studies on the subject.

Each time there is reference to a study, there is a little "hard data" symbol in the margin. There are other symbols in the margin as well, "Coding Horror" for code examples of what not to do, and "Key Point" for, well, key points. The margin is also used for cross references to other chapters, and for quotes related to the subject discussed. For me, this works really well. It is both useful and makes the text easier to read. In general, the book is very well laid out.

Some of my favourite advice from the book (all of which I remember from reading the first edition) are:

Chapter 7.1 Valid Reasons to Create a Routine - for example: Reduce complexity, Introduce an intermediate understandable abstraction, and Avoid duplicate code (there are 6 more valid reasons in this chapter). The second part of the chapter is called Operations That Seem Too Simple to Put Into Routines and contains a great example of why it can be good to put even a one-line calculation in a routine - the code becomes more readable, and small operations tend to turn into larger operations.

Page 172 (and 264 for variables) Use opposites precisely. When naming "opposite" methods and variables, be careful to use the correct pairs, like add/remove, begin/end, create/destroy etc. This makes the relationship between them clear and obvious.

Page 433 Break complicated tests into partial tests with new boolean variables. This is such a simple thing, but it makes the code a lot more readable.

Page 754 "Make the incompleteness of a statement obvi". For example, when breaking up a logical and over two lines, end the first line with && - that way, it is clear that the statement continues on the next line.

Even though the book truly is great, there are a few things to complain about. In the first edition, the chapters on layout and comments came right after the chapters on the different control structures. But in the second edition, these two chapters have been moved further back. To me, that doesn't make sense, since they too are related to how you actually write your code. Now there are chapters on testing, debugging, optimization and refactoring in between.

And talking about refactoring: while this is an important subject, I don't feel the chapter on refactoring is particularly good. This chapter is new in the second edition. The summary of refactoring is OK, but a good part of the chapter consists of just listing different kinds of refactorings.

Overall though, the second edition is a nice face lift. The code examples are now mostly in Java, C or Visual Basic (in the first edition they were in Pascal, C or Ada). But since all the major themes of the book were already present in the first edition, it does not make a big difference if you happen to read the first edition instead of the second edition.

Code Complete is thick - 862 pages (not counting the bibliography and index). If that feels like a lot to read, then I suggest you start by just reading one or two chapters, for example "Using Conditionals" or "Layout and Style". They (and pretty much any chapter in the book) can easily be read without first reading the preceding chapters, and these will give you a sense of what you can expect from the other chapters. Even if these are all you read, you will still get a lot of value from the book.

However, if you are a programmer and care about how you write code, you owe it to yourself to read the whole book. It is considered by many (including me) to be the best book available on programming, and it will almost certainly make you a better programmer. Highly recommended. ( )
  Henrik_Warne | Dec 13, 2020 |
[I am only going to include 10 tech books, a represtative sample]

Fabulous book. If I was interested in cars, then this book would tell me how cars are and should be made. I can't believe that any programmer has not read this book. Start here. ( )
  GirlMeetsTractor | Mar 22, 2020 |
Code Complete is a 850-page tome which might serve as Computer Science guru-author Steve McConnell's magnum opus. His presentation addresses an audience that spans programmers at the beginning level, intermediate level, and advanced level. With its wide-ranging scope, it fills in any computer scientist's holes of knowledge.

Units are filled with a handful of chapters each and consist of foundations, producing high-quality code, variables, statements, improvements, systemic issues, and craftsmanship. McConnell aims and succeeds at addressing core issues of how software is actually constructed.

I appreciate how much he addresses the team aspect of computer science. For me, this has been lacking in my education. I've worked hard at developing computer programming as a mathematical exercise. McConnell seems to conceptualize the practice more as a sports team, with individuals at varying degrees of core competencies and varying types of skills. As such, he puts forth ideas as computer code as communication in a forceful (again, 850 pages, 35 chapters) approach that I have not read or seen before.

The book is well-researched with frequent citations of studies, books, and papers. It attempts to bring its recommendations with hard facts, not simply sage advice. Further, it provides bibliographies at the end of every chapter with recommendations for further reading. I find that computer scientists are traditionally weak when it comes to reading the literature, and this type of book-list is hard to find. As one who learns best by close, quiet reading, I appreciate the well-commented references.
( )
  scottjpearson | Jan 25, 2020 |
Mostrando 1-5 de 22 (seguinte | mostrar todos)
sem críticas | adicionar uma crítica


Tem de autenticar-se para poder editar dados do Conhecimento Comum.
Para mais ajuda veja a página de ajuda do Conhecimento Comum.
Título canónico
Informação do Conhecimento Comum em inglês. Edite para a localizar na sua língua.
Título original
Títulos alternativos
Data da publicação original
Locais importantes
Acontecimentos importantes
Filmes relacionados
Primeiras palavras
Informação do Conhecimento Comum em inglês. Edite para a localizar na sua língua.
YOU KNOW WHAT "CONSTRUCTION" MEANS when it's used outside software development.
Últimas palavras
Nota de desambiguação
Editores da Editora
Autores de citações elogiosas (normalmente na contracapa do livro)
Língua original
DDC/MDS canónico
LCC Canónico
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 exp

Não foram encontradas descrições de bibliotecas.

Descrição do livro
Resumo Haiku

Current Discussions


Capas populares

Ligações Rápidas


Média: (4.22)
1 2
1.5 2
2 18
2.5 1
3 55
3.5 15
4 128
4.5 16
5 199

É você?

Torne-se num Autor LibraryThing.


Acerca | Contacto | LibraryThing.com | Privacidade/Termos | Ajuda/Perguntas Frequentes | Blogue | Loja | APIs | TinyCat | Bibliotecas Legadas | Primeiros Críticos | Conhecimento Comum | 206,327,057 livros! | Barra de topo: Sempre visível