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).
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
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
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 ;-)
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
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
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-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
Patterns of Enterprise Application Architecture - Fowler
Patterns for the architecture level. Not wwhat you need every day, but interesting anyhow.
Refactoring to Patterns - Kerievsky
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.
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
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.
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"'.
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