programming books

Programming Books

A Reading List for Software Craftsmanship

As an Amazon Associate, I earn from qualifying purchases. I'm grateful for anyone who wants to use my links to support this website.

1. Novice

Novice programmers knows how to program but has yet to build something substantial, like taking an idea to a finished and released application. If you are a beginner start by reading this article.

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.

    Further reading:
  • Nine Algorithms That Changed the Future - Buy from Amazon
    The Ingenious Ideas That Drive Today's Computers
    John MacCormick
    How come Google's search engine can be so fast, or that a computer can recognize your handwriting? This programming book explains how computers utilize algorithms to accomplish tasks we today take for gratned.
  • Smart Until It's Dumb - Buy from Amazon
    Why artificial intelligence keeps making epic mistakes (and why the AI bubble will burst)
    Emmanuel Maggiori
    AI is tremendously valuable, but it has been the victim of overhype for as long as it has existed. It will not save mankind, and it will probably neither be its doom. So, what is AI good for, and what can we expect from it?

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.

    Further reading:
  • Really Friendly Git Intro - Buy from Amazon
    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.
  • Small, Sharp Software Tools - Buy from Amazon
    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.
  • Practical Vim - Buy from Amazon
    Edit Text at the Speed of Thought
    Drew Neil
    Vim is that mysterious thing you sometimes accidentally open when you want to edit files in the terminal. I jumped on the Vim train pretty late, but the more I use it, the more I like it, and the tool has stood the test of time. So don't be like me and disregard Vim because getting started is scary.

2. 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.

    Further reading:
  • The Clean Coder - Buy from Amazon
    A Code of Conduct for Professional Programmers
    Robert C. Martin
    Learn form someone who has made many misstakes instead of making them yourself on what makes a programmer professional and how can we earn trust.

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.

    Further reading:
  • The Golden Ticket - Buy from Amazon
    P, NP, and the Search for the Impossible
    Lance Fortnow
    Can all problems be solved within a reasonable amount of time? What would the world look like if that were true? Read this book and discover why some problems are hard to calculate.
  • Programming Perls - Buy from Amazon
    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.

Grokking Simplicity

Taming complex software with functional thinking
Eric Normand

Functional Programming is growing in popularity, and it’s a paradigm with a lot to teach about how to design a system. This book covers how to minimize mutability and separate concerns, and the last chapter briefly introduces reactive programming and the onion architecture.

Thinking like a functional programmer can help you write simpler code and reduce system complexity.

    Further reading:
  • An Introduction to Functional Programming - Buy from Amazon
    Through Lambda Calculus
    Greg Michaelson
    Lambda calculus is a tiny mathematical programming language that is the origin of *functional programming*. For people who want to understand *functional programming*, there are few better books.
  • The Little Schemer - Buy from Amazon
    Daniel P. Friedman & Matthias Felleisen
    The Little Schemer is the best introduction to how to solve problems with recursion I've read, and it also teaches a lot about computation and functional programming.

    The author uses a Socratic writing style giving this a feeling like he is talking directly to you.

The Object-Oriented Thought Process

Matt Weisfeild

The fundamentals of Object-Oriented Programming (OOP) are easy to overlook. Don’t do that; there is plenty to learn from OOP. There are many misconceptions about OOP; it can be an excellent tool for designing maintainable applications if appropriately used.

    Further reading:
  • Elagant Objects Vol. 1 - Buy from Amazon
    Yegor Bugayenko
    There are a lot of misunderstandings about what *Object-Oriented Programming* (*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. Many of the recommendations in this book will seem extreme to some practitioners of *OOP*, but before disregarding them, try them, and maybe you will find that these crazy ideas are not that crazy.
  • Elegant Objects Vol. 2 - Buy from Amazon
    Yegor Bugayenko
    The continuation of the controverial first book with some more ideas on how to be more object-oriented and some revisits of the first book with more depth.
  • Practical Object-Oriented Design - Buy from Amazon
    An Agile Primer Using Ruby
    Sandi Metz
    Designing a system with **Object-Oriented programming (OOP)** requires knowledge if you don't want it to become a [big ball of mud]( This programming book teaches you to design classes with a single responsibility and compose them with well-defined interfaces that send messages to each other.

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.

3. 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.

    Further reading:
  • Agile Testing Condensed - Buy from Amazon
    A Brief Introduction
    Janet Gregory & Lisa Crispin
    Why does usability matter, and how do I achieve it? You don't need to be an expert on the subject (but having access to one helps) to make a usable application. This book will give you tools to improve your application for its users.
  • Clean Agile - Buy from Amazon
    Back to Basics
    Robert C. Martin
    Agile is a diluted term caused by years of misunderstandings. Uncertainty leads to confusion for people in the industry. Taking a look at where agile started and where it ended up 20 years later is illuminating.
  • Code with the Wisdom of the Crowd - Buy from Amazon
    Get Better Together with Mob Programming
    Mark Pearl
    This programming book discusses how to start **mob programming** and what to do when it does not work out as planned.
  • Continuous Delivery - Buy from Amazon
    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.
  • Extreme Programming Explained - Buy from Amazon
    Embrace Change
    Kent Beck
    XP came before the [agile manifesto]( and hugely influenced it. The name comes from taking good practices and taking them to an extreme. Reviewing code is good, and an extreme variation of that would be pair-programming.

    Adopting XP practices can help your team. Be wary of trying too much too early and giving up before giving it a fair chance.
  • Software Teaming - Buy from Amazon
    A Mob Programming, Whole-Team Approach
    Woody Zuill & Kevin Meadows
    Mob programming is the most agile practice I've tried. The authors of this book have shared their experiences and discoveries with you so you can more easily get started.
  • User Stories Applied - Buy from Amazon
    For Agile Software Development
    Mike Cohn
    User stories are where the developer and customer decide what to build. For example, they should communicate value to the end-user so the customer can prioritize and help the developer discover a solution.

    It's easy to get lost in all the jargon when gathering, writing, and planning stories. However, the author does an excellent job describing common problems and their solution.

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.

    Further reading:
  • Clean Architecture - Buy from Amazon
    A Craftsman's Guide to Software Structure and Design
    Robert C. Martin
    What is a good way to structure your project?

    Code can be difficult to get right on the function level, but getting a whole project to be cohesive and support change is no easy task. You might never have to switch UI framework or database provider, but separating these concerns can make a massive difference in maintainability.


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.

    Further reading:
  • The C Programming Language - Buy from Amazon
    Brian W. Kernighan & Ritchie Dennis
    C is a tremendously important programming language that enabled operating systems to be written without an assembly language, making them more portable than ever (look at Unix and Linux). C will teach you about memory management and be a precursor to understanding how operating systems and compilers work (many are programmed in C).

Don't Make Me Think

A Common Sense Approach Web and Mobile Usability
Steve Krug

The right tool for the right problem is the name of the game. For smaller projects, the choice of databases has little impact. In distributed systems, what database you use can make a huge difference in response times.

    Further reading:
  • The Design of Everyday Things - Buy from Amazon
    Don Norman
    As a developer you are building products even though you might not be As a software developer, you are building products. Even though you might not be responsible for how a UI looks, it's essential to understand what makes a great product. Lessons learned in the book can also be applied to your 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 context. Pattern familiarity can significantly enhance your ability to design modular and decoupled code, but also to understand frameworks and communicate ideas.

    Further reading:
  • Design Patterns - Buy from Amazon
    Elements of Reusable Object-Oriented Software
    Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides
    This programming book is considered a classic for good reasons. It's a great book, and understanding it will significantly help you solve problems and understands other people's code.

    It contains a log of diagrams that can take time to get used to, and the examples are in C++.
  • Dependency Injection - Buy from Amazon
    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.

The Manga Guide to Databases

Mana Takahashi & Shoko Azuma

Knowing your way around SQL and databases is vital for most projects. This fun introduction to designing and using databases will not make you a database guru, but it will give you enough to get stuff done and prepare you for other database books if you wish to learn more.

    Further reading:
  • The Practical SQL Handbook - Buy from Amazon
    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.
  • Seven Databases in Seven Weeks - Buy from Amazon
    A Guide to Modern Databases and the NoSQL Movement
    Eric Redmond and Jim R. Wilson
    The right tool for the right problem is the name of the game. For smaller projects, the choice of databases has little impact. In distributed systems, what database you use can make a huge difference in response times.

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.

    Further reading:
  • 97 Things Every Programmer Should Know - Buy from Amazon
    Collective Wisdom from the Experts
    Kevlin Henney
    Kevlin Henney has done a remarkable job collecting 97 tips from a broad range of developers. This book is bound to expand your perspective on programming. I'm confident that some tips in this book will make you think differently about programming.


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.

    Further reading:
  • Refactoring To Patterns - Buy from Amazon
    Joshua Kerievsky
    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.
  • Tidy First? - Buy from Amazon
    Kent Beck
    The book Refactoring discusses the topic when to refactor and gives some good advice. This book thakes that topic and asks the question if and when you should tidy your code and what implications does it have. The book is short, fun, and interesting, but not not a light read.
  • Working Effectively with Legacy Code - Buy from Amazon
    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.

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.

You might want to revisit Exercies for Programmers and try to work through it with one of these languages.

    Further reading:
  • Getting Clojure - Buy from Amazon
    Build Your Functional Skills One Idea at a Time
    Russ Olsen
    The simplicity and consistency of Clojure is a delight to work with and learning more about Lisp like langues is a good investment.

    There is more to read after you have finished this book: Clojure Applied, Joy of Clojure, and Elements of Clojure.
  • Get Programming with Haskell - Buy from Amazon
    Will Kurt
    Diving deeper into Haskell and learning how you can solve problems with its features and limitations will indeed challenge your thinking about data structures and functions. I'm confident that knowing how to build programs with Haskell will make you a better programmer.
  • Learn Functional Programming with Elixir - Buy from Amazon
    New Foundations for a New World
    Ulisses Almeida
    Functional programming is more common today than ever. Immutable data and higher-level functions are powerful concepts applicable in all programming languages. Some languages make adoption more natural than others, but the ideas are still valuable.

Test-Driven Development

By Example
Kent Beck

Test-Driven Development (TDD) 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 and I can’t think of a better place to start than with this book.

    Further reading:
  • Growing Object-Oriented Software, Guided by Tests - Buy from Amazon
    Steve Freeman and Nat Pryce
    Testing and TDD (test-driven development) are hard skills to learn. A common complaint is that TDD only works for lesser problems and not for real applications, A ridiculous idea! This book takes you on a TDD journey, building an application tat goes beyond toy examples.
  • xUnit Test Patterns - Buy from Amazon
    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.

4. 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!

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.

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

Domain-Driven Design (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.

    Further reading:
  • Domain Modeling Made Functional - Buy from Amazon
    Tackle Software Complexity with Domain-Driven Design and F#
    Scott Wlaschin
    Domain modeling is about turning the shared domain model of the product into code. But, of course, any programming language can accomplish this, and functional programming is pretty good at it.
  • Patterns of Enterprise Application Architecture - Buy from Amazon
    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.

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.


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.

    Further reading:
  • The Mythical Man-Month - Buy from Amazon
    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.

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.

TCP/IP Illustrated

The Protocols, Volume 1
Kevin R. Fall & W. Richard Stevens

How the bits from one computer ends up on another computer is something we take for granted. Understanding how devices communicate will make your life more enjoable since it will not seem like magic anymore.