Books I read on the subject

Currently only coarse categories, but better than no order at all. A quick reference to the automation related literature on my shelf (and which I actually read for the most part).

Generic automation

The Mythical Man-Month - Brooks
Visionary in describing the limitations of a given team and what you can do with it on the short term. The 20th year Anniversary Edition adds the famous 'No Silver Bullet' prediction.
The design of design - Brooks
Assays on how designing works. Intertwined stories on housing design and computer software. Research on what makes some designs and designers great.
The Inmates Are Running the Asylum - Cooper
Explains why much of the current software is more technical than it should be.
Object-Oriented Modeling and Design - Rumbaugh et al.
The prinicipal book on OMT. It includes a notation and method.
UML Distilled - Fowler
Basics of the most important diagram types. More than enough to help understand most explaining diagrams you might encounter.
The Art of UNIX Programming - Raymond
Description of the UNIX design philosophy. On how to develop UNIX software.
The Pragmatic Programmer - Hunt & Thomas
The philosophy is that you do and see what you do to improve the result. That is the core of sound craftmanship. The software mentioned is a bit dated, but the philosophy is sound.
Pragmatic Thinking & Learning - Hunt
A methodology to become the great craftsperson you want to be. Not all ideas might work for you, but they are certainly worth the try.
Scaling Lean & Agile Development - Larman & Vodde
Agile is said to work only for small teams. This book shows that by integrating techniques from the Lean tradition, it can scale very well.
Agile Estimating and Planning
With Agile methodologies every team member should be able to estimate a certain task. By introducing abstract units like 'Story points' estimating becomes simpler. Strange but true.
Writing Effective Use Cases - Cockburn
A structured book on this very useful way of creating the behavioural part of specifications. One great thing is the grading of use cases, and which to write and which not (too high level or detailed).
Lean Software Development, An Agile Toolkit - Poppendieck & Poppendieck
The first mayor work on this methodology. Superficially all Agile methods look the same, but one striking difference is the main focus; Extreme Programming has the main focus on programming (doh..), Scrum focusses on the development team and Lean targets the whole 'production' line. This book describes the methodology, the next is more on how to implement.
Implementing Lean Software Development, From Concept to Cash - Poppendieck & Poppendieck
How to implement Lean. Compared to XP and Scrum, which are based mainly on the Agile philosophy, Lean has also roots in the TPS methodology from Toyota. This allows it to cover more than just how to develop software. Having read this and the other books, and finding they each have a different focus. So you don't have to choose between Agile methods, you can do them all ;-)

Coding technique

Literate Programming - Knuth
An early attempt to integrate code with documentation. A bit old-school in assuming you need lots of text to explain a relative short bit of code. On the other hand correct in stating that not all code will make its intention clear on itself.
Code Reading - Spinellis
A book on how to read code. Good reading expirience is the basis of understanding code. More educational oriented than Beautiful Code.
Beautiful Code - Oram & Wilson
If you want to train in reading code, read lots of great code. More generic than Code Reading.
Agile Software Development - Martin
The subtitle "Principles, Patterns, and Practices" gives a hint, but doesn't reveal the complete contents. The "Agile" applies on how to organize code, not in the concrete Agile methodologies. The Pattern chapters were very enlightening because sets of patters were compared, making it very obvious which should be applied when. Example code is in C++ and Java.
Clean Code - Martin
On how to read code. As it is not given to most people to write final code in the first attempt, this book learns you to improve it by refactoring.
Code Complete - McConnell
A good book on how to write good code, but a bit to much top-down for my taste. Maybe it is because it isn't Agile.
The Practice of Programming - Kernigan & Pike
How to write classical, lean, UNIX code, so mainly C.
Refactoring - Fowler
Great book for small snippets of good code. And explanation of why the refactored code is better than the original. So it is also a book on how Java code should be written and organized. This makes this book valuable for the novice Java programmer.
Extreme Programming Explained - Beck
Describes the most famous Agile technique defined by setting the important (according to Beck) factors set to eleven (add Spinal Tap reference here).
Agile Software Development with Scrum - Beedle & Schwaber
Even thinner than "Extreme Programming Explained", but packed with information on Scrum. Makes it clear how it works and what the implications are (less and more structured control for stakeholders on feature priorities, maximizing focus on creating the most important features).
Domain-Driven Design - Evans
Makes a convincing case for the development and maintenance of a common language between users and developers to describe the functionality that is to be developed. The more 'common' the language is, the less room for misunderstanding.
Agile software development - Martin
A solid tutorial on Agile Development and Extreme Programming. Lots of clarifying and evolving listings (C++ and Java) and UML diagrams.
Reflections on Management - Humphrey
Assays from the inventor of CMMI which propagates the methods PSP and TSP. It is typically how this essential top-down approach can sometimes get close to the modern Agile methods (which I consider more "bottom-up"). Would all the reporting and checking count as waste (in the Lean sense)?

Programming languages and frameworks

Learning Java 3rd ed. - Niemeyer & Knudsen
Describes Java. The Java 5.0 features get too much attention, limiting the effectiveness as a beginners book.
Pro Spring 2.5 - Machacek et al.
Proper description of Spring features. Includes also integration with other frameworks. A great feature of Spring and also of this book.
Spring Recepies - Mak
Consists of lots of problems with their Spring solutions. Great if you like learing and implementing by example.
Harnessing Hibernate - Elliott et al.
A bit thin for the subject. The examples were too few for the Codeing-by-example technique. And why do all these books assume you code with editor and command line only? Just too thin.
Java Persistence with Hibernate - Bauer & King
Succeeds in getting you install and use Hibernate. And it has the assuring mass of containing more information than I probably even need.
The Java Programming Language, Fourth Edition - Arnold et al.
Not useful to learn Java from scratch, but good for the details you didn't get just right yet.
Effective Java - Bloch
Very good explanations of 78 Java concepts and how to use them. This is the book you want if the SCJP (Sun Certified Java Programmer) book explanation sounds like gibberish.

Pattern related

Pattern-Oriented Software Architecture vol. 1 - Buschmann et al.
A different approach to patterns. And there are at least four more volumes I haven't read.
Design Patterns - Gamma et al.
The base of all patterns. The fact that most code is in Smalltalk or some oldstyle C++ is a good thing, as you should implement what you need, not what the example shows you.
Patterns of Enterprise Application Architecture - Fowler
Patterns for the architecture level. Not wwhat you need every day, but interesting anyhow.
Refactoring to Patterns - Kerievsky
Patterns and refactoring always were meant to be combined, but this book makes it explicit. More important, it helps you refactor your code from one pattern to another more suitable one. By clarifying the boundaries between the patterns, their application becomes more clear.
Emergent Design - Bain
Agile from a slightly different perspective; much attention on the details that matter. If you understand those and why they are important, the rest is almost trival.
Implementation Patterns - Beck
An catalog of elementary patterns (the other end of the scale as PEAA). A great help if you start writing code in Java. You might have an idea, this helps you converting it to proper code.
Enterprise Integration Patterns - Hophe & Woolf
There are not many books describing patterns for integrating applications, but this is one. It focuses in Messaging the most complex form of inter-application communication. The others are File Transfer, Shared Database and Remote Procedure Invocation. The 65 patterns are illustrated with to the point illustrations and example code for the main messaging frameworks; JMS and .NET.

Testing related

xUnit Test Patterns - Meszaros
Like most pattern catalogs, you recognise them if you solved a similar problem yourself before. Then this book can help you improve your solution.
Test-Driven Development - Beck
How to create good code by writing the tests first. Explained in baby-steps. Slow and careful, as you should write your code.
Fit for Developing Software - Mugridge & Cunningham
A very good desctiption of the Fit framework. A large part of the book is dedicated on how tests should be designed, leaving all implementation details out. This part is for the non-technical tester and customer which are mainly interested in the business logic and how to write tests for it. Only later in the book the Java code on how to implement the software-to-test to Fit interface is explained. The clever bit of Fit is that all mechanics are well hidden, so do not distract from the test itself. So really a customer-oriented test framework.
Agile Testing - Crispin & Gregory
The Agile concept may be simple, the process in the real world is not. Creating usage stories with the customer and converting them to (automatic) tests is described in principal and with lots of anecdotes. Separating tests in four main types (quadrants) and the non-inverted test-pyramid (Cohn) are some of the useful concepts in this book.
Implementing Automated Software Testing - Dustin et al.
Lots of good arguments for the AST (Automated Software Testing). Good in describing tools for the various types of testing, and example procedures on how to implement them. This book is a bit management-oriented, as it skips the actual usage.
Lessons Learned in Software Testing - Caner, Bach & Pettichord
Testing in almost 300 short lessons from the experts in the field. Also the principle book on Context Driven Testing
TMap Next - Koomen, v.d. Aalst, Broekman & Vroon
I read this book in Dutch, all 768 pages, and think it is overrated. It concentrates on test management, and one can make a case for the theory that they complicated it beyond usability so you hire one or more consultants from Sogeti (the company behind the method) to get it implemented for you. The writing style is unpleasant, very generic, and not at all motivating. The method seems to be popular with large corporations and governement.
By the way, it does help you pass the certfication exam.
Perfect Software and other illusions about testing - Weinberg
Almost the complete opposite of the TMap book; short (182 pages), clear, pleasant text and to the point. Grok this gem: Common Mistake: 'Confusing testing with "creating and executing test cases"'. Wonderful.
The author may not be part of the "Context Driven Testing" school of thought, but is conceptually clearly in the neighborhood.
Software Testing, An ISTQB-ISEB Foundation Guide, Second Edition - Hambling (Editor)
Foundations of Software Testing, ISTQB Certification - Graham, v. Veenendaal, Evans, Black
Two books with the same purpose: passing the ISTQB Foundation exam. Both 'Implement' the same* syllabus, but have their own interpretation.
*) not exactly true, one does the 2007 version, the other the 2010 version. But the Syllabus differences are very small.

Latest update: 2015-08-27