I have always been interested in learning to continuously develop my skills as a developer further and my learning consists nearly exclusively of reading good books. It is a way to make the job more interesting and the new skills makes it possible to work smarter and more effective. That does not necessarily means faster but more effective in a way that brings to better quality and software that is a lot more cheap to maintain.
My view to the development process and how to create high quality software builds largely on a number of books that have moved to the way I prefer to apply development. They that have read these books should recognise a lot in what I say when I talk about how to run a development project in an effective way and how to achieve software with high quality.
This page contains a list of books I have read and it can be used as inspiration to literature that others also should read or just inspiration to how much knowledge there are available from good books. I always select books carefully and many of these books are very good. Some of them are absolute top class literature for Java developers, the best books that are available.
The books that have moved me
I have read a lot of books about Java development but it is few books that have had such a large impact on my view to development as the books in this list. These are the books that I count as some of the absolutely best literature available for Java developers and I think that some of them should be mandatory reading.
I have been certified as a Sun Certified Java Programmer twice, the last time for Java 6. The certification is notable tough and difficult but carefully reading the really good Sun Certified Programmer for Java 6 Study Guide is enough to clear it and I scored 88% at the test after I have read this book. Whether the goal is to be certified or not do I think this books should be mandatory reading for all Java developers as it makes it possible to create better Java code if you know all the fundamental language constructs that Sun decided was most important to know about.
This book have learnt me about all the basic language constructs such as for example the different ways to create inner classes, all the fundamental collection classes and how to use assertions in an appropriate way, which is something that I have not read about in any other book.
Whereas Sun Certified Programmer for Java 6 Study Guide teach about all the fundamental language constructs does Effective Java teach about how to really use the language and I think it should be mandatory reading for all Java developers. This is still the book that have had largest impact on how I perform Java development and it is still the book that I count as the absolutely best book for Java developers that I have read so far. I have read both the first and the second edition.
The author, Josh Bloch, was earlier a distinguished engineer at Sun and the one that led the design and implementation of numerous Java platform features like the collection classes and the new Java 5 language enhancements. This book have learnt me how to create code with high quality that is more robust and I have learnt such things as how to create a good implementation for the common methods equals, hachCode and compareTo and how to create high quality Javadoc API specification. Until I read this book was exception handling a pain whereas I now when I know that RuntimeExceptions should be used to signal programming errors count it as a useful language construct with which I can create more robust code. I think Java development is exciting and it was a joy to read this book!
Knowledge about the Java language syntax and how it should be used is not enough to understand how to work effectively as a developer. System development is a very complex work that require many skills like how to test our code from user acceptance tests down to the level of unit tests that implements the user requirements with code. The code but also the test code must be created so that is clean, maintainable and easy to understand.
Developers that works as craftsmen works differently to achieve this in that they create tests first, known as test driven development or TDD, iterated with refactoring and they do that both at user acceptance level down to the unit test level.
Practical Unit Testing with JUnit and Mockito is a really good, comprehensive and practical introduction to all this with test driven unit test development iterated with refactoring with a lot of good and wise advices as its main focus. I am one of they that already were convinced about the benefits with this before I read this book but I still learn a lot from it and it brought me a lot to think about how I work myself.
It is so important for our productivity and ability to create high quality code to become good at the craftsmanship where test driven development and refactoring are corner stones so that I think that every Java developer should read this book to get started to it. From there are they then more prepared to begin to learn more about it from more advanced literature.
Whereas Practical Unit Testing with JUnit and Mockito is a good introduction to test driven development and how to create good tests is the book Growing Object-Oriented Software Guided by Tests the book that show how to work practically with test driven development in a real development project with all its complexity. It builds on test driven development that begins at the user acceptance or end to end layer and then continue through all the layers with unit tests at lower level. It shows how test driven development drives the design of the classes throughout all the layers and how test driven development is iterated with refactoring in the TDD cycle. This book makes it easier to understand why the only way to create really good code that not is complicated with a lot of nice to have features is to create it test driven where the test code always is created before the implementation. It is not an easy book but one that everyone should read to fully understand TDD.
The book Refactoring – Improving the Design of Existing Code is more like a catalog with useful patterns instead of an ordinary learning book but it have definitely moved me. Since I read this book have I always been observant to duplication and cluttered code that is difficult to read, understand and maintain, particularly if I have created the code myself of course. I have learnt that code gets cluttered despite how experienced developer you are but that it not is a problem as long as you regularly refactor it when you have learnt how it must be implemented to solve the problem you currently are working with.
I have also learnt that you can you start with a naive solution and iterate contentiously between creating new test cases, implementing the code to satisfy that test cases and then refactoring of the test cases and the code until you have been able to implement a solution that both works and is good and maintainable. This way you don’t need to be paralysed of trying to build the solution in your mind before you start building it. You learn the solution while you are working with it and continuously refactoring helps you keep a good structure for the code despite you not know how the solution will look like in until you are finished.
Since I read this book have I thought that refactoring always should be applied continuously along the development to keep a good structure and high quality for the code. If you don’t refactor the code continuously will it quickly grow out of its structure and increase the costs for the maintenance substantially. Refactoring is because of this not waste of time but instead a way to keep the overall costs for the software development low in the long term. This book have even made me to think it is fun and interesting to work with cluttered code as long as I am allowed to refactor it as much as I want to make it good. Refactoring cluttered code is a really good chance to exercise object oriented principles by improving the code.
A book that I count as one of the best Java development books that I have read is the book Java Concurrency in Practise. It got me to understand how really difficult it can be to implement correct multi threaded code with Java and I feel that I still need to practise it a lot more before I feel safe with it. This is a really good book that I want to repeat again and practise more at some time.
It is clear that the authors really understand the topic to a deep level and they for example explain the new Java concurrency API that came with Java 5 that includes the executors framework that should be used instead of direct use of threads. They also talked about the Java memory model and explained why it is so important to use a profiler when Java code is optimised, which is because it is so difficult to predict the effect of small changes aimed to optimise the code. This is a reason to why premature optimisation should be avoided which is something other books like Effective Java also advise. I think that this book should be mandatory reading for every Java developer that works with multi threaded code, which all of us do, so that all the implications that it brings to the implementation are well understood.
The Pragmatic Programmer was published already in 1999 but I didn’t took me time to read it until the beginning of 2012 despite I had planned to read it for a long time. Since that have it had a large impact on how I think a development project should be run in an effective way. This book contains a lot of wise advices that I now always bear in my mind while I am working with development and I think this book should be mandatory reading for everyone that works in a development project in some way or other.
It have for example learnt me that duplication is evil not only in code but everywhere like in the documentation and the build scripts also because it brings to maintenance that is more difficult and a lot more expensive. I learnt that broken windows should always be fixed as soon as possible. If you not fix small problems in your code, documentation or wherever they are already when you find them will the code begin to degrade. This is much of what I already have learnt from the book Refactoring that says that bad code should be fixed before you create new code. This is a book about true craftsmanship for developers.
During 2013 did I participate within the second remote reading group for the Java developers community at IBM where we read Domain-Driven Design – Tackling Complexity in the Heart of Software and it was a joy to read it. It have already had a large impact on how I think modelling should be iterated with implementation in a way that fits very well with what is called tracer bullet development in the book The Pragmatic Programmer and this book advocates use of Extreme Programming as the most prominent way to execute a development project in an agile way.
This book have learnt me how important it is to keep the connection between the analysis and modelling, that usually is performed of the architects, and the implementation, that is performed of the developers. Otherwise will the implementation diverge from the model which soon becomes useless as it no longer describes how the system actually is implemented. This is caused of the fact that there always show up new requirements and new knowledge along the development that not could be foreseen in the analysis and modelling. This book calls the analysis and modelling together with the customer representatives, called the domain experts in this book, iterated with implementation for knowledge crunching and that is indeed a good way to describe how development could be performed in an effective way that largely builds upon Extreme Programming.
This is not an easy book that is easy to apply immediately in a development project but it brings to so much good understanding for the development process so that I think that it should be read of all developers and architects. It also gives a lot of understanding about foundational object oriented principles like coupling and that is something that never can be taught too much!
Like the book The Pragmatic Programmer is Extreme programming Explained a book I planned to read for a long time and when the book Domain-Driven Design – Tackling Complexity in the Heart of Software said that Extreme Programming … is the most prominent of the agile processes did I decide to read Extreme Programming Explained in parallel with that book.
I have a feeling that I eventually have found where I belongs after I have read this book. I realised that I believe in Extreme programming already while I were reading it. This book describe how to apply agile development in a true way whereas the way scrum usually is applied in development projects more is like waterfall development applied in iterative chunks. That way of doing development, which not deserves to be called agile, lacks things like extensive iterative collaboration together with the customer representatives, more dynamic project planning with iterations that build on experiences from what have been implemented so far instead of static planning with fast deadlines and lack of an early deployable end to end, just to mention some things.
The book Planning Extreme Programming was a good complement to what I already had learnt about Extreme Programming so far in the books mentioned above with a lot of good advices about how to practise it with emphasis on the project management. I have never read a book about project management and teamwork like this one before. It advise about a very pragmatic way to plan a development project that makes it very flexible to change in the requirements and issues that show up. Kent Beck and Martin Fowler also shares a lot of very amusing sarcasm on challenges like for example estimation in this book which just makes it a joy to read and they are indeed also two of the most experienced advocates for the most agile way to run a development project, Extreme Programming.
Extreme Programming is not a well defined development process but instead more like a toolbox to pick from to continuously improve the development and make it more effective with less waste of time. Craftsmanship and high quality development is also cornerstones that are part of it and this is the way I want to work whenever I can.
We don’t work alone as developers but in development projects together with other developers. Effective configuration management is a critical part of this team work and it is important that all the team members know about it. I had already learnt a lot about configuration management before I read this book but when I read it did I realise that there is a lot more in configuration management than I knew about it. This is a heavy book, it took me a long time to read, but good configuration management with build, test and deployment automation is an important part of development that is as truly agile as Extreme Programming where the extreme is to keep the code releasable all the time and release continuously. This is an excellent book that every developer should read to be fully understand what configuration management is about and how to apply it in an effective way.
A selection of other books that I have read
I began to learn Java already in 1998 but the JVMs performed bad at that time, the language contained many bugs and there was not yet that much request for Java skills. I worked only with Java development a few times until about 2003, 2004. Until that time was particularly C but sometimes also C++ the languages I used most.
The first book I read to learn Java, in 1998, was Mastering Java 1.1. At that time was Java still a small language and I tried to learn both Java 1.0 and Java 1.1 and most of their class libraries so that I should be able to apply any of these versions depending on which JVM that was available. But already with Java 1.2 became the class libraries for Java too large to be learnt completely of anyone.
I also tried to certify my Java skills after I had read this book but I were just not yet experienced enough at that time and this book was not good enough to work as preparation for the certification. But the certification was also even more difficult at that time as it also included knowledge about the ugly AWT classes, it had a passing score of 70% instead of the about 50% it were later and the questions gave not any information about how many answers that should be given.
The result is that I failed the certification test two times, the last time with only about one question from the passing score, and I did not try to certify again until 2004.
Bruce Eckel became well known at that time because he published his first edition of Thinking in Java on the web free for anyone to download and I did that too and found that he was very good at teaching the language in a good way. Many said that he must be crazy when he just give away his work like this but the result was instead that he sold a lot more books and I bought it myself and when he published the second edition of Thinking in Java two years later did I immediately buy that book also which I then read until it more or less began to decompose.
At this time did I also spend much time on learning UML and the second edition of UML Distilled by Martin Fowler was a really good introduction to UML. Martin Fowler have been one of my favourite authors since that. I have still only read one more of his books since that, the book Refactoring, but I have also read some what he have written on the web. I for example remember an introduction to dependency injection that he had published on the web before it became as a well known concept as it is today and he explained it very well.
I also read the book Visual Modelling with Rational Rose 2000 and UML and used Rational Rose some times to play with UML. This book was a very good, practical and concentrated introduction to UML modelling with Rational Rose which was the outstanding UML modelling tool at that time.
The Unified Modelling Language User Guide is a book I read and used as a reference book but I think it was unnecessary detailed. All that modelling stereotypes are not necessary and if they really were used would the model probably just only drown in too much details anyway.
In 2004 had I still not performed that many Java development projects but I had read a lot of Java development literature and I had played a lot with Java on my own so I now felt ready to give the certification a new try. I were very hungry for revenge but at the same time a bit scared for that I should fail again.
I was well aware with how difficult the certification test is so I read the Sun Certified Programmer & Developer for Java 2 Study Guide very carefully and that got me to score 88% at the test whereas it now only required 52%. This book gave me a very good preparation for the test and without suitable literature like this is it difficult to clear this certification even with much experience of the language.
Three years later, in 2007, did I read the book Head First EJB: Passing the Sun Certified Business Component Developer Exam when I prepared for the certification that was about the EJB 2.0 specification for Java EE 1.3 and this book helped me score 90% at that test.
I didn’t like the very unconventional format for that book that includes a lot of drawings but as difficult it was to learn the awkward EJB 2.0 specification with its EJB homes and entity beans and awkward transaction management do I still have to say that this was a really good book. However, I am glad for the new EJB 3.0 specification where EJBs and the transaction management now are a lot more clean.
I also read the book Head First Servlets and JSP: Passing the Sun Certified Web Component Developer Exam which prepares for the certification that was about the servlet 2.4 and JSP 2.0 specification. I never gave the certification a try but I learnt how to develop servlets and JSP pages very well with help of this book.
The book Design patterns: elements of reusable object-oriented software is a book that I return to regularly to learn more. It describes the patterns in a somewhat abstract way that can make them difficult to see and understand and with short code examples in C++ and SmallTalk that were the major object oriented languages at that time. But it is a very interesting and important book that is a must in the toolbox for a true craftsman as design patterns contribute so much to good design. See also the book Head First Design Patterns below for an alternative about design patterns.
I really like the Java Persistence API, JPA, which is a lot better and more clean way to access databases compared to the JDBC code with their connections and rowsets that had to be used before. With JPA can the code be kept with a better object oriented structure and I learnt JPA carefully when I read the book Pro JPA 2: Mastering the Java Persistence API. It is a thick book with about 480 pages but were well worth to be read all of them to get a thorough understanding of all the aspects of JPA which has many traps.
I have also read the even more thick book JavaServer Faces: The Complete Reference to learn about Java web development with JavaServer Faces, JSF, which is a very useful way to build a rich user interface to a Java server application. This book explained it very well over its about 750 pages. But I also want to read the next edition that describes JSF 2.0 at some time to repeat it and learn about the new features.
I have read selected parts of the book Cryptography with Java to learn about things like how to implement code that mange certificates and how to implement Abstract Syntax Notation One, ASN1. It is not a book that I have read completely but it was a good reference to pick from when the need arise.
It is the same with the book Mastering Regular Expressions. I have only read selective parts from it. It is a really great book that cover the most of what is worth to know about use of regular expressions but I have not had time to read and practise it completely, at least not yet. It has together with other reference information available on the web already learnt me enough about my use of regex so far but they are so useful so I hope I will have time to deepen my skills about them even further at some time in future.
A more light weight but not simple book is the book Java Puzzlers. One of the authors is Josh Bloch that is more known for his outstanding book Effective Java but in this book do they instead play with the language in many fun and humoristic ways, but also with the goal to give some examples on how terribly tricky Java code can be if it is intentionally applied to be that tricky. I have not read and tried all their puzzlers but it is a book that I like a lot.
I don’t yet feel comfortable with Java web services development, probably because it is so abstracted when it is performed with the development tools but I have learnt all the basics about it from the book Java Web Services Up and Running. Maybe I just need to practise it a bit more to get the hands on I need to feel more comfortable with it.
Maven is the build tool and the configuration management tool that I prefer most. I also like Ant for many situations where I need to perform simple setup like execute some SQL or deploy some external dependencies to a local Maven repository. But for the build do I prefer Maven because of for example its convention over configuration where the most configuration is set of defaults inherited from Maven’s super POM that decrease duplication and because of Maven’s great dependency management just to mention a few things.
I learnt a lot about Maven already from the Maven documentation that is available at the web site for Maven but the book Maven: The Complete Reference deepened my skills about Maven a lot further about such things as for example use of profiles. It gives a really good and extensive introduction to Maven and it is available free for download from Sonatype.
I have read three books authored of Kent Beck so far. His book Implementation patterns did I read the first half of 2012 together with the first reading group for the Java developers community at IBM. After that did I also read his book book Test-Driven Development by Example.
Kent Beck have did very much for craftsmanship and high quality development for Java developers so far and I really love his JUnit framework which I always use when I am doing Java development, but I am not quite comfortable with his way to explain. These books has many good points but I don’t feel that they did add much to the Java development skills I already had. But the book Extreme Programming Explained is different. As described above it have had a very large impact on my view to development!
During 2012 did I also read the book Clean Code: A Handbook of Agile Software Craftsmanship which is yet another book I planned to read for a long time. The title for the book is very appealing for a Java developer that put a lot of focus on high quality development and the book certainly have many good points but there were also several things where I were on the opposite with the author, for example that unchecked exceptions always should be used which is something I strongly deprecate.
I know that this, use of only unchecked exceptions, is a paradigm that have spread a lot over the last years and it can sometimes also be justified when it for example was applied to the Java Persistence API that replace the notable annoying way database access has had to be implemented before that with a lot of cumbersome exception handling. But using only runtime exceptions to application code would be a big mistake that leads to poor exception handling. Handle of real possible runtime problems that not is programming errors should be forced with checked exceptions as they otherwise could crash the application without any chance for the user of the code to react properly in them first.
For robust clean code and agile craftsmanship do I think that the books Effective Java together with The Pragmatic Programmer is a better alternative compared to this book, Clean Code: A Handbook of Agile Software Craftsmanship. When it was on the opposite with Effective Java did I agree with what Effective Java said.
In the end of 2013 and the beginning of 2014 did I read the book Head First Design Patterns in Safari Books Online with the book Design patterns: elements of reusable object-oriented software in parallel as a reference book. The book Head First Design Patterns is basic but I must say that it was a lot better than I expected. Its code examples that are more extensive compared to the original book about patterns and in Java instead of C++ and SmallTalk makes the patterns more concrete and more easy to see and understand. This book did definitely refresh and deepen my understanding of patterns a bit further and it is recommended reading for every Java developer that not have got used to patterns yet as they contribute so much to good design.
How to write good tests that really test something that possibly can break and just not cause us to waste time on things that not are worth to be tested is something that never can be learnt too much. This is what Tomek Kaczanowski advise about in the book Bad Tests, Good Tests and many of his advise are very useful. One thing that I for example will have more in mind from now on is to have in mind that I should try to avoid test implementation details that makes the tests too fragile to code updates and consider to implement my own custom assertions sometimes to make my test code more readable. This book is available for free but I now also consider to buy and read his other book about unit testing. I know there is more I could learn about it.
Refactoring to Patterns is an interesting book about true craftsmanship in that it aims to bridge between refactoring and design patterns. It states that the target for use of refactoring is design patterns and it shows many concrete and good examples on this. I did not feel that I learnt much new design patterns from this book, but I indeed learnt to understand some better. Instead I think the best benefit from this book is what they touched on in its afterwords, to learn the thinking about how to solve design problems with use of good design patterns and refactoring as the algebra to achieve that. The books Refactoring by Martin Fowler and Design patterns: elements of reusable object-oriented software, both mentioned above on this page, are a good complement while reading this book. I feel that this book has clarified the context for that books and that they are where refactoring to patterns can be continued and learnt further. This book is important to read as it increase the understanding of that books.
I am still not comfortable with Java Web Services development so I read the second edition of Java Web Services Up and Running. It is a very good overview to the different APIs there are for implementation of both RESTful Java Web Services and Java Web Services that employs SOAP and it also includes the APIs for implementation of security for Java Web Services. I still think Java Web Services development is tricky as there are so many options and the security on top of that makes it complex. This book can also just only be an overview, indeed a good overview with many code examples, as there are so many options to discuss. But it at least made me aware of what options there are to implementation of web services and it makes it easier to read and understand code that implements web services. Now is it mostly a lot more practise I need. Beside the information about web services does this book also contain a very good and pedagogic introduction to SSL and the Private Key Infrastructure, PKI, and a good overview about the Java EE support in Application Servers. Despite I have read about it several times before was it valuable to read this good material to learn about it again.
Some books I have read about development with C, C++ and other development
I worked as a professional trainer in programming with C a number of times around year 2000 and I were once forced to select a Swedish speaking book as the book for the course and then used the book Vägen till C (The way to C). That is a book that is a very basic learning book instead of a book written of someone that really know about and have a passion for the language. Real programming is complex and the best books are English books.
The books that had most impact on my use of C is The C Programming Language by Brian W. Kernighan and Dennis Ritchie, the creators of the C programming language, and the book C – A Reference Manual by Samuel P. Harbison and Guy L. Steele Jr., which is a really great book that I often used as a reference manual while I were coding or performed a trainer assignment. I learnt a lot about the details from that book and brought it with me every time I were working with C.
Around year 2000 were I involved within some Enterprise Application Integration, EAI, development where I developed distributed communication with C for the BEA Tuxedo System and I read the book The TUXEDO System: A Guide to Constructing Distributed Business Applications to learn more about how to build it.
That book describes the most of what you can do in the Tuxedo system with good information and examples, including queuing, request and response communication and a lot about the most difficult, conversational communication, that I struggled with for a long time once in a project to get it stable and robust against communication errors.
I did not work with C++ development that much before I went over to Java development but Thinking in C++ is the book I used to to learn C++ and it was a really good and extensive introduction. The author, Bruce Eckel, is good at explaining the language in a good way with good examples.
I also spent some time with the third edition and the special edition of The C++ Programming Language by Bjarne Stroustrup, the creator of the C++ programming language. These books are a lot more advanced and difficult to read but also a lot more extensive about the details. I did not read these books completely but I particularly remember that I learnt about good use of name-spaces in C++ from them.
I have never liked Windows GUI programming very much but I spent some time on learning Visual C++ and the MFC library somewhere around 2001. I read some books about it and actually also got certified as a Microsoft Certified Professional which however is something that I not acknowledge to any longer.
A book that I however think was really good about windows programming is the book Win32 System Programming. That was more a book about the type of non GUI programming that I liked and that book explained it very well.
Of the languages I have worked with except for Java is C the language that I spent most time on and liked most and learnt best. But I would not like it if I had to go back to it again now. Java is still the language that have enjoyed me most as a developer and the language that I really like to work with as an object oriented craftsman.