Fans pick 96 books like Smalltalk Best Practice Patterns

C++ is a tricky, beastly language, and there are no end of ways to program either incorrectly or inefficiently with it. Meyer's 1991 book set the bar high for similar books to come, providing great, detailed explanations about the language's pitfalls and how to avoid them. After reading Effective C++, though, you might find yourself wondering why you are coding in C++: The tips reveal so many insidious ways to shoot yourself in the foot, and worse, sometimes in a way that you won't even notice that your little toe is missing.

Effective C++ and the two follow-ons are essential reading for anyone working in C++. Nowadays you can purchase a digital edition that provides 140 total ways—adding in 50 additional tips from More Effective C++ and 40 from Effective STL.

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.

Distributed systems are everywhere now, but long before there were telephony switches, and Erlang was built to make those work.

Reading this book gave me not only an understanding about Erlang, but the language and understanding to talk and think about systems which are distributed from the beginning, not as an afterthought. For me personally Erlang/OTP is the DSL for dystributed system and the patterns implemented have applications every time I think about distributed systems now.

Lisp will always have a special place in my brain, not language can be as expressive and molded to what the programmer wants to do in my opinion.

Learning a programming language can be a bit dry, but not in the case of Land of Lisp, honestly I just found this book to be fun from beginning to end, and even so I was already familiar with Lisp before reading it I actually followed all the way through not skipping a page.

Yes Lisp is hardly in use these days, but if you know it you will find its concepts popping up all over the place and this is why knowing it is so useful.

Not really a programming book, Modern Operating Systems has been influential for me to understand what I am working with.

When learning about how OSs do their job it is impossible to know everything, but having a rough picture and being able to know how and where to drill down further is what it is all about and this is where this book really shined for me. Even when never writing a driver or working with kernel code, knowing how the details fit together helps in estimating complexity.

The knowledge I got from this book more than once helped me recognize when something was too good to be true, or simplify complex software by working with not against the OS, in my opinion a must read for every programmer.

I learned my first programming language as a kid, and Basic always felt like a beginner’s language. It wasn’t until I started writing C that I felt in control of the machine. This book is a classic and was on every C-programmer’s shelf in the 80s and 90s. It isn’t the easiest read but is remarkably comprehensive for a relatively thin volume. The fact that it has been in print for over 30 years tells you something about its staying power.

Nowadays, I tend to code in higher level languages, but every once and a while I dip down, getting closer to the bare metal, and brush this baby off. It is probably one of my most well-worn books.

Of all the books I recommend, this is practically a sort of personal bible, which I very frequently consult.

This book doesn't just show you how to code; with realistic patterns and real-world examples, it's like having experienced mentors guiding your every keystroke. These patterns aren't just snippets; they're blueprints for building robust, flexible software.

I think the book is practically mandatory for all developers, novice or seasoned. It transformed how I approach problems, teaching me techniques I use daily in systems design and development.

Few people want to grow up like their parents. In the early 2010s, many programmers scoffed at the design principles of the ‘90s. Why should anyone care about the nuances of object-oriented design? That’s such a Java thing to bother with!

To seasoned developers, this rejection felt like a baby and bathwater situation. Then Sandy Metz came to the rescue. Her book persuaded younger developers (or at least, those in the Ruby community) that those old ideas were still valuable.

Practical Object-Oriented Design in Ruby traced a straight line from the pioneering times of Smalltalk, through the years of the software craftsmanship movement, directly to modern programming.

It’s a timeless book in the best sense of the word: it would have felt relevant back in the 90s, or when it was published, or today. Few people want to grow up like our parents–but as it turns out, we all do.