programming books

Programming Books

An Ordered and Curated Reading List for Software Craftsmanship Growth

This list is the order I wished I had read these books when I started reading programming books. I have tried to maximize learning per page in this list. It will take years to read them all, so don’t stress it and take your time. Remember, It’s not a competition; It’s about learning and improving skills in our craft.

All links to Amazon on this website are affiliate links. I’m grateful for anyone who wants to use them to support this website.

1. Beginner

A beginner is someone who has just started to learn to write code. Reading programming books is not enough to learn to program, so I recommend beginners to read the article Beginners and Programming Books for further advice. Anyone who already knows the basics of one programming language should skip this section.


Learn to Program

Chris Pine

Programming is not natural, and it takes time to adjust one’s mind to the concept of writing code for a computer. This programming book is a gentle introduction to programming using the language Ruby, an excellent language for beginners.


Really Friendly Command Line Intro

Tracy Osborn

The Command-Line Interface (CLI) can initially be intimidating. This short little book will show you how to navigate the filesystem and list, create, move, and remove files. The CLI will be an invaluable tool throughout your career as a software developer.

2. Novice

A novice programmer knows how to program but has yet to build something substantial, like taking an idea to a finished and released application. These programming books might not be very challenging for the more experienced developer.


Exercises for Programmers

57 Challenges to Develop Your Coding Skills
Brian P. Hogan

Practice is essential to get good at programming. This programming book contains no solutions, is language agnostic, and will take you from small programs that display “hello, {name}” in a terminal to complete applications that utilize network, persistence, and UI, all without ever overwhelming you. It does this by introducing new concepts and challenges gradually for each exercise.


Explain the Cloud Like I'm 10

Todd Hoff

Explaining something to someone shows a great understanding of the subject matter. Why? Because you will have to be sure you have no assumptions and only facts. Doing this for programming and distributed systems is no easy task, but this programming book does it excellently, and I’m sure this will prove most useful to any developer.


Really Friendly Git Intro

Learn the basics of Git, the version control system for programming
Tracy Osborn

Version Control Systems (VCS) are handy tools that many programmers take for granted. VCS can make collaboration manageable and help you undo mistakes easily. Getting comfortable with git (the most popular VCS) is essential for any developer. Without it, you will likely make a mess and have no easy way to find your way back to when everything was less messy.

3. Apprentice

Apprenticeship is about learning and getting comfortable with the basics. As an apprentice, you should focus on taking control of your education and seek ways to improve.


Apprenticeship Patterns

Guidance for the Aspiring Software Craftsman
Dave Hoover & Adewale Oshineye

We all struggle with the same issues in our journey to mastery, especially early in our careers when we are apprentices. This programming book contains common problems for developers and discusses how to go past them. Knowing this early in your career will give an immense advantage to those who don’t. I’m sure the advice given here will be helpful indefinitely throughout your career as a software developer.


The Art of Unit Testing

with examples in C#
Roy Osherove

Test code is essential for a healthy software project. If you have no tests, you can’t refactor your code safely or avoid regression effortlessly.

Poorly written tests can become a burden instead of an advantage if one is not careful. Writing good tests is a skill like any other, and this is a great resource to learn how to improve your test writing skills.


Grokking Algorithms

An Illustrated Guide for Programmers and Other Curious People
Aditya Bhargava

Understanding algorithms is understanding how to decompose problems and using the right tools for the job. For example, being good at memorizing sorting algorithms will bring you nowhere, but understanding how and why they work will always be helpful and make you a better problem solver. This programming book is an easy and friendly introduction to algorithms with playful illustrations that make it easy to learn algorithms and data structures.


Grokking Simplicity

Taming complex software with functional thinking
Eric Normand

Functional Programming (FP) is growing in popularity, and it’s a paradigm with a lot to teach about how to design a system. Learn how FP thinking can help you write simpler code and reduce complexity in your system. You don’t need an FP language to benefit from this code style.


The Object-Oriented Thought Process

Matt Weisfeild

Object-oriented programming (OOP) is taught in almost every curriculum that teaches programming. So, one might think that most developers understand this programming paradigm to a tee. That is often not the case.

There are a lot of misunderstandings about what OOP is and what are good OOP practices. Learning to be good at OOP can be one the most valuable things you know, as it is so common in the industry. The author ends this book with a gentle introduction to design patterns and the SOLID principles.


Pragmatic Thinking and Learning

Refactor Your Wetware
Andy Hunt

You will always need to learn new things that will never stop. Understanding how we think and learn will make your journey as a developer more manageable. Knowing how to optimize your brain for learning is well invested and will payoff immensely through the years.


Small, Sharp Software Tools

Harness the Combinatoric Power of Command-Line Tools and Utilities
Brian P. Hogan

Working with files, text, and networks is common for a developer, and the Command-Line Interface (CLI) can likely automate most of the tediousness of these tasks pretty quickly.

Being proficient with the CLI is the most cross-platform skill you can learn and will most likely always be helpful and outlive any programming language and environment.

4. Journeyman

A journeyman has a solid foundation of the basics and can stand on one’s own two feet. Now it’s time to broaden one’s skills. It’s time to leave the comfort zone and explore other ways to do things and new perspectives.


The Art of Agile Development

James Shore

Agile development isn’t scrum or any other process for that matter. Instead, it’s a collection of values and principles guiding your team and organization to work better.

This programming book discusses the first 20 years of agile development, what went wrong, and what worked, giving concrete examples and advice on what practices you and your team can adopt to become more agile.


Clean Code

A Handbook of Agile Software Craftsmanship
Robert C. Martin

There are bad and good coding habits. This programming book documents many and gives them context. Understanding what makes code difficult to read and change will help keep the codebase maintainable.

Everyone won’t always agree with everything a programming book states, which is fine. But be careful to jump to conclusions without some reflections. You can read more about that in my article When programming books are wrong.


Code

The Hidden Language of Computer Hardware and Software
Charles Petzold

Code is what you as a developer writes to solve problems for users, but what is code, and why does it work? This programming book explores the origins of code and takes you on a computer-building journey starting from logic and gates.


Dependency Injection

Principles, Practices, and Patterns
Mark Seemann & Steven van Deursen

Dependency Injection is a simple concept but provokes many questions, like where should we instantiate dependencies, when should they be injected, and do we inject everything?

This programming book shows you how to avoid using singletons or other global states for dependencies and achieve cross-cutting concerns features like logging, validation, etc., without ending up with spaghetti code.


Head First Design Patterns

Building Extensible and Maintainable Object-Oriented Software
Eric Freeman & Elisabeth Robson

Design patterns describe a problem and a general solution that can be applied in many variations depending on your specific context.

This programming book gives a thorough but gentle introduction to design patterns and goes through the most commonly used ones from the programming book Design Patterns. I strongly recommend that you also Design Patterns at some point but be prepared that it can be a challenging but rewarding read.


The Mythical Man-Month

Essays on Software Engineering
Frederick Brooks Jr.

Software is hard to build. The problems we face today in software projects are as old as software engineering. This book makes that abundantly clear. Written in 1975 about a software project at IBM in the 60s, this book feels as relevant today as it probably was back then.

Knowing and understanding common software project problems helps us mitigate them or at least know what to expect.

“Adding manpower to a late software project makes it later” - Brooks’s law.


The Practical SQL Handbook

Using SQL Variants
Judith S Bowman

Databases are everywhere, and as a developer, you will likely need to interact with one or even design one. Unfortunately, designing databases and writing efficient queries is not trivial and easy to get wrong. So, being proficient with databases is a vital skill to be a well-rounded developer today.


The Pragmatic Programmer

Your Journey to Mastery
Andy Hunt & Dave Thomas

This programming book will define and give you the recipe to be a pragmatic programmer. So don’t expect to be one just because you read it once. Instead, you need to follow their advice and take it to heart without being dogmatic.

I’m sure your definition of a pragmatic programmer will change after you have read this programming book, and it will likely change again after reading it another time a few years down the road.


Refactoring

Improving the Design of Existing Code
Martin Fowler

Refactor isn’t rewriting as much as it’s evolving the code in small steps to improve the code.

Since we seldom get something right the first time and our code will need to change (That’s why we call it software), refactoring is something we need to do as new requirements come.

Being good at refactoring and knowing how and when to do it can make it or break it for the quality of your code.

This book introduces a vocabulary for code smells and refactorings that will help your team talk about code and how to change it.


Seven Languages in Seven Weeks

A Pragmatic Guide to Learning Programming Languages
Bruce A. Tate

This programming book introduces seven paradigms through seven programming languages. The ideas and concepts from these languages have influenced many modern languages today. Without Haskell there would surely be no Swift, Kotlin, or Elm.

Exposing oneself to new ideas and concepts is helpful for perspective and problem-solving. For example, Prolog and Erlang might seem like strange programming languages with little application, but understanding them might be more beneficial than you first might think.


Test-Driven Development

By Example
Kent Beck

TDD (Test-Driven Development) is the idea of writing test code before production code and letting that drive your design. TDD is one of the most rewarding technics one can learn. Learning TDD is tough and will take time.

David Heinemeier Hansson wrote a blog post claiming that TDD can harm the quality of the production code, listen to the hangout discussion with Martin Fowler and Kent Beck, and read Uncle Bobs thoughts to find out if he was right.

5. Expert

An expert has many years of experience and intuition for software design. Adopting new technics and programming languages is not trivial but defiantly something that an expert does with ease and is fearless in asking for help from someone more well-versed in the topic.


Clean Architecture

A Craftsman's Guide to Software Structure and Design
Robert C. Martin

This programming book lays out good strategies for setting boundaries in your code. It gives a good overview of what to strive for and what to avoid.

“Clean Code” talks about how one can keep the actual code neat and tidy, and clear boundaries help a lot.


Continuous Delivery

Reliable Software Releases Through Build, Test, and Deployment Automation
Jez Humble & David Farley

Getting software in the hand of users is fast and often is essential for an agile team because agile is all about small feedback loops. Achieving this is no easy task as it requires a lot of technical excellence from the team.


Designing Data-Intensive Applications

The Big Ideas Behind Reliable, Scalable, and Maintainable Systems
Martin Kleppmann

Distributed systems backed by databases are extremely common. Designing a distributed system is nontrivial because, by nature, it involves many components and external interfaces that bind you to early mistakes.


Domain-Driven Design

Tackling Complexity in the Heart of Software
Eric Evans

DDD is a big topic, and this is the book that started it. It explains everything you need to know to make a difference in how your business communicates and your team writes code.


Patterns of Enterprise Application Architecture

Martin Fowler

As the original design pattern book, it defines a vocabulary for problems and solutions. Knowing a lot of them gives you the flexibility to explore and talk about solutions at a higher level of abstraction.

If you are getting paid to write software, you are probably working on an enterprise application. It’s tricky to get all the parts right, like database, network, and user interface code. This book will help you make the right trade-offs for the right reasons.


Peopleware

Productive Projects and Teams
Tom DeMarco

Sometimes we treat people like machines. In some occupations, this can work. In software projects, it creates problems that can be hard to fix.

People are what make software projects succeed or fail. Few problems are technical. Having a well-functioned team is more important than a modern tech stack.


Programming Pearls

Jon Bentley

So much about programming is about problem-solving. We mostly solve these problems by writing code. Programming Pearls is a classic software engineering book that discusses the topic of problem-solving in a fun and easy-to-follow way.


Refactoring to Patterns

Refactoring to Patterns
Joshua Kerievsky

The unofficial sequel to the programming books Design Patterns and Refactoring.

Design patterns solve problems, so they should not be applied if there is none. Therefore design patterns should be a product of refactorings. Never start with a design pattern but rather refactor towards or to them, and sometimes even away from them.


Working Effectively with Legacy Code

Michael C. Feathers

There are many interpretations of legacy code. This book defines legacy code as code without unit tests.

Legacy code is in all projects if large enough, and there are many good reasons for it. Working with legacy code is tiring and makes long lead times for new features. It can also be a breeding ground for regression.


XUnit Test Patterns

Refactoring Test Code
Gerard Meszaros

This book is long and, if hit when thrown, you might end up in the hospital. It is also its completeness that makes it great.

Test code needs design as much as production code. Rules and principles about clean code still apply to tests.

Test code can be problematic if not maintained. Recognizing test smells and knowing what patterns to use is vital for the health of the test suite.

6. Master

A master should display excellent problem-solving skills while producing well-written code, showing communication capabilities and deep knowledge of their craft. More importantly, a master helps her peers and wants others to surpass them. You will find these books more demanding, but they will also be more rewarding.

The road to mastery is never over. Like the black belt in martial arts, this is the beginning of something, not the end. So continue reading and learning! You can find more books I recommend on the more page.


Crafting Interpreters

Robert Nystrom

Programming languages compile to machine code for the computer to run. Deconstructing how we build programming languages will give an understanding that can make learning new programming languages trivial.


Gödel, Escher, Bach

An Eternal Golden Braid
Douglas R. Hofstadter

What do Gödel, Escher, and Bach have in common, and what does it have to do with building software? The discussion in this book about artificial intelligence and recursion is entertaining and mind opening.


Introduction to Algorithms

Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, & Clifford Stein

Don’t let the title of this book fool you in that this is an easy read. Within this book, there lies a lot of ideas and knowledge about algorithms, maybe more than you’ll ever need. So why bother learning so much about algorithms? Because algorithms are about solving problems and are a fundamental concept of programming and computer science.


Operating Systems

Three Easy Pieces
Remzi H. Arpaci-Dusseau & Andrea C. Arpaci-Dusseau

Don’t neglect how operating systems work, as they are the mediator of all software running on the machine. Understanding operating systems gives you an insight into the interplay of devices and software that can be hard to grasp otherwise.


Structure and Interpretation of Computer Programs

Hal Abelson & Gerald Jay Sussman & Julie Sussman

This classic programming book teaches concurrent programming, functional programming, lazy evaluation, and nondeterministic programming.