Backendology A study of backend web development by Jared Ririe

Top 10 Books for New Software Engineers

Top three software books

I’m excited to share my top ten list of books new Software Engineers should invest in reading! These books have proved foundational in helping me transition from student to developer and deepen my skills.

First, a disclaimer: there are some great books missing from this list because I haven’t read them yet. I want this list to be as authentic as possible and therefore I will not recommend a book until I’ve read it cover to cover. If you have read an impressive book that you think deserves a spot on this list, comment and I will check it out!

Top Ten

10. The Master Algorithm

The Master Algorithm is a high-level introduction of both the history and latest advances within Machine Learning. While you may not be a data scientist or particularly passionate about this area of Computer Science, it’s becoming increasingly important to have at least a cursory understanding of Machine Learning. This book fills this need of providing exposure without dragging the reader into the deep end; that said, it’s definitely a technical and challenging book.

9. The Pragmatic Programmer

While The Pragmatic Programmer is a bit dated in parts, it remains a classic software book that every developer should read. It is the original source of many best practices that have been shared by word of mouth through the years. As the book progresses, many memorable pragmatic tips are shared. These are some of my favorites:

  • Care about your craft
    • If you are serious about a software career, you should care about the quality of the work you produce
  • Think about your work
    • Constantly critique your work
    • Disable auto pilot
  • Don’t live with broken windows
    • Fix bad design and code as soon as you notice it
  • Use tracer bullets to find the target
    • Get a simplistic end-to-end solution working first so you know you’re on track
  • Prototype to learn
    • The purpose of prototyping is to learn, not to produce code for the final product
    • Prototyping is different from using tracer bullets
  • Use a single editor well
    • Learn keyboard shortcuts
    • Program and extend your editor to make it your own
  • “select” isn’t broken
    • When debugging, remember that the OS, compiler, or standard library are rarely the problem. It’s your code that’s broken
  • Refactor early, refactor often
  • Test your software, or your users will
  • Find bugs once
    • Once you have identified a bug, ensure through regression testing that the bug will never crop up again
  • Build documentation in, don’t bolt it on
    • Documentation that is part of the code is more likely to be kept up to date

One part of the book that has stayed with me is the analogy of the woodworker. For woodworkers, the primary material of their work is wood and as such, they become intimately familiar with wood and the tools used to manipulate wood. The correlating material for a developer is text. Some of our tools include editors, IDEs, and terminals. Just like the woodworker, we need to become familiar with text and the tools that manipulate it. It’s pragmatic to learn keyboard shortcuts and automations. It’s wise to know one editor and terminal extremely well. It surprises me how many programmers don’t know simple shortcuts like alt + left/right arrow to move the cursor in increments of words rather than characters! Common editor features like multi-cursor select elude many, yet I don’t know what I would do without it–I find at least one application of this feature every day. It has uses for many things outside of renaming a variable in code.

8. Eloquent JavaScript (Print, Free Online Version)

This is one of those programming language books that teaches a lot about programming in general, not just a particular language. For example, the Robot path-finding project chapter piqued my interest in depth-first and breadth-first search for the first time since college. I also appreciated the author’s focus on composable, eloquent code that pushed me to write better code.

One oddity to be aware of is that chapter 1 of this book gives the impression that it’s beginner-focused; the author includes detailed analogies to help explain variables, for example. A few chapters later, though, you cover techniques used in functional programming. My recommendation is to skim through the early sections and then slow down as it quickly becomes a challenging read. The author applies rigor to a language that would never be described as rigorous.

The third edition of this book came out recently with thorough updates; all the code has been updated to ES6, helping the content feel more like the “Modern JavaScript” programmers are likely to encounter in the wild. The runnable code snippets in the online version were very helpful in interacting with the content.

7. Go In Practice

While the space for books about the Go programming language is growing, it’s particularly thin when it comes to books geared towards intermediate to advanced developers. Go In Practice is for an intermediate audience and it did a decent job of exposing me to some new techniques that I was not familiar with. The pattern of showing a problem you might run into, talking through various solutions, and ending up with a generally applicable technique is used throughout the book; I found it instructive.

The section on concurrency was particularly detailed compared to what I had read previously. I also learned a great deal about panics in Go and when it’s appropriate to handle them in application code, almost like a try-catch in other languages. The content about templates hasn’t proven useful for me, but that’s likely because that’s not how I’m using Go.

My overall recommendation is to look elsewhere for resources to learn Go, but if you are set on a book, I think this is a solid choice.

6. Cracking the Coding Interview

The coding interview, whether you agree with it or not, is the de facto way to interview candidates. While not all skills that are required to be good at interviews overlap with skills necessary for the job, there’s enough overlap to keep this practice going.

Take time to get good at coding interviews. This book is a great way to do just that. I can’t say that I’ve read this book cover to cover like the others, but I do practice 10-20 interview questions each quarter to keep my skills sharp. This has helped me develop my algorithm and data structure skills. With a Computer Engineering degree, I never took some advanced CS classes like algorithms, so I had a lot of catching up to do in this space.

An honorable mention in this area of algorithms is Grokking Algorithms. It’s an approachable book that explains data structures and algorithms with cartoon-like visualizations. As it’s written in such a way that non-programmers could also understand, I found it to be a quick read that taught these concepts in a different way than I originally learned them (Data Structures course with a textbook).

5. The Complete Software Developer’s Career Guide

John Sonmez is an example of a software engineer turned entrepreneur who has made an impressive impact in his career and as a result done well financially. He focuses on teaching software developers how to have a successful career (landing the best-possible job, getting promoted, learning efficiently, picking a specialty, generating passive income, etc.). I found his advice very motivating and have applied several of his ideas with success.

The book is quite lengthy, but it’s an easy, not highly technical read filled with great content that made me genuinely excited to keep reading.

John Sonmez also wrote Soft Skills: The Software Developer’s Life Manual which is worth checking out for more of this kind of content.

4. Clean Architecture

Clean Architecture is written by the same author as Clean Code (Robert Martin). As the differing names suggest, Clean Architecture takes a broader view of software. That said, one of the key points the author makes is that the same patterns that apply to designing the components of a single system also apply to arranging the pieces which make up the architecture. That is, an idea like loose coupling is important in the structure of code and the arrangement of the architecture.

This book changed the way I thought about the code I write and the systems I help design. It helped me to structure my code such that the business logic is in the “inner” portion of the architecture, decoupled from the “outer” portion which handles transforming data to/from external sources. A concrete example of this is that the core logic of your service should not need to change if you change the means of communicating with a service from HTTP to a command-line interface.

While the book can come off as opinionated, the opinions are well supported and thought provoking even if you disagree with them.

3. Building Microservices

Building Microservices is the book that helped me make sense of the wonderful and horrific world of microservices. It was immediately applicable to the projects I was working on at work, so I feel like I came away with a deep understanding of its concepts. I would learn about a concept like circuit breaking one day and implement it the next, which made for an enriching learning experience.

If an engineering team was considering adopting microservices, this book would help them understand the work they were signing up for to support such a system. As it gives such a holistic view of microservices, it’s also a great read for someone who works in such an architecture without understanding all the concepts and complexity. Here are some of the topics covered:

  • Service discovery and DNS
  • Monitoring
  • Continuous integration
  • Splitting monolithic systems
  • Building resilient systems with partial degradation of functionality
  • Asynchronous event-based collaboration

Engineers at the company I work for (Qualtrics) can optionally read and discuss a “book of the quarter.” This book was selected one quarter as we’re right in the middle of splitting apart the monolithic PHP system that bootstrapped our company to where it is today. I think many other companies are in a similar spot and will find value in this book.

2. NoSQL Distilled

If you work with NoSQL databases or are considering doing so, I consider this book a must-read. It’s quite compact (just over 150 pages) yet efficiently teaches critical database concepts necessary to understand NoSQL. The material of this book helped me operate a NoSQL database called Couchbase and understand the implications of its failure scenarios.

I actually read this book twice, first just as I started my career and then again two years later once I had a better understanding of databases. To be honest, I didn’t understand it very well the first time as everything was new. Reading technical books multiple times can be extremely useful as it often takes additional experience to grasp difficult concepts.

After explaining the main types of NoSQL databases (key-value, document, column-family, and graph), NoSQL Distilled dives into sharding, replication, and consistency. These are critically-important chapters as they give you the vocabulary you need to understand databases in general. I noticed that my understanding of research papers on the topic of databases increased dramatically after reading this book simply because I could speak a bit of their language. This book also prepares you to decide on and then defend your choice of the best database for your use case.

1. Designing Data-Intensive Applications

This book is phenomenal and can stand confidently in the number one position in this list! I strongly believe that all software engineers should make their way through this book! It’s on the lengthier side (624 pages) with sometimes dense and advanced content, but it’s well written and incredibly relevant to the data-intensive systems being built today.

If you’re an experienced developer, you may think the book is too introductory from the first two chapters. Keep reading and you’ll find rigorous explanations of concepts within distributed and database systems that will give you depth in these areas. This book could be explained a combination of Building Microservices and NoSQL Distilled, supplemented with a whole lot more goodness. Glancing through the table of contents reminded me of some of the most helpful content:

  • Data models and query languages
  • Encoding (Protocol Buffers, Avro, etc.)
  • Dataflow through databases
  • Replication and all its flaws (much more detailed coverage than in NoSQL Distilled)
  • Levels of isolation within various databases
  • Partial failure in distributed systems
  • Unix single responsibility principle
  • Unreliable clocks
  • Consistency and consensus
  • Batch and stream processing

Check out some of Martin Kleppmann’s blog posts for a sample of the awesome content contained in this book:

Current reading list

I keep an updated and prioritized list of books I would like to read. Here are some of the software-focused books on that list:

Metadata and Navigation


Subscribe via my newsletter or RSS feed

Share this post!