5 Books Every Software Engineer Should Read

Today I want to talk about 5 books every software engineer should read. These are not reference or academic material, but fun easy-to-read books full of interesting ideas that are directly applicable to the field of Software Engineering. That being said, some of these books are equally enjoyable and useful for people that are not software engineers.

I made a video about this in my YouTube channel that discusses these books in much more detail. If you like videos more, check that one out, if not, continue reading.

Algorithms to Live By: The Computer Science of Human Decisions

This is one my favorite books. It has 10 or so computer science concepts, but you don’t need any knowledge of computer science or algorithms to be able to understand them. It is really interesting to look into how things are optimized in the world of computer science, but how they have a direct parallel to how we operate in out daily lives.

A fascinating exploration of how computer algorithms can be applied to our everyday lives, helping to solve common decision-making problems and illuminate the workings of the human mind.

All our lives are constrained by limited space and time, limits that give rise to a particular set of problems. What should we do, or leave undone, in a day or a lifetime? How much messiness should we accept? What balance of new activities and familiar favorites is the most fulfilling? These may seem like uniquely human quandaries, but they are not: computers, too, face the same constraints, so computer scientists have been grappling with their version of such problems for decades. And the solutions they've found have much to teach us.

In a dazzlingly interdisciplinary work, acclaimed author Brian Christian and cognitive scientist Tom Griffiths show how the simple, precise algorithms used by computers can also untangle very human questions. They explain how to have better hunches and when to leave things to chance, how to deal with overwhelming choices and how best to connect with others. From finding a spouse to finding a parking spot, from organizing one's inbox to understanding the workings of human memory, Algorithms to Live By transforms the wisdom of computer science into strategies for human living.

Pragmatic Thinking and Learning: Refactor Your Wetware

This is a pretty interesting book. The core idea of this book is that the process software development actually happens in your head. So, he uses concepts from cognitive and neuroscience to improve your approach to development.

Software development happens in your head. Not in an editor, IDE, or design tool. You're well educated on how to work with software and hardware, but what about wetware--our own brains? Learning new skills and new technology is critical to your career, and it's all in your head. In this book by Andy Hunt, you'll learn how our brains are wired, and how to take advantage of your brain's architecture. You'll learn new tricks and tips to learn more, faster, and retain more of what you learn. You need a pragmatic approach to thinking and learning. You need to Refactor Your Wetware. Programmers have to learn constantly; not just the stereotypical new technologies, but also the problem domain of the application, the whims of the user community, the quirks of your teammates, the shifting sands of the industry, and the evolving characteristics of the project itself as it is built. We'll journey together through bits of cognitive and neuroscience, learning and behavioral theory. You'll see some surprising aspects of how our brains work, and how you can take advantage of the system to improve your own learning and thinking skills. In this book you'll learn how to: Use the Dreyfus Model of Skill Acquisition to become more expert Leverage the architecture of the brain to strengthen different thinking modes Avoid common "known bugs" in your mind. Learn more deliberately and more effectively. Manage knowledge more efficiently.

The Productive Programmer

This book is geared towards making you a productive programmer. From setting up your environment to optimizing your development process. The book is divided into two parts: mechanics and practice.

Anyone who develops software for a living needs a proven way to produce it better, faster, and cheaper. The Productive Programmer offers critical timesaving and productivity tools that you can adopt right away, no matter what platform you use. Master developer Neal Ford not only offers advice on the mechanics of productivity--how to work smarter, spurn interruptions, get the most out your computer, and avoid repetition--he also details valuable practices that will help you elude common traps, improve your code, and become more valuable to your team. You'll learn to:

Write the test before you write the code
Manage the lifecycle of your objects fastidiously
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

This isn't theory, but the fruits of Ford's real-world experience as an Application Architect at the global IT consultancy ThoughtWorks. Whether you're a beginner or a pro with years of experience, you'll improve your work and your career with the simple and straightforward principles in The Productive Programmer.

Refactoring: Improving Design of Existing Code (2nd Edition)

This is the book I have used the most. It helps you refactor your code quickly using the best practices in the industry.

This eagerly awaited new edition has been fully updated to reflect crucial changes in the programming landscape. Refactoring, Second Edition, features an updated catalog of refactorings and includes JavaScript code examples, as well as new functional examples that demonstrate refactoring without classes.

Like the original, this edition explains what refactoring is; why you should refactor; how to recognize code that needs refactoring; and how to actually do it successfully, no matter what language you use.

Understand the process and general principles of refactoring
Quickly apply useful refactorings to make a program easier to comprehend and change
Recognize “bad smells” in code that signal opportunities to refactor
Explore the refactorings, each with explanations, motivation, mechanics, and simple examples
Build solid tests for your refactorings
Recognize tradeoffs and obstacles to refactoring

Clean Code: A Handbook of Agile Craftmanship

This one is the most hand-on in terms of helping you build and iterate faster, which code examples.

Even bad code can function. But if code isn’t clean, it can bring a development organization to its knees. Every year, countless hours and significant resources are lost because of poorly written code. But it doesn’t have to be that way.

Noted software expert Robert C. Martin presents a revolutionary paradigm with Clean Code: A Handbook of Agile Software Craftsmanship. Martin has teamed up with his colleagues from Object Mentor to distill their best agile practice of cleaning code “on the fly” into a book that will instill within you the values of a software craftsman and make you a better programmer–but only if you work at it.

What kind of work will you be doing? You’ll be reading code–lots of code. And you will be challenged to think about what’s right about that code, and what’s wrong with it. More importantly, you will be challenged to reassess your professional values and your commitment to your craft.

Clean Code is divided into three parts. The first describes the principles, patterns, and practices of writing clean code. The second part consists of several case studies of increasing complexity. Each case study is an exercise in cleaning up code–of transforming a code base that has some problems into one that is sound and efficient. The third part is the payoff: a single chapter containing a list of heuristics and “smells” gathered while creating the case studies. The result is a knowledge base that describes the way we think when we write, read, and clean 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

This book is a must for any developer, software engineer, project manager, team lead, or systems analyst with an interest in producing better code.