These are rather notes than a review while reading:

1. Use very descriptive names. Be consistent with your names.

2. A function should not do more than one thing.

3. SRP (Single Responsibility Principle): a class or module should have one, and only one, reason to change.

4. Stepdown rule: every function should be followed by those at the next level of abstraction (low, intermediate, advanced).

5. A long descriptive name is better than a short enigmatic name. A long descriptive name is better than a long descriptive comment.

6. The ideal number of arguments for a function is zero (niladic). Next comes one (monadic), followed closely by two (dyadic). Three arguments (triadic) should be avoided where possible. More than three (polyadic) requires very special justification and then shouldn't be used anyway.

7. Flag arguments are ugly. Passing a boolean into a function is loudly proclaiming that this function does more than one thing. It does one thing if the flag is true and another one if the flag is false.

8. Write learning test when using third-party cody to make sure it behaves the way you expect it to. And if codebase changes in time, at least you find out early enough.

An impressive volume. It must have been amazing back in 2004. There was probably no better single book on software engineering for a beginner at that moment in time. It's impossible not to respect books like these which try to cover the whole ground - there's only a few of them around.

Unfortunately in 2024, huge parts of it are either obsolete, irrelevant, or missing. Across 800 pages, it barely mentions databases. The chapters on testing and debugging are really lacking. Concurrency is another miss, only a few mentions of threads are present. Whole chapters on code formatting and refactoring obsoleted by modern tools.

An experienced engineer will struggle to learn a lot from it, and it would be irresponsible to recommend it to a novice due to all of the above.

I decided to read it as it is frequently recommended along with Clean Code: A Handbook of Agile Software Craftsmanship, Design Patterns: Elements of Reusable Object-Oriented Software and other seminal software books, but it is largely a relic by now.

Code Complete is a timeless and essential guide for software developers seeking to improve their coding skills and overall software construction process. This classic book provides readers with invaluable insights, practical tips, and best practices for writing high-quality code.

McConnell's writing style is engaging and accessible, making the book a pleasure to read for both seasoned developers and newcomers alike. The book covers a wide range of topics, including planning, design, construction, debugging, refactoring, and testing, providing a comprehensive understanding of the software development lifecycle.

What sets this book apart from other programming books is its focus on the principles of software craftsmanship. McConnell emphasizes the importance of writing clean, maintainable code, and offers pragmatic advice on how to achieve this goal. The book is filled with real-world examples, case studies, and anecdotes that help to illustrate the concepts being discussed.

All in all, this is a must-read for any serious software developer looking to enhance their skills and produce better code. The timeless wisdom and practical advice offered by Steve McConnell make this book an enduring classic in the field of software development.

Very good! I should have read it 5 years ago!

I was given a copy of Code Complete when I was developing the kernel for the technology I patented. I didn't really know how to code, I did know some mathematics, formal (symbolic) logic and had a good helping of philosophy to draw on. I never met Steve McConnell (that I know of) and did find his philosophy of coding almost parallel to mind, hence his book was an enjoyable read at the time.

This is were I learned to make well documented code.
I prefer to write code that is modular and easy to follow... ...easy for the next guy if necessary.

Ce livre devrait être lu par bon nombre d'étudiant en informatique et de développeurs professionnel afin d'améliorer de manière globale la qualité de code source produit ainsi que sa conception.
Dans cette ouvrage, nous retrouvons plusieurs points essentiels du développement logiciel, que se soit des techniques afin de concevoir une architecture globale propre ou encore des techniques afin d'améliorer la qualité du code source. Cela passe par de nombreux exemples que donne l'auteur sur son expérience passé, ainsi que de nombreux chiffres et statistiques permettant de mieux cerner ce que nous dit l'auteur.
Je ne spoilerais pas le contenu du livre, pour forcer les développeurs intéresser à le lire d'eux-même. Cependant, je le conseille dans sa version original Code Complete pour ceux n'étant pas anglophobe, car la traduction française, bien que bonne, souffre parfois de soucis, en particulier au niveaux de la définition des termes non "traduisible" de l'anglais. De plus, il arrive qu'il manque certains mots ou que les phrases n'aient pas de sens, encore une fois due à la traduction de cette ouvrage.

Much of this book was created before multi-core processors became mainstream, and before the Internet, before the world wide web became the preferred way to publish applications and before the prevalence of distributed systems.

This book is the perfect book for 1993 (the year edition the first edition was published), but right now some of these topics are of lower importance.

If you work with structured, imperative, object-oriented programming languages, with no functional programming features, and without concurrency primitives (such as threads or futures/promises), this book might be still relevant.

A lot in this book can be achieved through the use of static analysis and adopting a proven coding standard. Today, you will make your software more reliable by reducing shared mutable state and by constructing for verification.

There's not very many topics in the field of software construction that this book doesn't cover! It's an extremely comprehensive guide to everything coding.

Most of the material is still relevant in 2020, especially the parts about programmer psychology and approaches to software.

Some key things are missing due to industry changes:

- a lot of the recommendations around formatting are less relevant since autoformatters like autopep8, go fmt, or clang-format have become popular. Some of the formatting techniques that are good but not recommended by the book because they are a pain to maintain are made much easier by autoformatters.
- expansion of the role of unit testing and test driven development; the book is a light on details for writing tests. A more modern book would go into more details about writing tests, mocks and fakes, etc.
- many examples using VB or C++ without smart pointers are less relevant today then they were in 2004.
- distributed/parallel systems are much more common nowadays. The nature of these systems mean that certain practices that are solid in a single-machine world make less sense in a distributed one where function calls can fail in many more ways, and can be slow over a network.

For some of these there are some solid books out there that you can use to supplement Code Complete. Doesn't stop this from being a really useful book!

This book is a behemoth, and also fantastic.

It’s well-written, carefully structured, and comprehensive. There’s a lot of content in its ~850 pages, but it’s generally concise and to the point.

It covers everything from the nitty-gritty details of variable naming and indentation style to the much broader themes of software development, such as managing complexity, iterating, and collaborating.

In my ~6 years as a software engineer, I have collected a toolbox of principles, instincts, tips, and tricks. This book mostly reflected all those back to me, but with better rationales and hard data.

There were a few sections that felt a bit dated - but generally I was surprised how relevant most of it still is given how much programming has changed in the ~20 years since this was published.

The best book I read on the subject, ok I didn't read so many :-)
Many advises are advocated using statistics not only personal feeling
The author tries to take the best from each method avoiding religious commitment to one church

Finally finished it after attempting it repeatedly over the past 8 years. Very good tips but EXTREMELY dense. If you want the TL;DR read the last 3 chapters. From there, you can then go through whichever chapters you want information on.