programming books


If you have read all the programming books on the main list, you should pat yourself on the back. I hope you learned a lot! The thing is that learning never stops, and here are even more programming books that I recommend.


Agile is a simple idea about valuing short feedback loops. But how to take this and apply it successfully is another story.

Too many have overcomplicated their process and added unnecessary cruft that slows everyone down. Remember, there is no agile process.

Agile Testing Condensed

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

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

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

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

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.

Remote Mob Programming

At home, but not alone
Simon Harrer & Jochen Christ & Martin Huber

How does the practice of mob programming transfer to remote work and distributed teams? This programming book contains the recipe the author’s team used to use mob programming in a distributed team successfully.

Software Teaming

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.

    Further reading:
  • Code with the Wisdom of the Crowd - Buy from Amazon
    How to get started with mob programming

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.

User Stories Applied

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.


There are a lot of great topics in computer science that will help you as a programmer. Not all computer science books are textbooks. Some of the best ones are pretty short and focused even if some are long. I will only put books I think are worth reading here.

Nine Algorithms That Changed the Future

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.

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.

Artificial Inteligence

AI been part of IT for a long time and it’s not going anywhere.

Smart Until It's Dumb

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?


Databases are a rich and vast subject, and learning more of them can help you avoid nasty designs and performance problems.

Seven Databases in Seven Weeks

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

Embeded Systems

The C Programming Language

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

Functional Programming

OOP is probably the most common paradigm right now. That doesn’t mean functional programming (FP) is obsolete or not worth learning.

An Introduction to Functional Programming

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.

Domain Modeling Made Functional

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.

Functional Programming in Scala

Paul Chiusano and RĂșnar Bjarnason

Scala is a multiparadigm programming language with good support for object-oriented and functional design. This programming book displays that we can apply functional programming ideas to any programming language.

Get Programming with Haskell

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

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.

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.

The Little Schemer

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 foundation of computer science is mathematics. A computer is just computing device and all that a computer is, is based on mathematics.

Good Math

A Geek's Guide to the Beauty of Numbers, Logic, and Computation
Mark C. Chu-Carroll

A computer can only do calculations, understanding math is understanding the computer and programming languages.

This book will give you an introduction to a wide array of subjects within math. Parts 1, 2, and 3 are fascinating but offer little value to your software craftsman career, and parts 4, 5, and 6 are helpful to understand how programming languages and computers work.

The Golden Ticket

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.

Object-Oriented Programming

Unthoughtful system design will always be a poor feat for future requirements, but a well-designed system is easy to change.

Design Patterns

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++. Having read Head First Design Patterns helps.

Elegant Objects Vol. 1

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.

    Further reading:
  • Elagant Objects Vol. 2 - Buy from Amazon
    More ideas on how to improve your object-oriented code

Elegant Objects Vol. 2

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.

Growing Object-Oriented Software, Guided by Tests

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 that goes beyond toy examples.

Practical Object-Oriented Design

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.

Software Craftsmanship

Software craftsmanship can mean many things. For me, it is all about learning and being better at our trade of building software.

Deliberate practice is an efficient way to become a better programmer. Honing one’s skill will make your work as a programmer more enjoyable for you and your teammates.

97 Things Every Programmer Should Know

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.

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.

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.

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.

The Clean Coder

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.

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.


It’s a poor workman who blames his tools, but that does not mean one shouldn’t practice and get better at utilizing them.

Practical Vim

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.

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.

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.

User Experience

All applications have a user interface (UI) from the command line to the web application. The user experience (UX) should always be considered and should never be a second-class citizen. No one will want to use the application you’ve built if they can’t figure out how to use it.

The Design of Everyday Things

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.