24 influential books programmers should read

The fast-paced world of programming demands that developers remain up-to-date. In fact, getting ahead of the curve makes a programmer stand out in his professional field. Don’t let yourself fall behind. Innovate so you can offer your company the kind of programming tailored for their needs. Here is a curated list of books that can support any software engineer.

Part 1: Books for Writing Code

Code Craft: The Practice of Writing Excellent Code (Pete Goodliffe)

All programmers know how to write code that works. But only the top coders and programmers can create outstanding code – clean software code that is comprehensible and lasting. Code Craft can help you join their ranks. Move beyond just writing whatever works and write outstanding, award-winning programming. This book teaches the best code presentation style, problem solving techniques, variable naming, error handling, and security. 

Code Craft takes readers beyond their own problems and forces them to look at reality in order to evaluate the best way to move forward. The real world requires a level of skill in teamwork, documentation, communication, and process. The advice given is accessible to all programmers and is based on practical experience. Questions and answers at the end of each chapter allow readers to reinforce the ideas presented to them. 

Solid Code (Developer Best Practices) / (Donis Marshall)

Efficiency is key in any code developing session. Solid Code looks to help programmers create robust, bug-free code. Two Microsoft .NET experts teach valuable lessons with examples based on real world problems that programmers have to face every day. Learn to navigate expenses and teamwork on a regular basis. Improve your designs, prototypes, debugging, and testing through the myriad of tips offered in this programming book. Start to create incredible, world-changing products and code. 

Solid Code teaches you to:

• Use metaprogramming to reduce code complexity, while increasing flexibility and maintainability.
• Treat performance as a feature – and manage it throughout the development life cycle.
• Apply best practices for application scalability.
• Employ preventative security measures to ward off malicious attacks.
• Practice defensive programming to catch bugs before run time.
• Incorporate automated builds, code analysis, and testing into the daily engineering process.
• Implement better source-control management and check-in procedures.
• Establish a quality-driven, milestone-based project rhythm—and improve your results!

The Clean Coder: A Code of Conduct for Professional Programmers (Robert C. Martin)

In The Clean Coder: A Code of Conduct for Professional Programmers, legendary software expert Robert C. Martin advises starting programmers to code with discipline and technique, instead of simply following directions. He crammed each page with enormous value: learn how to estimate, code, refactor, and test with ease. 

But Martin does so much more than just teach rudimentary technique. He also explains the importance of attitude. The Clean Coder focuses on approaching software development with honor, self-respect, and pride. Coders will learn to: 

• Work well and work clean.
• Communicate and estimate faithfully. 
• Face difficult decisions with clarity and honesty.
• Understand that deep knowledge comes with a responsibility to act. 

Readers will  also learn:

• What it means to behave as a true software craftsman.
• How to deal with conflict, tight schedules, and unreasonable managers.
• How to get into the flow of coding, and get past writer’s block.
• How to handle unrelenting pressure and avoid burnout.
• How to combine enduring attitudes with new development paradigms.
• How to manage your time, and avoid blind alleys, marshes, bogs, and swamps.
• How to foster environments where programmers and teams can thrive.
• When to say “No”–and how to say it.
• When to say “Yes”–and what yes really means.

Debugging the Development Process: Practical Strategies for Staying Focused, Hitting Ship Dates, and Building Solid Teams  (Steve Maguire)

Steve Maguire tells the story of how his Microsoft software teams learned how to develop the best software without wasting a dime or a day. Some of his methods could be considered controversial, but they worked for Maguire. He does not hold back about what succeeded and what failed for his team at Microsoft. 

Maguire also details how to take the energy that one programmer might have for his job and channel it to the whole team to guarantee effective, enjoyable work. Other lessons include: 

• Why you might want to kick your star programmer off your team.
• How to avoid corporate snares and overblown corporate processes.
• How to make tiny changes that produce major results.
• How to deliver on schedule without overwork.
• How to pull twice the value out of everything you do.
• How to get your team on a creative roll.
• How to raise the average programmer level at your company. 

Refactoring: Improving the Design of Existing Code (Martin Fowler)

As the application of object-oriented programming has become commonplace, a new problem confronts the software development community. 

The market has been flooded with poorly designed software that have been developed by programmers who are not as experienced. This means the applications are not only inefficient, but overall a waste of money and intellectual resources. Only now developers are realizing how difficult these systems are to work with. Books for software engineering have not addressed this problem as much.

Expert-level programmers have found better ways to solve these problems with complex yet brilliant methods meant to overwrite the performance of the program but uphold its structural integrity. These practices have not been passed down to programmers who follow in their footsteps. This book seeks to change that. 

In Refactoring: Improving the Design of Existing Software, Martin Fowler breaks the silence. The programming book demystifies these master practices and demonstrates how software practitioners can realize the significant benefits of this new process. 

Code Complete: A Practical Handbook of Software Construction, Second Edition (Steve McConnell)

This is widely considered as one of the best practical guides to programming, effectively demonstrating the art and science of software development. The author, Steve McConnell, integrates many  techniques and must-follow principles and turn them into actionable guidance. He pulls them from research, academia, and daily business practice. 

This guidance is suitable for readers with various experience levels, different backgrounds, or different project sizes. Readers can learn to develop the highest quality  clean software code.

These are the main topics in this book:

• Design for minimum complexity and maximum creativity.
• Reap the benefits of collaborative development.
• Apply defensive programming techniques to reduce and flush out errors.
• Exploit opportunities to refactor—or evolve—code, and do it safely.
• Use construction practices that are right-weight for your project.
• Debug problems quickly and effectively.
• Resolve critical construction issues early and correctly.
• Build quality into the beginning, middle, and end of your project.

Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin)

Clean Code is divided into three parts. The first teaches the necessary elements of clean software code: principles, patterns, and practices. 

The second part is a series of case studies detailing the problems and solutions in varying order. Each case study is an exercise in cleaning up code: you will learn to transform a code base that has some problems into one that is sound and efficient. 

The third part is a study in thought: a contemplation of heuristics that were a part of the case studies but require more understanding. This programming book is a must for any developer, software engineer, project manager, team lead, or systems analyst with an interest in producing better code.

Readers will come away from this book understanding:

• How to tell the difference between good and bad code.
• How to write good code and how to transform bad code into good code.
• How to create good names, good functions, good objects, and good classes.
• How to format code for maximum readability.
• How to implement complete error handling without obscuring code logic.
• How to unit test and practice test-driven development.

Code Simplicity: The Fundamentals Of Software (Max Kanat-Alexander)

Good software development results in simple code. But because the value of simple code was not recognized until recently, there is almost no simple code in the digital world. Programmers were encouraged to flood the market with their incomprehensible code. This book seeks to change that. It is a guide meant to help programmers understand what is needed to make good code and details universal principles that can be used for any programming language or project. 

Skill level and experience don’t matter here. You’ll learn how to build and adhere to a plan for software development. You will also become better at managing your time in determining where your programming will go and what path it will take. 

• Learn what differentiates great programmers from poor programmers.
• Understand the ultimate purpose of software and the goals of good software design.
• Determine the value of your decisions now and in the future.
• Examine real-world examples that demonstrate how a system changes over time.
• Learn to allow for the most change in the environment with the least change in the software.
• Make easier changes in the future by keeping your code simpler now.
• Understand why to write tests and what tests to write.

Part 2: Books for Software Engineering

Rapid Development: Taming Wild Software Schedules (Steve McConnell)

Everyone in the technical world is looking to gain control over their development schedules. In RAPID DEVELOPMENT, author Steve McConnell addresses that concern head-on with overall strategies, specific best practices, and valuable tips to  help shrink and control development schedules, as well as keep projects moving. Inside this programming book, you’ll find:

• A rapid-development strategy that can be applied to any project and the best practices to make that strategy work.
• Candid discussions of great and not-so-great rapid-development practices – estimation, prototyping, forced overtime, motivation, teamwork, rapid-development languages, risk management, and many others.
• A list of classic mistakes to avoid for rapid-development projects, including creeping requirements, shortchanged quality, and silver-bullet syndrome.
• Case studies that vividly illustrate what can go wrong, what can go right, and how to tell which direction your project is going.

Rapid Development is a real-world guide to more efficient application development.

Software Project Survival Guide (Developer Best Practices) / (Steve McConnell)

The author of the classics CODE COMPLETE and RAPID DEVELOPMENT has more wisdom to impart to his readers. Steve McConnell draws on solid research and a career’s worth of experience to map the surest path to your goal – what he calls, “one specific approach to software development that works pretty well most of the time for most projects.”

Nineteen succinct chapters teach how to attack and overcome the development process. Readers will learn to plan, design and manage their programming, as well as guarantee quality, testing, and archiving. Simple, elegant code is not out of reach for all programmers in the field.

Agile Software Development: The Cooperative Game (Alistair Cockburn)

Alistair Cockburn begins by updating his powerful model of software development as a “cooperative game of invention and communication.” Among the new ideas, he introduces: 

• harnessing competition without damaging collaboration.
• learning lessons from lean manufacturing. 
• balancing strategies for communication. 

Cockburn also explains how the cooperative game is played in business and on engineering projects, not just software development. 

Next, he systematically illuminates the agile model, shows how it has evolved and answers the questions developers and project managers ask most often, including:

• Where does agile development fit in our organization?
• How do we blend agile ideas with other ideas?
• How do we extend agile ideas more broadly?

Cockburn takes on crucial misconceptions that cause agile projects to fail. You’ll also find a thoughtful discussion of the controversial relationship between agile methods and user experience design.

This edition contains important new contributions on these and other topics:

• Agile and CMMI.
• Introducing agile from the top down.
• Revisiting “custom contracts.”
• Creating change with “stickers.”

Getting Real: The Smarter, Faster, Easier Way to Build a Successful Web Application (Jason Fried and others)

Through the example of 37signals, readers will learn business, design, programming, and marketing principles that apply to their programming. This book packs a powerful punch with simple, straightforward insights, contrarian points of view, and an outside-the-box view of software design. But don’t be fooled: this is not simply a tutorial. It’s a programming book of ideas.

Digital web developers and programmers of all kinds can find the answers they seek in this book. 37signals had wild success in five apps: Basecamp, Campfire, Backpack, Writeboard, and Ta-da Last, as well as their open-source web application framework, Ruby on Rails. All this was built in just two years with no outside funding, no debt, and only seven people (distributed across seven time zones).

This process was successful for over 500,000 people around the world who all sought to use these applications. Access the knowledge needed to gain success in the pages of this programming book.

Perfect Software: And Other Illusions about Testing (Jerry Weinberg)

Perfect Software and Other Illusions About Testing seeks to destroy negative ideas about testing and testers. Jerry Weinberg, the author of The Psychology of Computer Programming, dismisses the terrible notions that surround that step in software development. Testing isn’t a stigma, it’s necessary. 

Be entertained and informed by Weinberg’s expert story-telling while learning about what is possible in the world of software testing. Fallacies and rumors are swept aside and readers learn to steer clear of common pitfalls. 

Meanwhile, test strategy development that works for any project is taught here. 

Topics include:

• Why Not Just Test Everything?
• Information Immunity.
• What Makes a Test Good?
• Major Fallacies About Testing
• Determining Significance.
• Testing Without Machinery.
• and much more.

Coder to Developer: Tools and Strategies for Delivering Your Software (Mike Gunderloy)

Coder to Developer helps you excel at the many non-coding tasks entailed, from start to finish, in just about any successful development project. Furthermore,  it equips you with the mindset and self-assurance required to pull it all together, so that you see every piece of your work as part of a coherent process. 

Inside, you’ll find plenty of technical guidance on such topics as:

• Choosing and using a source code control system.
• Code generation tools–when and why.
• Preventing bugs with unit testing.
• Tracking, fixing, and learning from bugs.
• Application activity logging.
• Streamlining and systematizing the build process.
• Traditional installations and alternative approaches.

To pull all of this together, the author has provided the source code for Download Tracker, a tool for organizing your collection of downloaded code, that’s used for examples throughout this book. The code is provided in various states of completion which allows readers to dig deep into the actual process of building software. But you’ll also develop “softer” skills, in areas such as team management, open-source collaboration, user and developer documentation, and intellectual property protection.

If you want to become someone who can deliver not just good code but also a good product, this programming book is the place to start. This book is essential for building successful software projects. 

Software Estimation: Demystifying the Black Art (Developer Best Practices) / (Steve McConnell)

In his highly anticipated programming book, acclaimed author Steve McConnell unravels the mystery to successful software estimation. Software Estimation distills academic information and real-world experience into a practical guide for working software professionals. 

Instead of arcane treatises and rigid modeling techniques, this guide highlights a proven set of procedures, understandable formulas, and heuristics that individuals and development teams can apply to their projects to help achieve estimation proficiency.

Discover how to:

• Estimate schedule and cost—or estimate the functionality that can be delivered within a given time frame.
• Avoid common software estimation mistakes.
• Learn estimation techniques for you, your team, and your organization.
• Estimate specific project activities – including development, management, and defect correction.
• Apply estimation approaches to any type of project—small or large, agile or traditional.
• Navigate the shark-infested political waters that surround project estimates.

Software Engineering: A Practitioner’s Approach (Roger S. Pressman)

The programming book is organized in five  parts: Process, Modeling, Quality Management, Project Management, and Advanced Topics. The chapter count will remain at 32, unchanged from the sixth edition. However, eight new chapters have been developed and another six chapters have undergone major or moderate revisions. The remaining chapters have undergone minor edits/updates.

Facts and Fallacies of Software Engineering (Agile Software Development) / (Robert L. Glass)

While reading Facts and Fallacies of Software Engineering, you may experience moments of “Oh, yes, I had forgotten that,” alongside some “Is that really true?” 

The author of this book doesn’t shy away from controversy. In fact, each of the facts and fallacies is accompanied by a discussion of whatever controversy envelops it. You may find yourself agreeing with a lot of the facts and fallacies, yet emotionally disturbed by a few of them! Whether you agree or disagree, you will learn why the author has been called “the premier curmudgeon of software practice.”

These facts and fallacies are fundamental to the software building field.

Part 3: Books for Mentality

The Intentional Stance (Daniel C. Dennett)

How are we able to understand and anticipate each other in everyday life, in our daily interactions? Through the use of such concepts as belief, desire, intention, and expectation asserts Daniel Dennett. The author spent twenty years developing this full-scale presentation of a theory of intentionality.   

According to Dennett, humans adopt a stance,a predictive strategy of interpretation that presupposes the rationality of the people – or other entities – we hope to understand and predict.

These principles of radical interpretation have far-reaching implications for the metaphysical and scientific status of the processes referred to by the everyday terms of folk psychology and their corresponding terms in cognitive science. While Dennett’s philosophical stance has been steadfast over the years, his views have grown richer and more refined.  

The Intentional Stance brings together both previously published and original material: four of the book’s ten chapters – (Chapters One, Eight, Nine, and Ten) – appear here for the first time the remaining six were published earlier in the 1980s but were not easily accessible. The older chapters are followed by reflections – essays reconsidering and extending the claims of the earlier work.

These reflections and the new chapters represent the vanguard of Dennett’s thought. They reveal fresh lines of inquiry into fundamental issues in psychology, artificial intelligence, and evolutionary theory, as well as traditional issues in the philosophy of mind. It is one of the most crucial books for software engineering.

The Back of the Napkin: Solving Problems and Selling Ideas with Pictures (Dan Roam)

When Southwest Airlines co-founder Herb Kelleher brainstormed a solution to beat the traditional hub-and-spoke airlines, he grabbed a bar napkin and a pen. He drew three dots to represent Dallas, Houston, and San Antonio and three arrows to show direct flights.  The image made it easy to sell Southwest Airlines to investors and customers. It also solved his problem.

Used properly, a simple drawing on a humble napkin is more powerful than Excel or PowerPoint. It helps crystallize ideas, force people to think outside the box, and communicate ideas in a direct fashion. In this book, Dan Roam argues that everyone is born with a talent for visual thinking, even those who swear they can’t draw.

This book shows readers how to clarify a problem or sell an idea by visually breaking it down. It promotes a simple set of visual tools that take advantage of everyone’s innate ability to look, see, imagine, and show. These tools are supported by twenty years of visual problem solving, combined with the recent discoveries of vision science. 

The Back of the Napkin proves that thinking with pictures can help anyone discover and develop new ideas, solve problems in unexpected ways, and dramatically improve their ability to share their insights. This book will help readers to literally see the world in a new way.

The Timeless Way of Building (Christopher Alexander)

Christopher Alexander believes that the current theory of architecture in our world is bankrupt.

More and more people are aware that something is deeply wrong. But these ideas seem so powerful that critics are uncomfortable, even afraid, to openly say how they feel. Disliking what is happening might make them look foolish.

Now, at last, there is a coherent theory which describes in modern terms an architecture as ancient as human society itself.

The Timeless Way of Building is the introductory volume in the Center for Environmental Structure series. Christopher Alexander presents a new theory of architecture, building, and planning. This theory has at its core that the age-old process by which the people of a society have always pulled the order of their world from their own being.

Alexander writes, “There is one timeless way of building. It is thousands of years old, and the same today as it has always been. The great traditional buildings of the past, the villages and tents, and temples in which man feels at home have always been made by people who were very close to the center of this way. And as you will see, this way will lead anyone who looks for it to buildings which are themselves as ancient in their form as the trees and hills, and as our faces are.”

Hackers and Painters: Big Ideas from the Computer Age (Paul Graham)

“The computer world is like an intellectual Wild West, in which you can shoot anyone you wish with your ideas if you’re willing to risk the consequences. ” –from Hackers & Painters: Big Ideas from the Computer Age, by Paul Graham

We live in the computer age. Our world, our society, is built and perfected by computer programmers and software designers. These  people call themselves hackers. Who are these people, what motivates them, and why should you care?

Consider these facts: Everything around us is digitized.  Typewriters don’t exist. They have been replaced by a computer. Your phone functions like a computer. So has your camera. Your television is a glorified computer. Your car was not only designed on computers but has more processing power in it than a room-sized mainframe did in 1970. Letters, encyclopedias, newspapers, and even your local store are being replaced by digital products. The world that existed fifty years ago looks very different from the world that exists now. 

Hackers & Painters: Big Ideas from the Computer Age gathers historical evidence to draw a meta picture of the phenomenon of digital progress. In an easy-to-read style, Paul Graham explores the “intellectual Wild West.” 

This book teaches programming best practices, including the importance and necessity for order and symmetry in software design, how to become profitable, the separation between heresy and free speech, the history of programming language and its current peak today, the open-source movement, digital design, and internet startups. It ranks highly among books for software engineering. 

The Productive Programmer (Theory in Practice (O’Reilly)) / (Neal Ford)

In a software developer career, a proven method to produce the code in a more efficient manner is key. The Productive Programmer teaches methods that will tweak your current system for developing software. It is simple to read and even simpler to improve your work. 

Master developer Neal Ford discusses how to work smarter, using all of the tools and resources you have to create the best code. He also shows how to stay motivated, get the most out of your tools, and avoid doing the same task over and over again. Become more valuable to your team!

You’ll learn to:

• Write the test before you write clean software code.
• Manage the lifecycle of your tools.
• Build only what you need now, not what you might need later.
• Apply ancient philosophies to software development.
• Question authority, rather than blindly adhere to standards.
• Make hard things easier and impossible things possible through meta-programming.
• Be sure all code within a method is at the same level of abstraction.
• Pick the right editor and assemble the best tools for the job.

The Effective Engineer: How to Leverage Your Efforts In Software Engineering to Make a Disproportionate and Meaningful Impact (Edmond Lau)

Effective engineers have a certain system that they employ in order to get work done in a fast, efficient manner. Wouldn’t it be nice if you had the same system? Make the attempt to avoid trial and error and learn how to be a wanted commodity, not just another employee. 

Edmond Lau illustrates his points with interviews of top engineers at the best tech companies. He tries to get them to answer his question: How do engineers become the best in their field? What tips should every engineer know in order to advance himself. 

These stories and anecdotes were collected from engineering VPs, directors, managers, and experienced leaders at modern software companies. Some of these companies include Google, Facebook, Twitter and Linkedin. Other up and coming companies include Dropbox, Square, Box, Airbnb, and Etsy. A handful of startups, like Reddit, Stripe, Instagram, and Lyft, were also included. 

From their stories, there are some lessons that readers can follow to reach success.

This book teaches readers to

• Prioritize the right projects and tasks to increase your impact.
• Earn more leeway from your peers and managers on your projects.
• Spend less time maintaining and fixing software and more time building and shipping new features.
• Produce more accurate software estimates.
• Validate your ideas cheaply to reduce wasted work.
• Navigate organizational and people-related bottlenecks.
• Find the appropriate level of code reviews, testing, abstraction, and technical debt to balance speed and quality.
• Shorten your debugging workflow to increase your iteration speed.
• Use metrics to quantify your impact and consistently make progress.

The Pragmatic Programmer: From Journeyman to Master (Andrew Hunt)

Learn how to grow and develop your career by adding responsibilities and techniques to your portfolio. If you can write flexible and adaptable code, you can work anywhere. This book is a series of lessons that stand alone and allow you to pick it up from time to time to learn something new. The author uses examples to illustrate his points. You’ll learn the best practices for software development while sharpening your mental tools to use to help you rise in the field.

The Pragmatic Programmer teaches readers to:

• learn how to Fight software rot.
• Avoid the trap of duplicating knowledge.
• Write a flexible, dynamic, and adaptable code.
• Avoid programming by coincidence.
• Bullet-proof your code with contracts, assertions, and exceptions.
• Capture real requirements.
• Test ruthlessly and effectively.
• Delight your users.
• Build teams of pragmatic programmers.
• Make your developments more precise with automation.