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.
Table of contents
- The Addison-Wesley Signature Series
- Foreword by Martin Fowler
- Foreword by Paul Julius
- What Is This Book About?
- What Is Continuous Integration?
- Who Should Read This Book?
- Organization of This Book
- What You Will Learn
- What This Book Does Not Cover
- About the Cover
- About the Authors
- About the Contributors
I. A Background on CI: Principles and Practices
- 1. Getting Started
2. Introducing Continuous Integration
- A Day in the Life of CI
- What Is the Value of CI?
- What Prevents Teams from Using CI?
- How Do I Get to “Continuous” Integration?
- When and How Should a Project Implement CI?
- The Evolution of Integration
- How Does CI Complement Other Development Practices?
- How Long Does CI Take to Set Up?
- CI and You
- Commit Code Frequently
- Don’t Commit Broken Code
- Fix Broken Builds Immediately
- Write Automated Developer Tests
- All Tests and Inspections Must Pass
- Run Private Builds
- Avoid Getting Broken Code
3. Reducing Risks Using CI
- Risk: Lack of Deployable Software
- Risk: Late Discovery of Defects
- Risk: Lack of Project Visibility
- Risk: Low-Quality Software
4. Building Software at Every Change
- Automate Builds
- Perform Single Command Builds
- Separate Build Scripts from Your IDE
- Centralize Software Assets
- Create a Consistent Directory Structure
- Fail Builds Fast
- Build for Any Environment
- Build Types and Mechanisms
- Use a Dedicated Integration Build Machine
- Use a CI Server
- Run Manual Integration Builds
- Run Fast Builds
- Stage Builds
How Will This Work for You?
- “My project has seven billion lines of code. How is this going to work for me?”
- “I have a legacy application, so how will this work for me?”
- “What if our source code is in multiple version control repositories?”
- “Our project is separated geographically, so how can we practice CI?”
- “My integration builds are taking too long!”
- “We frequently get build failures. Are we doing something wrong?”
- “We can’t afford a separate build machine.”
- “Our software is too complex; we have to do things manually” or “No—we have all sorts of stuff going on.”
- “Our software uses a version control repository, but we need to support multiple versions using branching. How will this work?”
II. Creating a Full-Featured CI System
5. Continuous Database Integration
- Automate Database Integration
- Use a Local Database Sandbox
- Use a Version Control Repository to Share Database Assets
- Continuous Database Integration
- Give Developers the Capability to Modify the Database
- The Team Focuses Together on Fixing Broken Builds
- Make the DBA Part of the Development Team
- Database Integration and the Integrate Button
- 6. Continuous Testing
7. Continuous Inspection
- What Is the Difference between Inspection and Testing?
- How Often Should You Run Inspectors?
- Code Metrics: A History
- Reduce Code Complexity
- Perform Design Reviews Continuously
- Maintain Organizational Standards with Code Audits
- Reduce Duplicate Code
- Assess Code Coverage
- Evaluate Code Quality Continuously
- 8. Continuous Deployment
- 9. Continuous Feedback
- The Future of CI
- 5. Continuous Database Integration
A. CI Resources
- Continuous Integration Web Sites/Articles
- CI Tools/Product Resources
- Build Scripting Resources
- Version Control Resources
- Database Resources
- Testing Resources
- Automated Inspection Resources
- Deployment Resources
- Feedback Resources
- Documentation Resources
B. Evaluating CI Tools
- Considerations When Evaluating Tools
- Automated Build Tools
- Build Scheduler Tools
- Title: Continuous Integration: Improving Software Quality and Reducing Risk
- Release date: June 2007
- Publisher(s): Addison-Wesley Professional
- ISBN: None
You might also like
Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow, 2nd Edition
Through a series of recent breakthroughs, deep learning has boosted the entire field of machine learning. …
Kafka: The Definitive Guide
Every enterprise application creates data, whether it’s log messages, metrics, user activity, outgoing messages, or something …
Software Architecture Patterns
The success of any application or system depends on the architecture pattern you use. By describing …
Fluent Python, 2nd Edition
Python’s simplicity lets you become productive quickly, but often this means you aren’t using everything it …