For any software developer who has spent days in “integration hell,” cobbling together myriad software components, Continuous Integration: Improving Software Quality and Reducing Risk illustrates how to transform integration from a necessary evil into an everyday part of the development process. The key, as the authors show, is to integrate regularly and often using continuous integration (CI) practices and techniques.

The authors first examine the concept of CI and its practices from the ground up and then move on to explore other effective processes performed by CI systems, such as database integration, testing, inspection, deployment, and feedback. Through more than forty CI-related practices using application examples in different languages, readers learn that CI leads to more rapid software development, produces deployable software at every step in the development lifecycle, and reduces the time between defect introduction and detection, saving time and lowering costs. With successful implementation of CI, developers reduce risks and repetitive manual processes, and teams receive better project visibility.

The book covers

• How to make integration a “non-event” on your software development projects

• How to reduce the amount of repetitive processes you perform when building your software

• Practices and techniques for using CI effectively with your teams

• Reducing the risks of late defect discovery, low-quality software, lack of visibility, and lack of deployable software

• Assessments of different CI servers and related tools on the market

The book’s companion Web site, www.integratebutton.com, provides updates and code examples.

Amazon.com® Reader Reviews (Ranked by Helpfulness)

Average Amazon.com® Rating:  Based on 18 Ratings

Fine for an introduction; otherwise of little help - 2008-07-07
Reviewer Rating:
If you have not been exposed to continuous build/integration, this book covers the approach along with the advantages and points you to some references.
However, if you already have an understanding of CI or have decided that you need to set up a CI environment, this book doesn't add much: few details, little discussion of fine points, etc. That is, don't buy this book if you want concrete help setting up CI.
There is quite a bit of repetition (how many times does one have to list the advantages of CI, or a dedicated build machine, or whatever?).
I found Ant in Action (Manning) much more useful: both in providing the motivation for CI, explaining fine points, providing examples, and in breadth (even if "Ant in Action" is nominally about a Java build tool).

A good book on automating processes related to software development - 2009-02-15
Reviewer Rating:
Software development is (normally) about automating tasks for other people, allowing clients to be more productive at what they do and allowing them to be more reliable in what they do. Automation reduces risk by reducing scope for manual error, particularly for repetitive and mundane tasks. What software developers have often not been so good at is automating the repetitive tasks that they do themselves to improve their own performance and reliability. Whether this is their own decision or because management don't allocate time or resources to do this automation varies from site to site. The evidence is clear though, even from my own experience, that sites where automation is used properly are far more productive, produce more reliable systems and are more fun places to work. I've worked places where this has been done well, I've also worked places where automation has never even been considered. In those latter cases I've done my best to introduce it, usually in incremental steps, with projects becoming far more efficient and reliable as a result. Just this week, whilst automating the building of existing systems for a client, I identified five projects developed by the client that couldn't be built from what was in version control - that alone is evidence that automation is required and, for this client, long overdue.

"Continuous Integration - Improving Software Quality and Reducing Risk" describes this automation, covering everything from automated compilation through to automated deployment, covering topics such as automated testing, inspection etc along the way. It has a leaning towards Java environments, but also refers to tools for .Net (although it doesn't make explicit whether this means true "managed" .Net projects or whether it also includes unmanaged C++ projects written using Visual Studio .Net. It does seem that the .Net references normally relate to managed code, most likely produced with C#). Note that there is also an associated web-site containing related videos and other resources.

This book covers many of the typical questions that arise when automating build-related processes, including optimising the build, increasing the chances that if the build is going to fail it does so quickly, feedback methods etc. Interestingly, it also covers some team-dynamic/psychology stuff, which are things that we see in practice but you rarely read about.

In terms of intended audience, I would recommend this book to developers, testers and development managers. My own experience shows that developers can introduce these techniques themselves, in parallel with doing their allocated tasks, but things would happen quicker if management understood the benefits and allocated time and resources to put these practices in place at the beginning of projects. So, if you are a development/project manager, please do read this book (or even the similar, but shorter, Pragmatic book on the same subject). If you are a developer, the Pragmatic book is good, but I would really go for this one instead, even though it is longer. There is more information in this one, including an overview of various existing tools.

There are places where a bit more detail would have helped, particularly for environments other than Java and .Net. Some more detail on integrating with different version control systems would have been good too (the emphasis is on SubVersion, but suddenly switching to cvs in places). However, these are minor niggles that could easily be addressed on the related web-site. Of course, if details were included in the book for every common environment the book would get significantly longer, which would deter some people who should read it from doing so. So it probably has the balance about right for most people.

All-in-all, this is a very good book. I just wish I had written it first !

Good introductory overview with a hands-on approach and list of tools - 2010-05-03
Reviewer Rating:
I enjoyed reading this book, learned much from it and can recommend this book as a fast introduction to the practices of Continuous Integration. Having read the book, I would summarize it to be more of a bag of proven practices than a brilliant theoretical approach. The other reviewers have praised the good aspects of this book quite correctly. While reading the book, I kept filling and updating three lists for myself:

1. TODO: practices, ideas and approaches that I will take over. This list grew quite long.

2. blind spots: this book limits its focus to medium-sized Java and C# projects. Several aspects of large projects are not covered at all: C++ (handling of libraries), multi-platform, multi-language, UML-tools and model-based development (Rhapsody), generated code, HW/SW integration with FPGA, DSP and VHDL, integration of 3rd party products, maintaining product lines and their variants, integration of CI with existing quality assurance and documentation processes

3. reject: there is one recommended practice that I quite frankly reject, this is "collective ownership of code"; in medium-sized Java-only projects it may be possible to assign responsibility for the code to each and every developer who is involved. But in large projects (involving the tools Rhapsody, C++, VHDL, SQL) you would ask too much of the developers if you expect them to cover each and every of these tools.

Some reviewers have criticized that there is too much repitition in the chapters. This is true. The chapters were written by different authors and it is obvious that each chapter was written so that it could be presented without the other chapters. As a consequence, the basic priniciples are repeated again and again.

I have seen this book and its basic principles being applied in two very different companies. In one company, middle-management based their decisions on a combination of two sources:
1. this book as a Gospel and 2. SCRUM was their religion. The results were sometimes frightening. Reading this book is no replacement for a lack of craftsmanship and understanding your daily work and its details. Bad decisions can grow out of CI-ideology when applied blindly.

Take this book as a bag of good ideas, not as the only true church. Otherwise people involved might start hating their jobs.

Only one book needed for CI - 2010-03-29
Reviewer Rating:
If you just want to read only one book for CI this is it. The big plus for the book is its platform agnostic nature of it.

Good Book - 2009-05-19
Reviewer Rating:
This is a very cleanly written, easy to jump into book on continuous integration. It's a fast read for those who are looking to get a good introduction into the subject, but doesn't lack on substance.

There are ample examples throughout the book of each topic, as well as suggestions for software product (many open source) that are available to implement the principles of continuous integration.

Browse Similar Topics

Top Level Categories:
Software Engineering

Sub-Categories:
Software Engineering > Design Patterns
Software Engineering > OOP