Software Engineering Books for "NCG" (new college grads)

07 Sep 2020

This blog post describes my top books for NCG (new college grads) starting a career as a serious software engineer.

Let’s say it right away: This is absolutely guided by my Pure Storage experience and targeted for a similar audience. Pure Storage is a Modern C++ engineering company who in the last decade built a high-performance, low-latency storage system optimized for Flash. A software engineer writing frontend code with JavaScript on the frontend might different requirements and should read different books. However, some of the books on my list would apply.

Titus Winters states his definition of Software Engineering in “Software Engineering at Google” as “Software engineering is programming integrated over time” (see also 2017 Cppcon Video). I see my work still more as a craft than an engineering discipline, but there is valuable, often ignored insight here.

The list is inspired by a conversation with a couple of junior engineers and my experiences in the first project I led some years ago where had the opportunity to mentor a number of new hires. All of them were really good at data structures and algorithms. The large emphasis on these topics in the interview process of all major tech companies helped. All were good programmers. All did a number of internships and had projects during their studies. However, at that time, they were not yet software engineers.

They do not have to. I didn’t expect that nor can I expect that. The CS programs have to focus on Computer Science. It is in the name. Computer Science is the cornerstone of systems and infrastructure development. You need to have a solid understanding of data structures and algorithms as well as principles of operating systems and concurrency. But it isn’t enough.

Programming is important because we actually have to deliver software, even if in my experience German universities would like to eradiate that part of the trade. We do not deliver a design document, nor a technical report or proof. We are expected to deliver working software. And we do have to maintain it for years to come.

There are a couple of books that can partly fill the gap left by CS programs:

The first book I want to recommend is “Effective Modern C++”. This is a must-read when writing modern C++ code. At Pure. we do not use exceptions so some recommendations do not apply. Neither do we use unique_ptr/shared_ptr but the principles of smart pointers, move semantics and strong ownership of memory still apply. The vast majority of tips from this book apply. So far so boring and uncontroversial, but the book is still more about programming in C++ then Software Engineering.

The second book on my list was “Effective Java (3rd edition).

Hear me out. I am a Java programmer by trade, so I might be biased, but I strongly recommend this book to C++ programmers. I wrote a blog post about it discussing why I think all C++ software engineers should read that book and how Java and C++ in some are getting very similar.

There is a significant lack in the C++ world on books discussing engineering for the higher-level concepts that “Effective Java” excels at. Effective Modern C++ is soo focussed down in the important low-level trickery of C++. With one chapter about smart pointers alone and one chapter about different reference types alone, that there is no space to discuss more higher-level concepts. But the higher-level concepts are equally important in C++ then they are in Java.

Honestly, no other book changed my perspective on software programming as much the first edition of this book did. I was really at the beginning of the transition from programmer to software engineer. The book focus on class contracts. For me it was an eye-opener. That you should write software that is not only correct in the moment, but still correct when code around it changes when it is used in different scenarios.

The third book on the list of quite old: “Code Complete 2” from 2004. The book is extremely comprehensive and not focused on a single language or domain. It covers everything from requirements, class design, method design, testing, debugging, refactoring, craftsmanship, and other topics. The book has a clear scientific approach to it containing lots of statistics why software construction and clean code matter as well as references to other literature and research. It has the advantage that is not to domain-specific as some of the other books.

Actually, a lot of these books are from the early 2000th. My first thought was this is my own bias because that is the time I grow up learning professional coding. But it appears that these are still the leading books in that area. So much has changed in the 10-20 years, but these books are still useful.

The fourth book on my list is “Clean Code: A Handbook of Agile Software Craftsmanship”. It is quite Java-specific. I would argue it is more Java specific than Effective Java (see above). So, why is it on the list? It overlaps with Code Complete, but is much shorter. There are certainly parts that might work in a Java environment, but not in a storage software environment, but if you keep an eye of for these cases it is good advise.

The next book is “Design Pattern: Elements of Reusable Object-Oriented Software” aka the classical “Gang of Four” book about design pattern. What is a design pattern? It is a “general, reusable solution to a commonly occurring problem in software design”. The book’s code examples actually use C++, although an outdated coding style. If you want to know why there are classes called “visitor” or “factory” this is the book to answer that.

The GoF design pattern and object-oriented programming got a negative reputation in recent years that I do not share. However, object-oriented programming without good guidance leads to a mess that might be worse then the alternative. That is why books like this are so important.

The book “Head First Design Pattern” is related to the previous book. Don’t be confused by all the pictures and the informal writing, it is indeed a really good introduction on the topic. This book proves that you can combine good even fun writing-style with complex content. If you are done with this book, consider going back the GoF book.

Next on my list is “Programming Pearls”. It isn’t a reference at all. It is actually a small book, but it contains essays about algorithm design, debugging, tuning, and solid software engineering. Not anywhere as comprehensive as “Code Complete 2”, but still interesting tips.

A bit different from the other books is “Code Reading: The Open Source Perspective”. Pure’s code base is quite big and any big, new code base can be overwhelming. Code reading certainly is thought in any university program that I have ever seen. The book is solely focussed how to deal with large, unknown code bases and how to understand, to navigate, and to maintain them.

The last book on my list is “Practical VIM”. One issue I see over and over again is that new college grads use VIM, but without any finesse. For example, when to change a file they close VIM and re-open a different file. No buffers, no splitting. I switched from VIM to vscode around a year ago (still using the VIM plugin, which is really good) so I am not saying you should use vim, but it you do knowing your editor will be increasing the productivity of engineers. So, reading this book is recommended for people who use VIM in the first place.

When I learned programming, there were many books for a language or even libraries. These have been replaced by websites and StackOverflow. However, the more general books explaining good code construction and good software engineering principles still contain important material. They are effectively time-less or at least the survived the last decades.