IniciGrupsConversesMésTendències
Aquest lloc utilitza galetes per a oferir els nostres serveis, millorar el desenvolupament, per a anàlisis i (si no has iniciat la sessió) per a publicitat. Utilitzant LibraryThing acceptes que has llegit i entès els nostres Termes de servei i política de privacitat. L'ús que facis del lloc i dels seus serveis està subjecte a aquestes polítiques i termes.
Hide this

Resultats de Google Books

Clica una miniatura per anar a Google Books.

Code Complete: A Practical Handbook of…
S'està carregant…

Code Complete: A Practical Handbook of Software Construction, Second… (2004 original; edició 2004)

de Steve McConnell (Autor)

MembresRessenyesPopularitatValoració mitjanaMencions
2,627214,019 (4.24)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 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… (més)
Membre:puthre
Títol:Code Complete: A Practical Handbook of Software Construction, Second Edition
Autors:Steve McConnell (Autor)
Informació:Microsoft Press (2004), Edition: 2nd, 960 pages
Col·leccions:La teva biblioteca
Valoració:
Etiquetes:No n'hi ha cap

Detalls de l'obra

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

S'està carregant…

Apunta't a LibraryThing per saber si aquest llibre et pot agradar.

No hi ha cap discussió a Converses sobre aquesta obra.

» Mira també 5 mencions

Anglès (20)  Rus (1)  Totes les llengües (21)
Es mostren 1-5 de 21 (següent | mostra-les totes)
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 |
Advice on writing programs
  stevholt | Nov 19, 2017 |
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: that code is harder to read than to write, that managing complexity is the main goal of programming, and so on.

The book is filled with nuggets of wisdom. 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.

One downside to the book is that it seems to largely focus on OO languages (C , Java) and even older imperative ones (C, Ada, etc). There is virtually no consideration given to functional programming. 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...", which is true in the languages he used, which don't support tail call optimization.

The book also pre-dates the open source explosion, github, cheap/free access to amazing tools and cloud services, and the growth of continuous integration/deployment. These have had some pretty profound impact on software development that are not taken into account in the book. ( )
  brikis98 | Nov 11, 2015 |
Es mostren 1-5 de 21 (següent | mostra-les totes)
Sense ressenyes | afegeix-hi una ressenya
Has d'iniciar sessió per poder modificar les dades del coneixement compartit.
Si et cal més ajuda, mira la pàgina d'ajuda del coneixement compartit.
Títol normalitzat
Informació del coneixement compartit en anglès. Modifica-la per localitzar-la a la teva llengua.
Títol original
Títols alternatius
Data original de publicació
Gent/Personatges
Llocs importants
Esdeveniments importants
Pel·lícules relacionades
Premis i honors
Informació del coneixement compartit en anglès. Modifica-la per localitzar-la a la teva llengua.
Epígraf
Dedicatòria
Primeres paraules
Informació del coneixement compartit en anglès. Modifica-la per localitzar-la a la teva llengua.
YOU KNOW WHAT "CONSTRUCTION" MEANS when it's used outside software development.
Citacions
Darreres paraules
Nota de desambiguació
Editor de l'editorial
Creadors de notes promocionals a la coberta
Llengua original
CDD/SMD canònics
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

No s'han trobat descripcions de biblioteca.

Descripció del llibre
Sumari haiku

Dreceres

Cobertes populars

Valoració

Mitjana: (4.24)
0.5
1 1
1.5 2
2 16
2.5 1
3 50
3.5 15
4 123
4.5 16
5 192

Ets tu?

Fes-te Autor del LibraryThing.

 

Quant a | Contacte | LibraryThing.com | Privadesa/Condicions | Ajuda/PMF | Blog | Botiga | APIs | TinyCat | Biblioteques llegades | Crítics Matiners | Coneixement comú | 155,900,317 llibres! | Barra superior: Sempre visible