With a title like "Clean Code", you know what you are going to get! In this book, you are presented with guidelines for how to write beautiful expressive code that is easy to maintain. Ugly code is hard to understand, while clean code will be easier to understand and maintain. While the book is focused on Java, I think the tips are useful for almost any language.

Learning to write code that is easy to read for others is paramount in an enterprise. Code is often maintained and revised for years after it was initially written.

When you write code that is easier to read, it will be easier for others to read. As well as yourself the next time you revisit your older code! That way you can work more effective with other people, and we can write code faster and enjoy working with it.

I can recommend Clean Coder as well on what it takes to be a professional programmer (according to the author), but it did not make as much as an impact on me as Clean Code. That being said, I still VERY much recommend reading it! It gives you much insight on what you should know if you want a professional career in software development.

A collection of many design patterns, which are repeatable solutions to commonly occurring problems, to assist you while designing new software. These come in several categories: creational (creating objects), structural (e.g, how objects are accessed and used) and behavioral (e.g, interactions between objects). While some of them are not so relevant anymore, it is still a useful to see how different problems can be solved (e.g, object creation and delegation). Many of the patterns are still found in modern software, and have clearly influenced their design (see introduction for examples). I would say skip chapter one, as it is clearly dated. If you think the entire book is dated and hard to read, I have heard that a lot of people enjoy the more modern Head First Design Patterns book (not read it myself though).

You will recognize patterns in libraries you learn, frameworks you use and so on. More importantly you will know of some solutions to commonly occurring problems in object oriented software development, so you can use the design patterns yourself if you encounter problems that are similar in nature.

Effective/recommended ways of working with the Java programming language. This includes both effective for readability and for performance. In general the book contains many tips and tricks for working with Javas library and many features. It will make you a better Java programmer, and teach you about parts of the Java Virtual Machine (JVM) that you probably did not know about.

If you don't ever use Java (or another JVM language), it won't… But if you do, it will give you value on what GOOD Java code actually is. Should you always use lambdas and streams? (NO!!!). How should serialization be used? This is probably one of the Java books I have had the most use for.

In essence: Thinking differently and learning a new language. In this book you will learn to think in a more functional way, learn to think in different concepts, implement various algorithms and more! One very peculiar highlight is Church Numerals (only a few exercises, but still fun!). Church Numerals is basically treating numbers as functions instead of plain numbers, so they are in a way a method of encoding numbers (and you can indeed convert them to regular numbers).

That being said, do you need to read everything? This book is quite old, isn't it? Is everything still relevant? I would say that most of it is very useful to learn, but you may not use it at your job. I would say read at least the first 4 chapters (up to and including the Meta-Circular Evaluator where you make your own Scheme/Lisp!). A lot of the ideas you learn will help you think differently about future tasks you may have at work.

If you use any higher level (C level or above) language, and especially those with higher-order functions (functions that return functions or take functions as arguments), then the topics in this book will prove very useful! (even better if you use functional languages like Haskell, Clojure, Elm or something else!). In Java you have streams, in which you can directly use much of what you learn in this book. The most important part is learning to think differently, so you know of different ways to solve problems.

The point of developing software is that is some day will be in production (if it is not a library or framework, then it will be part of other software in production). With this book you can learn some things to check for in your software, how to find errors earlier and what to do when errors happen. Topics includes timeouts, firewall issues, antipatterns for security and more. You will also be introduced to some testing strategies like chaos engineering. As well as stories from the author that are interesting and emphasize the importance of the lessons learned.

Going from writing software to getting it in production is an important step. How do you know that your software is easy to maintain? And what do you do if you get problems? I think this book has helped me handle all of these questions better. No projects will be perfect, but you can at least know of some common topics to think about for each project.