Happy New Year, horses.
First post of the year and nothing better than another motivational post. Don’t forget to prepare your year’s resolutions.
What book should I read to become a better developer?
This is the question that constantly comes to my mind.
I think it’s a great question, and it is one that I asked many of my colleagues and mentors as I was becoming a software engineer.
I decided to develop a routine to read one book a month or at least I’m trying. Over the years I’ve created a list that, I believe, should be the must-reads for anyone that wants to be a good developer.
The problem was that many people suggested to me different books on different topics, but no one was able to give me a list that would be the essential books.
So here is my list. The top book that every Software Engineer should read. This is not a sorted list.
The Mythical Man-Month
This book is a classic, and recently revised and corrected. Is one of the most famous books in all of software development literature and is arguably the most famous book on software development management. The amazing thing is how relevant the book still is to software product development, first published in 1975. This book is also known for the famous expressions “There is no silver bullet” and “Creating Understandable Code is Hard but Necessary”.
If you are involved in software, this book is a must-read.
Design Patterns: Elements of Reusable Object-Oriented Software by Erich Gamma
The famous gang of four book.
So much of software engineering is the identification of problems and the creation of their solutions, and this is what the book, Design Patterns, was created to assist. In the book, the authors go over what patterns are, where they might be applicable, and how they can be used to solve design problems. It presents 23 patterns of usable and reusable design patterns aimed at problem-solving and even shows examples in programming languages like C++ and Smalltalk to help guide readers.
Head First Design Patterns
Originally I had recommended Design Patterns: Elements of Reusable Object-Oriented Software. That is a great reference book for all of the design patterns we use in software today. However, since then I have read Head First Design Patterns and I loved it. This covers the most common design patterns that we use today and explains them in a very engaging way that enables you to remember them and the situations that they can be helpful to you. This is a great book for anyone trying to understand the advantage of well-constructed object-oriented software and the book is a pleasure to read. Highly recommend it.
Is about improving the design of existing code. It is the process of changing a software system in such a way that it does not alter the external behavior of the code, yet improves its internal structure. With refactoring, you can even take a bad design and rework it into a good one. This book offers a thorough discussion of the principles of refactoring, including where to spot opportunities for refactoring, and how to set up the required tests. There is also a catalog of more than 40 proven refactorings with details as to when and why to use the refactoring, step-by-step instructions for implementing it, and an example illustrating how it works.
This was one of the first programming books I read. Though the book was written in 1999, the concepts are the basis of how we go about developing a complex system in a practical manner. Programmers are craftspeople trained to use a certain set of tools (editors, object managers, version trackers) to generate a certain kind of product (programs) that will operate in some environment (operating systems on hardware assemblies). Like any other craft, computer programming has spawned a body of wisdom, most of which isn’t taught at universities or in certification classes. Most programmers arrive at the so-called tricks of the trade over time, through independent experimentation. In The Pragmatic Programmer, Andrew Hunt and David Thomas codify many of the truths they’ve discovered during their respective careers as designers of software and writers of code.
Some of the authors’ nuggets of pragmatism are concrete, and the path to their implementation is clear. They advise readers to learn one text editor, for example, and use it for everything. They also recommend the use of version-tracking software for even the smallest projects and promote the merits of learning regular expression syntax and a text-manipulation language. Other (perhaps more valuable) advice is more light-hearted. In the debugging section, it is noted that “if you see hoof prints think of horses, not zebras.” That is, suspect everything, but start looking for problems in the most obvious places. There are recommendations for making estimates of time and expense, and for integrating testing into the development process. The book is highly relevant even in 2022, especially with the new 20th Anniversary Edition. It examines what it means to be a modern developer by exploring topics that range from personal responsibility and career development to architectural techniques.
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 codebase 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.
The Clean Coder: A Code of Conduct for Professional Programmers
Another book by Uncle Bob teaches techniques, disciplines, tools, and practices of true software craftsmanship. “The Clean Coder: A Code of Conduct for Professional Programmers” is packed with practical advice about estimating, coding, refactoring, and testing.
After reading this book, you should be able to deal with conflicts, tight schedules, and unreasonable managers, handle unrelenting pressure and avoid burnout, manage your time, get into the flow of coding, and foster environments where developers and teams can thrive.
You can see this book as similar to Pragmatic Programmer.
Clean Architecture: A Craftsman’s Guide to Software Structure and Design
Clean Architecture zooms out one level to cover composition, service boundaries, and high-level application architecture. Even if you never take on the title of “Software Architect,” this book will give you a lot of insight into how you can design better software that scales.
Applications nowadays are very complex, and they usually consist of several components. This book gives tips about SOLID principles and how to apply them. It also talks about Object-Oriented and Functional programming. What I liked about this book were all the real-life use cases it gave with lots of diagrams to help with the understanding. It will not hurt to read this book, but I believe it is more for experienced and senior developers as it is strongly geared towards architecture. Nevertheless, anyone who is serious about their career will benefit from reading this.
Domain-driven design: Tackling Complexity in the Heart of Software
For some, DDD is the pinnacle of building maintainable and scalable software. To sum it up, DDD says that when designing software, the business rules must be at the center of your design and that the whole company must speak a common language(ubiquitous language) when talking about requirements.
DDD is hard. It requires a lot of technical knowledge and uses some design patterns. You also need a lot of knowledge in architecturing and designing software in general.
I don’t believe that every software should be designed the DDD way, as it might be overkill for simple projects. You can find a lot of reports that show that the majority of the companies that tried to add DDD failed.
Enterprise Integration Patterns
Enterprise Integration Patterns by Gregor Hohpe and Bobby Woolf is a seminal book on Messaging. Every developer working on messaging solutions should read it. Even though it’s more than 10 years old, the content is still relevant. This is because the book focuses on patterns and principles and its technology agnostic. The authors do a good job of describing how you can combine the patterns together and present the trade-offs of different approaches.
Although it’s long (about 700 pages), I found it to be easy to read. When I look at the messaging solutions that we use today, it’s clear that they have been influenced by these patterns. Also, it’s one of those actionable books – reading it opened my eyes to a couple of places where I could apply the patterns. It’s a good way to gain a deeper understanding of integration patterns and structure your knowledge on messaging.
The idea of the book is that enterprise integration problems can be solved using messaging. By using asynchronous messaging as a backbone or “channel”, integration becomes a series of asynchronous messages between applications. These messages can be used to trigger events, track processes or transform data. Nowadays this idea is about Data Streaming.
Patterns of Enterprise Application Architecture
It deals with the practice of enterprise application development. After a short tutorial on how to develop enterprise applications, Martin then gives you over 40 patterns as solutions to common problems while architecting enterprise applications. It also comes with a lot of UML visualizations and code examples written in Java or C#.
After reading the book, you should be able to divide an enterprise application into layers, to know the major approaches of organizing business logic, to use the MVC patterns to organize web applications, and to handle concurrency for data over multiple transactions.
However, the book is aging pretty badly, so modern concepts like REST, cloud, or JSON are not mentioned. It’s still a good read, but be critical while doing so!
Designing Data-Intensive Applications
In the current era of software engineering data is everywhere and data is king. Increasingly it’s not only about designing good applications but also about creating and capturing the data flows from those applications, to get business insights. Designing Data-Intensive Applications provides a sort of mini-encyclopedia of data engineering. It covers broad topics in considerable detail and discusses many of the principles and issues of data-intensive, distributed systems. Given that data is becoming increasingly important, improving your knowledge in that area is useful.
“Kleppman has coherently blended the relevant computer science theory with modern use cases and applications…Design concepts don’t go out-of-date soon, so the book has a very long shelf-life.”
This is one of the best books for people that are interested in Data applications, like Data Streaming and others.
Microservice Architecture: aligning principles, practices, and culture
Microservices can have a positive impact on your enterprise–just ask Amazon and Netflix–but you can fall into many traps if you don’t approach them in the right way. This practical guide covers the entire microservices landscape, including the principles, technologies, and methodologies of this unique, modular style of system building. You’ll learn about the experiences of organizations around the globe that have successfully adopted microservices.
Building Microservices: Designing Fine-Grained Systems
As organizations shift from monolithic applications to smaller, self-contained microservices, distributed systems have become more fine-grained. But developing these new systems brings its host of problems. This expanded second edition takes a holistic view of topics that you need to consider when building, managing, and scaling
Through clear examples and practical advice, author Sam Newman gives everyone from architects and developers to testers and IT operators a firm grounding in the concepts. You’ll dive into the latest solutions for modeling, integrating, testing, deploying, and monitoring your autonomous services. Real-world cases reveal how organizations today manage to get the most out of these architectures.
I add more developer or coder books to my list, but as a good Software Engineer, Process should be something that you need to learn by hard. I should create a list for
TDD, BDD, Scrum, Kanban, Agile, and others.
The data structure is another very important topic and there are two famous books:
Introduction to Algorithms
Introduction to Algorithms is nothing less than an essential guide to algorithms of all kinds. It is very comprehensive and accessible to all kinds of readers, beginners, and professionals alike. It is worded and covers a lot of subject matter. But it also is kind of complex and not so easy to follow.
It covers topics such as data structures, fast algorithms, polynomial-time algorithms for seemingly intractable problems, graph theory, computational geometry, and much more. While it contains some examples in pseudo-code, it still is a very theoretical book in my eyes.
Algorithms 4th Edition
And of course, as this is a motivational post and is the beginning of the year I need to add some titles that I believe will be a good read for 2022.
Data Mesh – Delivering Data-Driven value at scale
And my idea is that Data Mesh and Data Fabric are the same things and they are explained by this picture.
Microservice Patterns: With examples in Java
Reactive Systems in Java: Resilient, Event-Driven Architecture with Quarkus
I could add a couple of Kafka and Java books but this could be another blog post.
I hope this list inspires you to pick up one of these books and learn something new. If you have any book suggestions of your own, reach out in the comments, I’d love to hear them!