Continuous Integration: Improving Software Quality and Reducing Risk

Paul M. Duvall

Language: English

Pages: 336

ISBN: 0321336380

Format: PDF / Kindle (mobi) / ePub

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,, provides updates and code examples.


Search Engine Marketing, Inc.: Driving Search Traffic to Your Company’s Website (3rd Edition)

From Business Strategy to Information Technology Roadmap: A Practical Guide for Executives and Board Members

IT Systems Management (2nd Edition)

Developing iOS Applications with Flex 4.5

Managing and Using Information Systems: A Strategic Approach (5th Edition)

01 Informatique, Business & Technologies, n°2128 (3 au 9 mai 2012)













The most important principle to understand is that you should prevent the larger builds from failing, and this means following a process to integrate and verify all changes with your own build capabilities before committing changes to the version control repository. Figure 4-8 demonstrates the steps involved in running a private build before committing changes to the repository. “We can’t afford a separate build machine. ” Hardware is cheap when compared to the amount of time that can be lost when an integration problem occurs.

Close();}catch(Exception e){} throw new FindException("Exception while finding word: " + word + " "+ thr. getMessage(), thr); } } This class has been reasonably tested in a series of componentlevel tests that utilize DbUnit. These tests verify the basic CRUD (create, read, update, and delete) operations. For example, Listing 6-13 shows a test for the find method. Write Tests for Defects LISTING 6-13 145 Sample Sunny Day Test Case public void testFindVerifyDefinition() throws Exception{ final WordDAOImpl dao = new WordDAOImpl(); final IWord wrd = dao.

Run these tests with your automated build and run them often with CI. All tests and inspections must pass Not 90% or 95% of tests, but all tests must pass prior to committing code to the version control repository. Run private builds To prevent integration failures, get changes from other developers by getting the latest changes from the repository and run a full integration build locally, known as a private system build. Avoid getting broken code If the build has failed, you will lose time if you get code from the repository.

In some cases, you may be moving from batch or shell scripts to a build scripting tool such as Ant 5. Fowler, et al. Refactoring: Improving the Design of Existing Code (Reading, MA: Addison-Wesley, 1999). Commit Code Frequently 39 or managing all of the project’s binary dependencies. In other cases, you may have previously used your IDE for “integration” and deployment. Either way, the road map to full CI adoption could be quite a bit longer. CI and You In order for CI to work effectively on a project, developers must change their typical day-to-day software development habits.

This will reduce the DBA bottleneck and empower developers to make necessary changes. The DBA can evaluate the new changes to the repository by reviewing the integration builds or working with the developers if the build breaks. As the adage goes, with this additional authority comes additional responsibility. Changes to the underlying database structure can have far-reaching impacts on the system. The developer who makes changes to the database structure must assume the responsibility for thorough testing before committing these changes.

Download sample


Rated 4.64 of 5 – based on 35 votes