Most “best programming books” lists mix up two different shelves. One teaches you a language, the other makes you a better engineer whatever language you write, and we keep them apart. The 20 picks below are the fundamentals, craft, algorithms, architecture and career books working developers keep for years, and further down there’s a starting book for every major language with a link to our full guide.
Need a quick verdict? Buy The Pragmatic Programmer first. Add Clean Code’s new second edition or A Philosophy of Software Design for writing better code, Grokking Algorithms for algorithms, Designing Data-Intensive Applications for backend work and AI Engineering if you build on top of models. What changed this year is that an assistant can draft most functions for you, so the books worth your money teach the judgment it cannot: how to structure a system, which trade-off to take and why inherited code resists change.
Current as of October 2026.
Our top picks at a glance
Most readers only need one or two of these, so start from what you’re trying to do right now:
- Best overall: The Pragmatic Programmer. The one book that makes almost any programmer better at the job.
- Never programmed before: Python Crash Course. One language learned properly, with three real projects.
- Writing better code: Clean Code, 2nd Edition for rules, A Philosophy of Software Design for design thinking.
- Learning algorithms: Grokking Algorithms. The friendly way in before the heavy references.
- Backend and systems: Designing Data-Intensive Applications. How databases and distributed systems really behave.
- Coding interviews: Beyond Cracking the Coding Interview. The 2025 successor to the classic prep book.
- Building with AI models: AI Engineering. Evaluation, RAG and agents for application developers.
The other 12 fill narrower gaps (changing existing code, architecture, your first job, staff-level work), and every pick below names who should skip it, so you don’t buy a book you will not finish.
The 20 best programming books compared
Levels are a guide rather than a wall, and most readers cross between them within a year or two. These are the books every programmer should read at some point, grouped in the same order as the sections below:
| Book | Best for | Level | Edition |
|---|---|---|---|
| 1. The Pragmatic Programmer | Becoming a better engineer | Any | 2nd, 2019 |
| 2. Code (Petzold) | How computers really work | Beginner | 2nd, 2022 |
| 3. Python Crash Course | First language | Beginner | 3rd, 2023 |
| 4. A Philosophy of Software Design | Managing complexity | Junior to senior | 2nd, 2021 |
| 5. Clean Code | Readable code | Junior to mid | 2nd, 2025 |
| 6. Refactoring | Improving existing code | Mid to senior | 2nd, 2018 |
| 7. Tidy First? | When to clean up code | Mid to senior | 1st, 2023 |
| 8. Code Complete | Construction reference | Junior to senior | 2nd, 2004 |
| 9. Head First Design Patterns | Object-oriented patterns | Junior to mid | 2nd, 2021 |
| 10. Grokking Algorithms | Learning algorithms | Beginner | 2nd, 2024 |
| 11. The Algorithm Design Manual | Practical algorithms | Intermediate | 3rd, 2020 |
| 12. Introduction to Algorithms | Algorithm reference | Advanced | 4th, 2022 |
| 13. Designing Data-Intensive Applications | Backend and data systems | Intermediate to advanced | 2nd, 2026 |
| 14. Fundamentals of Software Architecture | Architecture decisions | Senior | 2nd, 2025 |
| 15. Software Engineering at Google | Codebases that last | Mid to senior | 1st, 2020 |
| 16. Beyond Cracking the Coding Interview | Interview prep | Junior to senior | 1st, 2025 |
| 17. The Missing README | Your first engineering job | Beginner | 1st, 2021 |
| 18. The Staff Engineer’s Path | Staff and principal roles | Senior | 1st, 2022 |
| 19. The Mythical Man-Month | Why projects slip | Any | Anniversary, 1995 |
| 20. AI Engineering | Apps on foundation models | Intermediate | 1st, 2025 |
How we picked these books
A best-books list is worthless if it just ranks famous names, so we weighed every title on the same four tests:
- It teaches judgment, not syntax: the value an AI assistant can’t replace is knowing what to build and why, so craft, design and systems books score highest.
- It ages well: a craft or algorithms book should still be right in five years, and where a pick shows its age (Code Complete, The Mythical Man-Month) we say so.
- The current edition is buyable: we link the newest edition you can actually order, which is why Clean Code and DDIA now point at their second editions.
- Working engineers rate it: reputation among practitioners counts, and Amazon sales rank is a tiebreaker, not the ranking.
Editions, page counts, publication dates and stock come from Amazon’s product data, pulled in October 2026, and the cover images are publisher cover art. We dropped two classics this round because new copies were scarce and the buy box showed a used copy: Working Effectively with Legacy Code and Computer Systems: A Programmer’s Perspective. Both are still worth reading if you find a new copy, but we’d rather not send you to a listing that may not ship.
1. The Pragmatic Programmer, 2nd Edition
If you only buy one book from this list, make it this one. It barely mentions a specific language because it’s about the habits that separate someone who writes code from someone who ships and maintains software, and those habits don’t expire when your stack changes. The 2019 anniversary edition added new topics and revised the rest, including property-based testing and concurrency, so the advice reads current rather than nostalgic.
Who it’s for: Any programmer past the first few months who wants to get noticeably better at the job, from keeping code decoupled to estimating work and owning a career. Skip it if you want syntax, exercises or algorithm drills. It sits one level above the code on purpose, and readers who need hand-holding through a language should start with pick 3.
- Authors: David Thomas and Andrew Hunt
- Edition: 2nd (20th Anniversary), 2019, 352 pages, hardcover
- Covers: DRY, orthogonality, tracer bullets, decoupling, testing, estimating
- Price: usually $45 to $55 new; seller and stock vary, so compare offers
2. Code: The Hidden Language of Computer Hardware and Software, 2nd Edition
Petzold starts with flashlights and Morse code and, one small step at a time, builds up to logic gates, memory and a working CPU. It is the best book we know for the gap most self-taught developers carry around, because once you’ve seen how a processor fetches and runs an instruction, pointers, encodings and performance stop feeling like magic. The 2022 second edition adds new chapters and an interactive companion website.
Ideal reader: Beginners and self-taught developers who want to understand what the machine is actually doing, and anyone who skipped computer architecture at university. Pass on it if you need something that helps you write code this week. There’s no language to learn here, and the payoff is understanding, not output. Pair it with an operating systems book when you want to go the next layer up.
- Author: Charles Petzold
- Edition: 2nd, 2022, 480 pages, paperback
- Covers: binary, logic gates, adders, memory, the CPU, assembly, how software meets hardware
- Price: usually $33 to $40 new, check the current price on Amazon
3. Python Crash Course, 3rd Edition
This is the first book we’d hand someone who has never programmed. Python keeps the syntax out of your way, and Matthes spends half the book on three real projects (a Pygame arcade game, data visualizations and a Django web app), so you finish with things that run instead of a pile of exercises. No Starch bills it as the world’s best-selling Python book, which matters for a beginner because every error you hit has already been asked about online.
Best for: Complete beginners, career changers and students who want one language learned properly before touching the craft books further down. Look elsewhere if you already write code in another language and just need Python’s idioms. A faster, denser book from our Python book shortlist will suit you better.
- Author: Eric Matthes
- Edition: 3rd, 2023, 552 pages, paperback
- Covers: Python basics, testing, a game, data visualization, a Django web app
- Price: usually $21 to $50 new; discounts come and go, so check the current price
4. A Philosophy of Software Design, 2nd Edition
Ousterhout’s book is under 200 pages and tackles the problem that actually kills codebases: complexity piling up until every change is risky. His argument for deep modules (simple interfaces hiding a lot of work) is the single most useful design idea on this list, and because he pushes back on some of Clean Code’s advice, reading the two side by side teaches you more than either alone. It’s also cheap, so the cost of trying it is low.
Written for: Anyone deciding how to split a system into modules, classes or services, from a mid-level developer to a tech lead reviewing designs. Hold off if you want code samples or a language tutorial. It’s design thinking, distilled, and it assumes you have already written enough code to have felt the pain it describes.
- Author: John Ousterhout
- Edition: 2nd, 2021, 196 pages, paperback
- Covers: complexity, deep vs shallow modules, information hiding, comments as design
- Price: usually $22 to $23 new, check the current price on Amazon
5. Clean Code, 2nd Edition
The most-read book on writing readable code came back in October 2025 as a full rewrite, and it is a different book from the 2008 original. Part I still works through names, comments, functions, classes and testing disciplines, now with examples in Java, JavaScript, Go, Python, C# and more, plus a chapter on programming with AI tools. Parts II to IV then add design (simple design, SOLID, component principles, concurrency), clean architecture and the ethics of craftsmanship, so make sure the listing you buy says second edition.
Aimed at: Junior and mid-level developers who want a concrete rulebook for naming, functions and tests, and teams that want a shared vocabulary for code review. Leave it on the shelf if Martin’s rules already strike you as dogmatic. Even then, the new appendix reprints his debate with John Ousterhout (pick 4) on method length, comments and TDD, which is the fairest way to weigh the two books against each other.
- Author: Robert C. Martin
- Edition: 2nd, October 2025, 672 pages, paperback
- Covers: names, comments, functions, classes, testing disciplines, AI-assisted coding, SOLID and design, clean architecture, craftsmanship
- Price: about $60 at list, check the current price on Amazon
6. Refactoring, 2nd Edition
Most of a programming career is spent changing code that already exists, and Fowler’s catalog is the reference for doing that in small, tested, reversible steps. Each refactoring has a name, a motivation and mechanics you can follow, which is why “extract function” and “replace conditional with polymorphism” became shared vocabulary across the industry. The second edition switched its examples to JavaScript, so it reads naturally to web developers too.
Right for: Developers working in real, messy codebases who want a disciplined, low-risk way to improve them while features keep shipping. Choose another pick if you want greenfield design theory. This book is about transforming code you already have, and it’s a reference you dip into more than a cover-to-cover read.
- Authors: Martin Fowler with Kent Beck
- Edition: 2nd, 2018, 448 pages, hardcover
- Covers: code smells, a catalog of named refactorings, safe steps backed by tests
- Price: usually $45 to $66 new, check the current price on Amazon
7. Tidy First?
Kent Beck’s short 2023 book answers a question Refactoring leaves open: should you clean this code up before changing it, after, or not at all? He breaks tidying into tiny moves you can make in minutes, then spends the second half on the economics behind the decision (coupling, cohesion and the value of keeping options open). At 122 pages it’s a weekend read, and it is the most practical thing on this list for someone who reviews pull requests every day.
Good fit for: Mid-level and senior developers who keep arguing in code review about whether a cleanup belongs in the same change as a feature. Not the right buy if you want depth on a specific technique. It’s deliberately small and opinionated, and readers expecting a successor to Refactoring’s catalog will find it thin.
- Author: Kent Beck
- Edition: 1st, 2023, 122 pages, paperback
- Covers: small tidyings, when to tidy, coupling and cohesion, design as an economic decision
- Price: usually $28 to $40 new, check the current price on Amazon
8. Code Complete, 2nd Edition
McConnell’s 960-page handbook covers software construction in more depth than anything else in print: variable naming, routine design, defensive programming, debugging, code tuning and how to review a colleague’s work. It’s from 2004 and some examples show it, but the reasoning is backed by research findings McConnell cites throughout, so the advice is argued instead of asserted. Most readers use it as a reference they open by chapter rather than reading straight through.
Made for: Developers who want the evidence behind coding practices, and leads building a team’s coding standard who need sources to point at. Skip it if dated examples bother you, or you want something you will finish. A Philosophy of Software Design covers the core design ideas in about a fifth of the pages.
- Author: Steve McConnell
- Edition: 2nd, 2004, 960 pages, paperback
- Covers: design in construction, variables, routines, defensive programming, debugging, tuning
- Price: usually $28 to $60 new, check the current price on Amazon
9. Head First Design Patterns, 2nd Edition
The original Gang of Four book still defines the patterns, but it’s dense, and this is the one people actually finish. Freeman and Robson teach Strategy, Observer, Decorator, Factory, Adapter, State and the rest through pictures, puzzles and repetition, then show where each one earns its place and where it’s overkill. The examples are Java, yet the patterns map directly onto C#, TypeScript and Python classes.
Most useful to: Developers working in object-oriented codebases who keep meeting patterns in code review and want to recognize and apply them with confidence. Pass on it if the playful visual style grates on you, or you mostly write functional or Go-style code where many classic patterns are not needed. The 1994 Gang of Four original is the terse alternative.
- Authors: Eric Freeman and Elisabeth Robson
- Edition: 2nd, 2021, 669 pages, paperback
- Covers: the core object-oriented design patterns and the principles behind them
- Price: usually $31 to $80 new; discounts vary, check the current price on Amazon
10. Grokking Algorithms, 2nd Edition
If dense textbooks made you bounce off algorithms, start here. Bhargava explains binary search, recursion, hash tables, graphs and dynamic programming with hand-drawn illustrations and short Python examples, so the idea clicks before the notation arrives. The 2024 second edition adds new material on trees and other topics, and it remains the friendliest bridge to the heavier books below.
Pitched at: Self-taught developers and beginners who want to understand the core algorithms instead of memorizing them for an interview. Look elsewhere if you need proofs or full coverage for a university course. That’s what picks 11 and 12 are for, and Grokking will feel slow once you’re past the basics.
- Author: Aditya Bhargava
- Edition: 2nd, 2024, 320 pages, paperback
- Covers: big-O, recursion, hash tables, BFS, Dijkstra, greedy and dynamic programming
- Price: usually $40 to $50 new; delivery times vary by seller, so compare offers
11. The Algorithm Design Manual, 3rd Edition
Skiena’s book sits between Grokking and CLRS, and for working engineers it’s often the more useful of the two big references. The first half teaches how to design an algorithm, with “war stories” from real consulting problems, while the second half is a catalog of common problems that tells you what the problem is called, which approaches work and where to find an implementation. That catalog is the reason it lives on so many desks: it helps you recognize the problem you have.
Who it’s for: Engineers who hit graph, scheduling or optimization problems at work, and interview candidates who want more depth than a problem book gives. Hold off if you want a gentle first course. It assumes some mathematical comfort, and the hardcover costs more than most picks here. Stock was limited when we checked, so check the listing before you plan around it.
- Author: Steven S. Skiena
- Edition: 3rd, 2020, 810 pages, hardcover
- Covers: algorithm design techniques, war stories, a catalog of algorithmic problems
- Price: usually $49 to $90 new, check the current price on Amazon
12. Introduction to Algorithms, 4th Edition
Known everywhere as CLRS, this is the definitive algorithms reference: rigorous, complete and backed by correctness proofs for nearly everything in it. You will not read its 1,312 pages straight through, and you shouldn’t try. It’s the book you reach for when you need the authoritative answer on a data structure, a bound or an algorithm’s correctness, which is why it’s on university reading lists and senior engineers’ shelves alike.
Ideal reader: Computer science students and engineers who want depth and proofs, and anyone who wants one desk reference covering essentially the whole field. Leave it on the shelf if you are learning algorithms for the first time. Start with Grokking, move to Skiena, and keep CLRS for when you need the proof. It’s math-heavy and expensive.
- Authors: Cormen, Leiserson, Rivest and Stein
- Edition: 4th, 2022, 1,312 pages, hardcover
- Covers: data structures, sorting, graphs, dynamic programming, NP-completeness, with proofs
- Price: usually $93 to $150 new; seller and stock vary, so compare offers
13. Designing Data-Intensive Applications, 2nd Edition
This is the book that explains how databases, caches, queues and distributed systems actually behave, so you can reason about trade-offs instead of copying an architecture diagram. The second edition arrived in early 2026 (ebook in February, print in March) with Chris Riccomini as co-author, and when we checked in October 2026 it outsold every other pick here on Amazon except AI Engineering. Read it slowly: each chapter on replication, sharding, transactions or consensus changes how you’ll judge the next system design you see.
Best for: Backend, data and platform engineers who make storage and architecture decisions, and anyone preparing for system design interviews. Our system design book guide covers the interview-focused titles that pair with it. Choose another pick if you are a beginner or want copy-paste recipes. It’s conceptual and demanding, and it rewards readers who’ve already run a database in production.
- Authors: Martin Kleppmann and Chris Riccomini
- Edition: 2nd, early 2026 (print March), 670 pages, paperback
- Covers: storage engines, replication, sharding, transactions, consistency, stream processing
- Price: usually $57 to $70 new, check the current price on Amazon
14. Fundamentals of Software Architecture, 2nd Edition
Where DDIA goes deep on data systems, Richards and Ford map the whole job of a software architect: identifying the characteristics a system must have, choosing between architecture styles and recording the trade-off behind each decision. The 2025 second edition updates the styles and examples, and its central claim (everything in architecture is a trade-off) is the habit worth taking away. It is the most direct route from senior developer to someone who owns the design.
Written for: Senior developers moving into architect or tech lead roles, and teams choosing between a monolith, services or an event-driven design. Not the right buy if you want implementation detail. It stays at the level of structure and decisions, so pair it with DDIA for the data side.
- Authors: Mark Richards and Neal Ford
- Edition: 2nd, 2025, 543 pages, paperback
- Covers: architecture characteristics, architecture styles, decisions, the soft skills of the role
- Price: usually $52 to $80 new, check the current price on Amazon
15. Software Engineering at Google
Its framing line, that software engineering is programming integrated over time, explains why it belongs on this list. The book covers what happens once code has to survive for years and be changed by thousands of people: code review, testing at different scales, documentation, large-scale changes, dependency management and build systems. You won’t copy Google’s tooling, but the reasoning behind each practice carries straight to a ten-person team. Google also publishes the full text free at abseil.io, so you can read a few chapters before buying print.
Aimed at: Developers and leads who’ve moved past writing features and now care about how a codebase stays healthy as the team and the years grow. Skip it if your career is just starting or you work alone. Much of it answers problems you’ll only meet in a large engineering organization.
- Curated by: Titus Winters, Tom Manshreck and Hyrum Wright
- Edition: 1st, 2020, 602 pages, paperback
- Covers: culture, code review, testing, documentation, large-scale changes, build systems
- Price: usually $32 to $66 new, check the current price on Amazon
16. Beyond Cracking the Coding Interview
This January 2025 book replaces the 2015 sixth edition of Cracking the Coding Interview as the one to buy for technical interview prep. McDowell wrote it with Mike Mroczka, Nil Mamano and interviewing.io founder Aline Lerner, and it draws on replays and data from more than 100,000 interviews on that platform. It goes past problem drills into getting noticed by recruiters and negotiating the offer, which is where a lot of money gets left on the table.
Right for: Anyone preparing for algorithm-heavy interviews at product companies, from new graduates to experienced engineers who haven’t interviewed in years. Pass on it if you only need fundamentals and already own the sixth edition; the older book still covers data structures well. System design rounds need DDIA or a dedicated system design book on top.
- Authors: Gayle Laakmann McDowell, Mike Mroczka, Aline Lerner and Nil Mamano
- Published: January 2025, 644 pages, paperback
- Covers: problem-solving patterns, coding problems, getting interviews, negotiating offers
- Price: usually $42 to $45 new, check the current price on Amazon
17. The Missing README
University and bootcamps teach you to program, and then your first job asks for a dozen things nobody covered: working in a large existing codebase, writing tests others rely on, reviewing code, going on call and handling an incident. Riccomini and Ryaboy wrote down the onboarding a good senior engineer would give you, which is why it is the book we’d give someone in their first year. It’s short, practical and free of career-guru padding.
Good fit for: New graduates, bootcamp finishers and anyone in their first two years of a software job. Look elsewhere if you have already been through a few years of on-call and code review. Most of it will confirm what you learned the hard way.
- Authors: Chris Riccomini and Dmitriy Ryaboy
- Published: 2021, 288 pages, paperback
- Covers: existing code, testing, code review, delivery, on-call, working with your manager
- Price: usually $27 to $30 new, check the current price on Amazon
18. The Staff Engineer’s Path
Past senior level, the job changes from writing the best code to deciding which problems the organization works on, and Tanya Reilly’s book is the clearest guide to that shift. She splits it into seeing the big picture, executing projects that cross teams and raising the level of the engineers around you. It’s the book to read before a promotion conversation, not after.
Made for: Senior engineers aiming at staff or principal roles, and managers who need to understand what those roles should do. Hold off if you’re still building core technical skills. It assumes you already are the strong engineer on your team.
- Author: Tanya Reilly
- Edition: 1st, 2022, 356 pages, paperback
- Covers: technical strategy, cross-team projects, influence without authority, mentoring
- Price: usually $26 to $46 new, check the current price on Amazon
19. The Mythical Man-Month, Anniversary Edition
Brooks wrote these essays after managing IBM’s OS/360 project in the 1960s, and they still explain why software projects slip: adding people to a late project makes it later, conceptual integrity beats feature count and there is no silver bullet. The 1995 anniversary edition includes the “No Silver Bullet” essay and Brooks’s own look back at what he got right and wrong. Read it once and you’ll recognize its lessons in every planning meeting.
Most useful to: Tech leads, engineering managers and any developer who has watched a deadline slide and wondered why throwing people at it didn’t help. Leave it on the shelf if you want modern practices. The technology references are decades old, and the value is entirely in the ideas about people and projects.
- Author: Frederick P. Brooks, Jr.
- Edition: Anniversary edition, 1995, 336 pages, paperback
- Covers: Brooks’s law, conceptual integrity, the surgical team, No Silver Bullet
- Price: usually $23 to $48 new; seller and stock vary, so compare offers
20. AI Engineering
A programming list for 2026 that ignores AI would be out of date, so the last pick is the book for developers building products on top of foundation models. Chip Huyen covers how to evaluate model output, prompt engineering, retrieval-augmented generation, agents, fine-tuning and inference cost, with the emphasis on evaluation, which is the part most teams get wrong. When we checked in October 2026 it also had the best Amazon sales rank of any pick here, ahead of every classic.
Pitched at: Software engineers adding LLM features to an application, and anyone who wants a grounded view of what building with models actually involves. For more depth, see our LLM engineering books; for using AI assistants to write code, our AI coding books guide is the better fit. Choose another pick if you want to train models from scratch or study the math behind them. It’s about building applications on models other people trained.
- Author: Chip Huyen
- Edition: 1st, January 2025, 532 pages, paperback
- Covers: evaluation, prompt engineering, RAG, agents, fine-tuning, inference optimization
- Price: usually $52 to $80 new, check the current price on Amazon
The best programming book for each language
The books above make you a better engineer in any language. When you want to go deep in one, start with the current top pick below, then open our full guide for that language, which runs from beginner primers to advanced references:
| Language | Start here | Edition | Full guide |
|---|---|---|---|
| Python | Python Crash Course | 3rd, 2023 | best Python books |
| JavaScript | Eloquent JavaScript | 4th, 2024 | books to learn JavaScript |
| Java | Core Java, Volume I | 13th, 2024 (scarce when we checked (October 2026), around $90) | top Java books |
| C# and .NET | C# 14 and .NET 10 | 10th, 2025 | best C# and .NET books |
| Rust | The Rust Programming Language | 3rd, 2026 (Rust 2024 edition) | best Rust books |
| C (C++ readers: see the guide) | The C Programming Language | K&R, 2nd (ANSI C89) | best C and C++ books |
A language book dates much faster than a craft book, so the edition matters more here than anywhere else on the page. The C# pick moves to the C# 14 and .NET 10 edition from November 2025, the Rust title is the 2026 third edition built on the Rust 2024 edition, and K&R covers ANSI C (C89) only, with no C++, so C++ readers should go straight to our C and C++ guide. If your language is not listed, the same rule applies: buy the newest edition from a publisher with a track record, and treat anything two or more editions behind as a warning sign.
How to choose a programming book worth your time
Most bad book purchases come from buying the wrong kind of book for where you are, not from buying a bad book. Run through these before you order:
- Learning a language: buy a language book from the table above first. Craft and design books land better once you can already ship working code.
- Already shipping code: the craft, design and algorithms picks are where the growth is, and one of them read carefully beats five skimmed.
- Picking an edition: language and framework books go stale in two or three years, so buy current. Algorithm and design books age slowly, so an older CLRS or Refactoring is still fine.
- Print or ebook: references you jump around in (CLRS, Skiena, Code Complete) are easier in print, while books you read front to back work fine on a reader.
- Spotting padded titles: popular topics attract thin self-published books that repackage free docs, so prefer an established publisher and an author with a real track record.
Price is the least useful filter here. The difference between two of these books is small next to the cost of starting the wrong one, which is usually a month of evenings, so choose for fit first.
Reading paths by experience level
Ranking 20 books is useful, but the order you read them in matters more than the order we listed them. These four paths cover most readers, and each one is three or four books, not twenty.
You’ve never written a program
Start with Python Crash Course and type every example rather than reading them, because the errors you hit are the actual lesson. Read Code alongside it in the evenings so the machine underneath stops being a black box, then add Grokking Algorithms once loops and functions feel natural. Leave the craft books until you’ve built two or three small things on your own.
You write code for a living
Read The Pragmatic Programmer, then A Philosophy of Software Design and Clean Code back to back so you see two strong opinions argue. Keep Refactoring and Tidy First? close for the daily work of changing code you did not write, and if you’re in your first job, The Missing README answers the questions you’re nervous to ask.
You are preparing for interviews
Work through Beyond Cracking the Coding Interview for structure, use Grokking Algorithms to fill gaps in the fundamentals and reach for Skiena when a problem type keeps beating you. Practice on a problems platform as you go, since the books give you the mental model and the reps build speed. For system design rounds, add DDIA.
You’re heading toward senior, staff or architect
DDIA and Fundamentals of Software Architecture are the core pair, one for how data systems behave and one for how to make and record design decisions. Software Engineering at Google shows how those decisions hold up over years, The Staff Engineer’s Path covers the role itself and The Mythical Man-Month explains why the schedule slipped anyway. If your team is shipping LLM features, AI Engineering belongs on this shelf too.
