100 Books Like Effective C++

Smalltalk is not as common or popular as it once was, but the influence its design had on programming is hard to overstate.

Reading this book has changed how I think about object orientation, and how I design systems, learning the patterns of Smalltalk makes it clear what object oriented design is really intended to achieve.

When seeking a book on how to use a language effectively, getting one written by someone who helped design and implement the language is usually a great idea. With Effective Java, you get a book written by someone who contributed a significant amount to the language: Joshua Bloch had a lot to do with the design of the Java 5.0 features circa 2004, which is where Java moved for me from "inelegant" to "hey I can finally make things look good in this language." Bloch goes into considerable and passionate depth about each of the 90 items in the 2018 edition and will help you ensure you don't make the mistakes that can lead to defective or bad code.

During my first few weeks of JavaScript coding, I encountered what seemed to be an endless number of head-scratching moments: "I'm slowly reading the few lines of code I just wrote, it seems fine, so why isn't it doing what it looks like it should be doing?" Even more insidious at times than C++, JavaScript contains a number of fairly clever constructs, including things like hoisting, duck typing, and a loosey-goosey argument passing mechanism. This concise tome of fewer than 175 pages helped get me past those first few months, and as an author-stated goal, it helped me "learn to think in JavaScript."

When learning a new language, you'll want to avoid the mistake of assuming that you can adapt your old way of doing things to your new language (like I first tried many years ago). Even though Java and Ruby are both object-oriented languages, the "right" approach to implementing things is dramatically different between the two. Practical Object-Oriented Design in Ruby makes it easy to learn how to apply object-oriented design and to implement the code properly in Ruby, making your system easier to change as it grows.

Next to Fred Brooks' The Mythical Man-Month, this is perhaps the most classic of all classic programming books.

The authors write: "Besides showing how to make effective use of the language, we have also tried where possible to illustrate useful algorithms and principles of good style and sound design."

The book is astoundingly practical as a tutorial, which is itself a testament to the Unix "pipe" model of programming: By page 13, they've introduced getchar and putchar, and by the end of Chapter 1, twenty pages later, you've implemented a host of useful utilities including cat, wc, and detab. In Chapter 5 you implement a function recognizable as the now-standard qsort; in Chapter 8 you implement malloc itself.

Now, I recommend "K&R1," not the more popular "K&R2." The first edition was issued in 1978 at a slim 225 pages; the second edition, a decade later, added conformance with ANSI… show more.

This tour de force probably couldn't get written today. Kernighan and Plauger take snippets of Fortran and PL/I code from real, published textbooks and find things to fix about them. Now, many of their specific concerns are relics of the "structured programming" wars of the 1960s (overuse of arithmetic IF and GOTO) or quirks of the programming languages in question (undeclared variables silently getting the wrong type); but this is educational in itself. If you wonder what's so bad about GOTO, or why we need to declare functions and variables before use, this book may enlighten you. And despite its age, almost every example finds some present-day analog. For example, Kernighan and Plauger's advice to avoid manually counted Hollerith strings in Fortran applies equally to manually counted array bounds in C++: don't write "int a[5]" when you can write "int a[]". The authors boil every couple of pages down to… show more.

Scott Meyers' Effective C++ series was insanely influential around the turn of the millennium. Then C++11 obsoleted almost the whole series by changing the language out from under it. This book—Scott Meyers' last, as of 2024—is the only one that remains relevant to today's C++. It assumes the reader is reasonably familiar with C++98, and then explains smart pointers, move semantics, perfect forwarding, std::initializer_list, decltype and auto, and many other "modern C++" features, in Meyers' trademark item-oriented format, which is easily digestible and quotable.

The past decade of C++ standardization has added plenty of things that this book doesn't mention; but the subjects it does talk about, by and large, have not yet become obsolete. And there's still nobody who writes about C++ quite like Scott Meyers.

This is one of the best books I’ve read on how to write better code and build more maintainable software in Python. It is well-written, concise, and to the point.

Brett’s book is a perfect companion to the other books on this list, which are more focused on data analysis and using specific libraries to build data systems.

This book greatly influenced my philosophy around style. Norman's ostensible subject is the design of physical objects, like emergency exits, shower faucets, and refrigerators, but most of what he says is directly applicable to software design and API design, too.

For example: Whatever you expose or document about your interface, the user will take that and form a mental model of the implementation—and he'll program against that mental model, not against your documentation. So you'd better make sure that your interface—by exposing certain details and deemphasizing others, appropriate naming, and so on—suggests a mental model that will be useful to the user (even if it is not correct in every particular).

For example, a horizontal rod mounted on a door affords pushing (a bit of jargon that's entered my technical vocabulary), while a vertical rod affords pulling. If you use the design language of a horizontal rod, people will… show more.

Unless you are writing a greenfield app, you have legacy code around. And even if you are on a greenfield app, you are writing legacy code right now.

This book gives you techniques for working on such a codebase. It is a really good read for learning how to refactor safely so you can work with what you are inheriting. You might notice this book is 20 years old. It’s just as relevant today as when I first read it in 2004. The concepts don’t depend on the exact language syntax.

In fact, some of the examples are in a mix of Java, C#, and C++. I really appreciate the perspective on testing that I got by reading this book.