Here are 100 books that Effective C++ fans have personally recommended if you like
Effective C++.
Shepherd is a community of 11,000+ authors and super readers sharing their favorite books with the world.
Shepherd is reader supported. When you buy books, we may earn an affiliate commission.
Computers have fascinated me since my childhood, having fond memories of my dad's ZX81, but even so I played around I was never truly captured by the programming until I recognized it as a way of writing rather than raw engineering. Through my studies of media sciences I found my fascination with how language can shape perception, and through my work in developer advocacy, I found how communities are shaped as well. Now I am fascinated with how different programming languages can shape thinking, having had the opportunity to solve problems at large companies in nonmainstream languages.
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.
This classic book is the definitive real-world style guide for better Smalltalk programming. This author presents a set of patterns that organize all the informal experience successful Smalltalk programmers have learned the hard way. When programmers understand these patterns, they can write much more effective code. The concept of Smalltalk patterns is introduced, and the book explains why they work. Next, the book introduces proven patterns for working with methods, messages, state, collections, classes and formatting. Finally, the book walks through a development example utilizing patterns. For programmers, project managers, teachers and students -- both new and experienced. This book…
I love computer programming books almost as much as I love computer programming. As a high school student in 1980 I remember typing in really frustrating source code from the book BASIC Computer Games. Was programming meant to be a black art? Was code supposed to be an impenetrable mess of buried intent? When I started getting paid to program, I was happy to see that the answer to both questions was "no." I began to seek and enjoy books that espoused the "right" way to code in a given language. Here is a handful of books that have helped me and countless others learn to produce correct, clear, and maintainable code.
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.
Since this Jolt-award winning classic was last updated in 2008, the Java programming environment has changed dramatically. Java 7 and Java 8 introduced new features and functions including, forEach() method in Iterable interface, default and static methods in Interfaces, Functional Interfaces and Lambda Expressions, Java Stream API for Bulk Data Operations on Collections, Java Time API, Collection API improvements, Concurrency API improvements, and Java IO improvements.
In this new edition of Effective Java, Bloch explores new design patterns and language idioms that have been introduced since the second edition was released in 2008 shortly after Java SE6, including Lambda, streams,…
I love computer programming books almost as much as I love computer programming. As a high school student in 1980 I remember typing in really frustrating source code from the book BASIC Computer Games. Was programming meant to be a black art? Was code supposed to be an impenetrable mess of buried intent? When I started getting paid to program, I was happy to see that the answer to both questions was "no." I began to seek and enjoy books that espoused the "right" way to code in a given language. Here is a handful of books that have helped me and countless others learn to produce correct, clear, and maintainable 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."
Most programming languages contain good and bad parts, but JavaScript has more than its share of the bad, having been developed and released in a hurry before it could be refined. This authoritative book scrapes away these bad features to reveal a subset of JavaScript that's more reliable, readable, and maintainable than the language as a whole-a subset you can use to create truly extensible and efficient code. Considered the JavaScript expert by many people in the development community, author Douglas Crockford identifies the abundance of good ideas that make JavaScript an outstanding object-oriented programming language-ideas such as functions, loose…
I love computer programming books almost as much as I love computer programming. As a high school student in 1980 I remember typing in really frustrating source code from the book BASIC Computer Games. Was programming meant to be a black art? Was code supposed to be an impenetrable mess of buried intent? When I started getting paid to program, I was happy to see that the answer to both questions was "no." I began to seek and enjoy books that espoused the "right" way to code in a given language. Here is a handful of books that have helped me and countless others learn to produce correct, clear, and maintainable code.
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.
The Complete Guide to Writing Maintainable, Manageable, Pleasing, and Powerful Object-Oriented Applications
Object-oriented programming languages exist to help you create beautiful, straightforward applications that are easy to change and simple to extend. Unfortunately, the world is awash with object-oriented (OO) applications that are difficult to understand and expensive to change. Practical Object-Oriented Design, Second Edition, immerses you in an OO mindset and teaches you powerful, real-world, object-oriented design techniques with simple and practical examples.
Sandi Metz demonstrates how to build new applications that can "survive success" and repair existing applications that have become impossible to change. Each technique is illustrated…
My first computer was an early IBM PC back when all my friends had Commodores they used for gaming. Not being able to share their games meant I had to do something else, so I read the Introduction to Basic book that came in the box. I’ve been coding, reading about coding, writing about coding, teaching about coding, and talking about coding ever since. The world of technology moves so fast that it is hard to keep up. If you’ve taken one of my courses or listened to The Real Python Podcast, I hope you’ve heard about my passion for the topic.
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.
This edition describes C as defined by the ANSI standard. This book is meant to help the reader learn how to program in C. The book assumes some familiarity with basic programming concepts like variables, assignment statements, loops, and functions. A novice programmer should be able to read along and pick up the language.
I’ve always enjoyed mentoring folks whether new or experienced in programming. Whether it is teaching an intern or a high school robotics student, or onboarding an experienced Java developer, it brings me joy to see people learn. I also love to read. Being able to recommend some of my favorite books can help even more people absorb all of this information.
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.
This book provides programmers with the ability to cost effectively handlecommon legacy code problems without having to go through the hugelyexpensive task of rewriting all existing code. It describes a series of practicalstrategies that developers can employ to bring their existing softwareapplications under control. The author provides useful guidance about how touse these strategies when refactoring or making functional changes to codebases. One of the book's key points is that it teaches developers to write teststhat can be used to make sure they are not unintentionally changing theapplication as they optimize it. Examples are provided in Java, C++, and Csharp,and…
I've been in the software engineering profession for over 40 years, working at companies as diverse as Bank Leumi, Jet Propulsion Laboratory, Graftek (a CAD startup), Silicon Graphics, Boeing, and Microsoft. As an architect, lead, manager, director, writer, and now career coach, I've been obsessed with finding practical ways to make my work easier, my staff and clients more productive, and our products more delightful. These five books (along with my book and blog) provide proven, time-tested techniques. Each is written clearly with real-life examples, so it is easy to reap the benefits. Smile as you learn to avoid the missteps made by those who coded before you.
Not only does this book provide insight into the planning and development of one of the first visual IDEs, it’s overflowing with hilarious, profound, and pragmatic real-life lessons for how to manage a software team and deliver a complex project.
As a product of its time, the writing isn’t always politically correct. However, many of the lessons and memes are still part of our vernacular today: Don’t flip the bozo bit; If you build it, it will ship; and [Love] the customer.
Some of its lessons should be memes: Beware of [an engineer] in a room, Be an authority, not an authority figure, and Don’t trade a bad date for an equally bad date.
Some sections show their age in our current world of continuous delivery, but few current books have the humor and concise insight of this remarkable work.
Shipping great software can be done, insists McCarthy, and charts, in five sections, the progress from initial design to successful product. McCarthy is a software industry veteran and the director of the Microsoft Visual C++ development group.
As a computer science professor and educator, my teaching motto is Rigor and Vigor. I believe that the only way to learn something deeply, whether it's an abstract mathematical argument or a complex computer system – is building the thing from the ground up, from first principles. That's the rigor. The second requirement – vigor – comes from the need to make this learning experience captivating, rewarding, empowering. I spent much of my career developing books, courses, and games that help learn computer science and mathematics with gusto. I am pleased that this work has had an impact, and that it resonates with many students and self-learners around the world.
This weighty tome delves deep into the low-level working of computer programs.
This book is a great resource for professional programmers who work close to the machine in such fields as embedded software, cybersecurity, and device drivers. Assuming a basic knowledge of the C language, Bryant and O’Hallaron, two CMU professors, teach how to read and understand compiled code, how to optimize it for better performance, and how to avoid common pitfalls.
This is a hard-core technical book, written by engineers for engineers, in a dense style that is nonetheless accessible and practical. I like the numerous applied problems, each accompanied by a worked-out solution.
&>standalone product; MasteringEngineering (R) does not come packaged with this content. If you would like to purchase both the physical text and MasteringEngineering search for 0134123832 / 9780134123837 Computer Systems: A Programmer's Perspective plus MasteringEngineering with Pearson eText - Access Card Package, 3/e
Package consists of:
013409266X/9780134092669 Computer Systems: A Programmer's Perspective, 3/e
0134071921/9780134071923 MasteringEngineering with Pearson eText -- Standalone Access Card -- for Computer Systems: A Programmer's Perspective, 3/e
MasteringEngineering should only be purchased when required by an instructor.
For courses in Computer Science and Programming
Computer systems: A Programmer's Perspective explains the underlying elements common among all computer…
As a kid, I used to do all the math problems in my textbooks just for fun, even if they weren’t part of a homework assignment. My grandchildren cringe when I tell them this. I am a researcher and educator in secure software engineering and have enjoyed a productive career in software development and management, software engineering and software security research, and software and secure software engineering education.
The title says it all. This is probably one of the first, if not the first book on secure
coding, by a pioneer in the field. Robert
worked tirelessly to make this happen. Although the book has been superseded by
the secure coding standards that evolved from it, it is still a good read and
contains a lot of useful information for developers.
Learn the Root Causes of Software Vulnerabilities and How to Avoid Them
Commonly exploited software vulnerabilities are usually caused by avoidable software defects. Having analyzed tens of thousands of vulnerability reports since 1988, CERT has determined that a relatively small number of root causes account for most of the vulnerabilities.
Secure Coding in C and C++, Second Edition, identifies and explains these root causes and shows the steps that can be taken to prevent exploitation. Moreover, this book encourages programmers to adopt security best practices and to develop a security mindset that can help protect software from tomorrow's attacks, not…
If someone had told me during my early professional years that I would become a strong advocate for functional programming and the author of a fundamental book on functional software engineering, I would have found it hard to believe. Was functional programming truly worth dedicating my life to? However, once I experienced the sheer beauty of functional programming, there was no turning back. I delved deep into Haskell and functional C++, and began writing articles, giving talks, and developing various technologies. I realized that I possessed a truly unique perspective on approaching software engineering in functional languages, and that there was a significant knowledge gap that needed to be filled for the benefit of all.
I'm a devoted advocate of functional programming and a passionate Haskell enthusiast.
Ironically, there was a time in my life when I was a student and held the belief that functional programming was merely an impractical academic pursuit.
However, I soon had a revelation that the techniques I employed in C++ to mitigate the inherent unsafety of the language actually aligned with the core principles of functional programming: immutability, purity, and composability.
This realization left a profound impression on me, prompting me to delve into learning Haskell. It proved to be a pivotal moment that significantly shaped my entire career trajectory.
As I delved deeper into functional programming, I discovered a significant void in terms of software engineering practices that were prevalent in the realm of object-oriented programming.
Drawing from my experiences in C++ and C#, I noticed numerous gaps in our understanding of how to build robust applications using…
Functional and Reactive Domain Modeling teaches readers how to think of the domain model in terms of pure functions and how to compose them to build larger abstractions. It begins with the basics of functional
programming and gradually progresses to the advanced concepts and patterns needed to implement complex domain models. The book demonstrates how advanced FP patterns like algebraic data types,
typeclass based design, and isolation of side-effects can make models compose for readability and verifiability.
On the subject of reactive modeling, the book focuses on higher order
concurrency patterns like actors and futures. It uses the Akka framework…
