56 books like Head First Git

When trying to become a better Java developer, there is so much to learn.

97 Things covers, well 97, of them in a series of brief essays. What’s cool is that the essays were written by different people so you get lots of points of view on what is important. Topics range from language (comments, fat jars) to the ecosystem (benchmarking, frequent releases) to the language-agnostic (definition of done and breaking down problems.)

Note that two of these are mine. The book is thin at just over 200 pieces. And since each “thing” is short, it’s easy to read on the go.

Unless you are writing a greenfield app, you have legacy code around. And even if you are on a greenfield app, you are writing legacy code right now.

This book gives you techniques for working on such a codebase. It is a really good read for learning how to refactor safely so you can work with what you are inheriting. You might notice this book is 20 years old. It’s just as relevant today as when I first read it in 2004. The concepts don’t depend on the exact language syntax.

In fact, some of the examples are in a mix of Java, C#, and C++. I really appreciate the perspective on testing that I got by reading this book.

By contrast to my previous 20-year-old book recommendation, this one is brand new.

When I was learning Java, we used the (now classic) “Gang of Four” book for Patterns. For design patterns, language syntax does matter. Miro covers the Gang of Four patterns and new ones using the same categories – creational, structural, and behavioral.

Miro also adds concurrency and anti-patterns which weren’t in the original GoF. I like that he includes review questions. This is very key info to know and mastering it with a modern book is very useful. Plus Miro includes examples of that pattern in the JDK itself.

In addition to Java, you need to know about the Java ecosystem.

Each chapter covers a type of tool like version control, securing binaries, or mobile. Some chapters cover a variety of tools. I particularly liked the overview of Quarkus and Micronaut. I also liked the emphasis of tools vs a role. The analogies were great such as comparing identify/fix/deploy to an oil spill.

The book is 300 pages and easy to carry around. Despite having four authors, the book is very cohesive and reads well.

I'm a devoted advocate of functional programming and a passionate Haskell enthusiast.

Ironically, there was a time in my life when I was a student and held the belief that functional programming was merely an impractical academic pursuit.

However, I soon had a revelation that the techniques I employed in C++ to mitigate the inherent unsafety of the language actually aligned with the core principles of functional programming: immutability, purity, and composability.

This realization left a profound impression on me, prompting me to delve into learning Haskell. It proved to be a pivotal moment that significantly shaped my entire career trajectory.

As I delved deeper into functional programming, I discovered a significant void in terms of software engineering practices that were prevalent in the realm of object-oriented programming.

Drawing from my experiences in C++ and C#, I noticed numerous gaps in our understanding of how to build robust applications using… show more.

My journey in the world of software development has been arduous and challenging.

One of the common struggles we all face is the overwhelming number of solutions available, making it impossible to fully grasp everything at a deep level.

Just when I thought I had mastered an approach and felt competent in it, a new shiny approach would emerge, demanding my immediate attention. It often felt like a never-ending race to keep up with the ever-evolving field.

This constant pursuit of staying relevant as a software engineer can be frustrating, as it feels like we are always lagging behind the rapidly advancing world. I discovered that knowledge of specific technologies, frameworks, or libraries does not easily transfer across different technology stacks. They are too specific and lack universality. It was then that I turned my focus to more general principles of software engineering.

I realized that there are fundamental engineering… show more.

Many functional programming books concentrate on the detail of functional techniques (things like recursion or higher-order functions), often leaving open the gap between these techniques and their concrete application to solve everyday programming tasks.

This was one of the reasons I wrote my book, and one source of inspiration for me was the work of F# evangelist Scott Wlashin.

For many years, Scott has been showing how he applies functional thinking in his daily practice centered around e-commerce, through blog posts on his popular site and his talks at programming conferences. At popular request, he's organized these ideas into his book Domain Modelling Made Functional.

The examples are practical enough that every business application programmer will be able to relate to them, and his explanation of functional programming techniques and ideas is clear and rigorous. Although Scott encourages the adoption of F# (the functional-first language of the .NET family), these… show more.

This book (an update to Software Tools by the same authors) codifies and instructs the principles by which the Unix / Linux toolset was designed. It emphasizes clear, robust code, and the building of tools, reusable, general purpose software components that can be hooked together to solve many kinds of programming and data management tasks. The lessons it teaches are timeless, and the current generation of programmers would be well served to try and learn them.

The original Software Tools was perhaps the single most influential software book that I ever read. It taught me how to think with the Unix mindset, how to make the best use of what the Unix system (and now Linux) offers, and how to focus on readability and maintainability in my own software.

Robert Glass is one of the foundational leaders of the discipline of software engineering. He’s done it all and seen it all. This book includes 55 facts and 10 fallacies about many aspects of software engineering, grouped into the major categories of management, the life cycle, and quality. Based on my own experience, I can vouch for the validity of all the points Glass makes.

These timeless truths can help you avoid going down an ineffective path, wasting time only to rediscover the same facts on your own. There’s no need to retrace the missteps from the past. Books like this can keep your energies focused where they will provide the most value to your customers.

This book is essential in that it follows a systematic and scientific approach to software development, advocating for clarity in expressing algorithms, providing a rigorous framework for designing and reasoning about programs, and, fundamentally, always focusing on formal methods and mathematical techniques to ensure correctness and efficiency in programming code.

Most importantly, the book doesn’t just show you how to prove programs correct, but also teaches how to arrive from a definition to an efficient and correct solution, so I would recommend this to every developer.