Introduction

Although there are plenty of articles and blog posts on the topics included in the following books, I still find books are a far more effective way to learn for a number of reasons. Firstly it allows me to not look at a screen while reading which is a good thing for my eyes. Secondly there are far less distractions when not reading on the screen of a connected device. Thirdly books go through a far more extensive review and editorial process allowing more errors to be caught.

The Pragmatic Programmer

This book is a must for any developer, it doesn’t cover the details on programming in any particular language. Instead it covers the common traps and pitfalls that developers or development teams could fall into. It explains the basics that developers should know in order to be effective, for example command line interfaces, text editors and manipulation. Professional responsibility is also another key aspect that this book covers this is key, particularly for less experienced developers. This include topics such as:

  • “the boy scout rule”, always leave the code base in a better state than when you find it
  • Knowing that you will never achieve perfection within within a codebase and establishing a feel fro good enough
  • Ownership of the codebase, not you verse the world/the other developers in the team
  • Taking responsibility for both successes and failures

Another key aspect that it covers is the methods and strategies for project architecture and design to allow for easy extension and how to investigate new features and functionality.

Code Complete

This book, again is language agnostic however it does look directly at coding styles and anti-patterns. It covers everything from good naming conventions and comments to formatting and separation of concerns. Although it covers a wide range of topics, my favorite is the chapter on code smells. This points out many different things to look out for both when developing your own code and reviewing other peoples. Code reviews are a great way to get feedback on code you have written, but reviewing other peoples code is also a valuable skill for multiple reasons. Firstly it allows you to understand other areas of the code base that you may have to work on in the future, secondly you are almost always able to learn new approaches and practices from other peoples code and thirdly it allows you to easily teach and mentor peers in new techniques.

Effective Java

Written by one of the core architects of the Java, Joshua Bloch, whose most notable work on the Collections API is used daily by thousands of developers. This is a fantastic book which I always keep within reach when working on Java code. It deals with the best practices for developing in java, including everything from a detailed explanation of the relationship between Equals and Hash code to Exception Handling. Again this book is great for code reviews and is divided into items allowing you to quote item numbers in your peer review. For example: “This constructor could be refactored to use a builder as detailed in Item 2 of Effective Java”. Not only will this book provide details on the best practices for developing in Java, it will also provide better understanding of the core Java libraries and concepts.

Another good resource from Joshua Bloch is the video How to design a good API and why it matters.

Head First Design Patterns

I tried hard to get into the Gang of Four book on design patterns, however I found it a little too dry and a little too hard to apply the examples to every day programming experiences. However the head first design patterns book provides accessible and applicable examples for each of the major patterns that it includes. It contains a good number of patterns which are covered in detail with working examples and often examples of how to refactor to use that particular pattern. I do however feel that now I have some working experience with both this book and working in larger code bases that I should attempt to read the Gang Of Four again.

The Well Grounded Java Developer

This book came out with the advent of Java 7, so starts by covering the new features available in that release. From there it goes on to explain in detail many of the core concepts of the JVM including byte code, class files, class loaders and performance. It also contains details of other languages that are available form the JVM such as groovy and scala. The final section deals with some of the newer approaches to software development such as Test Driven Development and continuous delivery, as well as rapid development with Spring Roo. Although this was a great book when it came out I would love to see an updated version to include Java 8 and Spring Boot.

Functional Programming in Java

This is a great introduction to some of the new Lambda Expressions that are included in Java 8. It starts off with an introduction to the new libraries and syntax that is available in Java 8. It then moves on to go into details of the implementing design patterns using functional programming and how to make use of it in existing projects.

Future Books

My future reading list includes the following so hopefully I will have a new post with these in the future:

  • Gang of Four
  • Java Performance
  • Service Design Patterns
  • Patterns of Enterprise Application Architecture
  • Enterprise Integration Patterns