A C++ Reading List by John Lakos
Looking for a different subject? Take a look at a directory of all of our Developer Reading Lists.
John Lakos, author of Large Scale C++ Software Design, serves at Bloomberg LP in New York City as a senior architect and mentor for C++ Software Development world-wide. Dr. Lakos is the founder of the BDE group and curator of Bloomberg’s burgeoning BDE/BSL open-source initiative (http://www.openbloomberg.com/bsl). He is also an active voting member of the C++ Standards Committee, Library Working Group. His next book, entitled Large-Scale C++, Volume I: Process and Architecture, is anticipated in 2014.
As a mentor to myriad practicing C++ software engineers, I’m often asked for recommendations regarding books and other resources. Some of my recommendations are new, but many of them are classic. Here’s my short list for both, with newer (reference) material toward the end.
Effective C++: 55 Specific Ways to Improve Your Programs and Designs, 3rd Edition by Scott Meyers (2005)
Scott Meyers is known for his lucid, common-sense approach to teaching journeymen and expert programmers alike how to improve their C++ code. This volume (as with its two previous editions) is packed full of day-to-day-relevant material that every practicing software engineer should know, presented in a highly digestible and entertaining manner. What’s more, I agree with virtually all of it! If you think you know how to write C++ well, read this book first and make sure before going further.
Effective STL: 50 Specific Ways to Improve Your Use of the Standard Template Library by Scott Meyers (2001)
Scott Meyers is effective at making you productive. If you are not familiar with STL, you could start with a comprehensive reference book (see below), but that might be overwhelming. Instead, I would recommend that you pick up this book and read it cover to cover to get a feel for the important highlights of what typical practitioners need to know to be productive with STL. If you are already familiar with STL, then a quick read of this book will fill in any gaps before going on to more advanced texts.
C++ Coding Standards: 101 Rules, Guidelines, and Best Practices by Herb Sutter and Andrei Alexandrescu (2004)
Herb Sutter and Andrei Alexandrescu – both industry recognized experts and repeat authors in their own right – have compiled a treasure trove of consensus advice from the writings of others (myself included), and presented it in bite-size chunks, each just a couple of pages in length and with accompanying citations. While not every topic is explored in full depth, each provides a solid starting point for consideration and further exploration. This book is a must read for anyone who is considering establishing a coherent coding standard for their group or enterprise.
Programming With POSIX Threads by David R. Butenhof (1997)
C++ has only recently begun to incorporate threading constructs into its standard library, yet multithreading has been an important adjunct to C/C++ programming for more than a quarter century. Like other topics that are subtle and deep, it is best to get a good foundation before digging deeper, and David Butenhof nailed it when he wrote this book. A graduate of this book should have no trouble writing a multithreaded program using condition variables to efficiently implement, say, multiple producers/consumers (or answering detailed interview questions on the topic). This book was my introduction to multithreading, and I found it invaluable; I hope you will too. (I’ve also heard good things about C++ Concurrency in Action by Anthony Williams).
The C Programming Language (ANSI C), 2nd edition by Brian Kernighan and Dennis Ritchie (1988)
I have long said that C++ is a delivery vehicle for C. What I mean is that – at some point – we’re going have to tell the computer the nitty gritty details of what it needs to do. The C subset of the C++ language is typically how we do that. Basic C-level concepts, such as pointers, storage classes, and lifetimes are the arithmetic upon which the rest of C++ is based, yet Brian Kernighan and Dennis Ritchie have provided us with more than just a very well written, authoritative book on C; this iconic book also embodies a wealth of collateral information on related software engineering topics in the form of highly relevant, yet concise usage examples and classic exercises (of varying difficulty) to supplement the reference text. For those of you who are modern C++ programmers, and not originally from C, working through this book would make an excellent addition to your programming resume.
The Design and Evolution of C++ by Bjarne Stroustrup (1994)
I believe it was George Santayana who said, “Those who cannot remember the past, are condemned to repeat it." In this important book, Bjarne Stroustrup has chronicled the history – collaboration, critical thinking, misjudgments, and sometimes “soap opera” – that comprised the formative years of the C++ language. What was the rationale that convinced Stroustrup to introduce the key words protected or bool? The answers to these and other interesting questions both surprised and educated me in ways I would not have anticipated, and have continued to influence me all these years. This book provides a unique perspective on how C++ came to be from the one man who knows best: its creator.
Design Patterns: Elements of Reusable Object-Oriented Software by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides (1994)
I was teaching C++ at IBM Watson Research for Columbia University back in the Spring of 1993, when I first met John Vlissides and Richard Helm. At that time, I had no idea what a design pattern was, and it took quite a while for them to get me to understand. A year later, when this book was published, I read it cover to cover, and finally understood not only what design patterns were, but why the concept is important: Documented design patterns provide a shared context and a concise vocabulary for readily expressing software sub-system architectures! I even included a design pattern, Protocol Hierarchy, in their rendering style as an appendix in my own book (see below). Design Patterns is just one of those books that you need to read through once and then continue to reference as needed.
Large-Scale C++ Software Design by John Lakos (1996)
Developing large systems requires not only a sound understanding of logical design (e.g., classes, functions, and their detailed relationships), but also physical design (e.g., files, libraries, and their dependencies). I am pleased to report that, while the syntax of C++ has evolved, the basic compile- and link-time physical design concepts this book introduced to the world nearly two decades ago apply as much today as they did then. Moreover, applicability of good physical design is not limited to C++, and can be extended to any language that supports programs having separately compiled modules. My personal authorship notwithstanding, I consider this book essential reading for anyone working on large programming projects.
The C++ Standard Library: A Tutorial and Reference, 2nd Edition by Nicolai M. Josuttis (2012)
Many of my colleagues grew up with Nico’s first edition of his very popular book on the C++ Standard Library. This second edition incorporates the many new features of C++11, while striving to retain the highly effective delivery of material found in the first. This new second edition is essential for anyone who is serious about using, maintaining, or extending, standard-conforming container/algorithm template libraries.
The C++ Programming Language, 4th Edition by Bjarne Stroustrup (2013)
Given the popularity of the C++ Language, it is easy to understand why, over the years, there have been innumerable books written about C++ – an unsettling number of which are imprecise, incomplete, or just flat-out wrong. I own all of the preceding editions of this book ( first ’85, second ’91, third ’97, and special ’00) and have consistently found the material Bjarne Stroustrup presents to be concise, complete, and accurate in context – devoid of any half-truths that might arise from oversimplification. Just as Kernighan and Ritchie did for C, Stroustrup makes effective use of relevant examples to showcase the many benefits of the C++ language. I just received this latest edition (fourth ’13) and thumbed through it. Needless to say, this book – which includes all of the additional features of C++11 – is a truly welcome addition to my library. Note that the international standard upon which this book is based can be ordered for $30 from ISO.
The C++ Draft Standard by the International C++ Standards Committee (2013)
For those who want to understand the current state of the C++ language and its libraries, there is no more proximate, up-to-date reference than the current draft of the C++ Standard – the most recent version of which can be found as an N-numbered paper (along with other papers proposing new features for C++) at http://isocpp.org/files/papers.
Large-Scale C++, Volume I: Process and Architecture by John Lakos (2014)
Since my previous book, Large-scale C++ Software Design, was first published in 1996, I have continued to work on and learn about developing large systems, first at Bear Stearns, and then – for the past 12 years – at Bloomberg, where I am today. During this time, I have continued to expand and refine a comprehensive development methodology organized around the physical design concepts I pioneered, as well as important new logical design issues, including logical/physical name cohesion, common class categories, proper value semantics, appropriately narrow contracts, and component-level testing. This first volume (of three) focuses on the motivation for, and physical design aspects of, organizing software that can form a cohesive framework that scales to (tens of) thousands of programmers, working on multiple versions of many applications and projects, spanning dozens of calendar years.
Since joining Bloomberg in 2001, my team – the BDE team – and I have been focused on developing and refining a methodology that yields hierarchically reusable libraries. After over a decade of in-house-only development, we are finally ready to open-source these libraries starting with the root, bsl: (1) to serve as a framework for further development, and (2) to demonstrate how it is done.