book - continuous delivery

Read this book in the fall.. didn't get around to posting till now. cuz life.
Eventually I'll fill this out with more details...but the Table of Contents is a good start.

Part I: Foundations
    Chapter 1. The Problem of Delivering Software
        Introduction
        Some Common Release Antipatterns
        The Power of Automated Deployment
        How Do We Achieve Our Goal?
        What Are the Benefits?
        What a Difference a Byte Makes
        The Cost of Manual Configuration Management
        Running Enterprise Software on a Laptop
        The Release Candidate
        Principles of Software Delivery
        Summary
    Chapter 2. Configuration Management
        Introduction
        Using Version Control
        Check Everything In
        Version Control: The Freedom to Delete
        Managing Dependencies
        Managing Software Configuration
        The Danger of Ultimate Configurability
        Packaging Configuration Information
        Don’t Check Passwords into Source Control or Hard-Code Them in Your Application
        Managing Your Environments
        Applying Configuration Management to Infrastructure
        Summary
    Chapter 3. Continuous Integration
        Introduction
        Implementing Continuous Integration
        Prerequisites for Continuous Integration
        Using Continuous Integration Software
        Predecessors to Continuous Integration
        Essential Practices
        Build Discipline on Distributed Projects
        Suggested Practices
        Enforcing Remote Calls at Build Time
        CheckStyle: The Nagging Is Worth It after All
        Distributed Teams
        Distributed Version Control: When Nothing Else Will Work
        Distributed Version Control Systems
        Summary
    Chapter 4. Implementing a Testing Strategy
        Introduction
        Types of Tests
        Should Acceptance Tests Hit the UI?
        Real-Life Situations and Strategies
        Process
    Summary
Part II: The Deployment Pipeline
    Chapter 5. Anatomy of the Deployment Pipeline
        Introduction
        What Is a Deployment Pipeline?
        Deployment Pipeline Practices
        Why Binaries Should Not Be Environment-Specific
        The Commit Stage
        The Origin of the Term “Deployment Pipeline”
        The Automated Acceptance Test Gate
        Why Unit Tests Aren’t Enough
        Subsequent Test Stages
        Preparing to Release
        Implementing a Deployment Pipeline
        Metrics
        Summary
    Chapter 6. Build and Deployment Scripting
        Introduction
        An Overview of Build Tools
        Principles and Practices of Build and Deployment Scripting
        Operations and Developers Must Collaborate on the Deployment Process
        Project Structure for Applications That Target the JVM
        Managing Build Output
        Deployment Scripting
        Smoke-Testing N-Tier Architectures
        Tips and Tricks
        Summary
    Chapter 7. The Commit Stage
        Introduction
        Commit Stage Principles and Practices
        The Results of the Commit Stage
        Creating Your Own Artifact Repository
        Commit Test Suite Principles and Practices
        Using Stubs to Substitute for Messaging Systems
        Summary
    Chapter 8. Automated Acceptance Testing
        Introduction
        Why Is Automated Acceptance Testing Essential?
        Creating Acceptance Tests
        The Application Driver Layer
        What Is a Domain-Specific Language?
        Using the Window Driver Pattern to Create Maintainable Tests
        Implementing Acceptance Tests
        Using Stubs to Simulate External Systems
        The Acceptance Test Stage
        Recording Acceptance Tests for Debugging
        Who Owns Acceptance Tests?
        Acceptance Testing and the Build Master
        The Aardvark Roll Call
        Acceptance Test Performance
        Speeding up Selenium Tests
        Using Cloud Computing for Acceptance Tests
        Summary
    Chapter 9. Testing Nonfunctional Requirements
        Introduction
        Managing Nonfunctional Requirements
        Programming for Capacity
        Premature Optimization In Action
        Measuring Capacity
        Setting Initial Capacity Thresholds
        The Capacity-Testing Environment
        Capacity Testing on a Cluster of iPods
        The Shortcomings of Scaling Factors
        Automating Capacity Testing
        Adding Capacity Tests to the Deployment Pipeline
        Additional Benefits of a Capacity Test System
        Summary
    Chapter 10. Deploying and Releasing Applications
        Introduction
        Creating a Release Strategy
        Deploying and Promoting Your Application
        Continuous Demos for Product Development
        Rolling Back Deployments and Zero-Downtime Releases
        Canary Releasing for Point-of-Sale Systems
        Emergency Fixes
        Continuous Deployment
        Tips and Tricks
        Things Go Better When Development and Operations Are Friends
        Chris Stevenson’s PowerBuilder Bottleneck
        Summary
Part III: The Delivery Ecosystem
    Chapter 11. Managing Infrastructure and Environments
        Introduction
        Understanding the Needs of the Operations Team
        Modeling and Managing Infrastructure
        Managing Server Provisioning and Configuration
        Bad Configuration Management Means Debugging on Release Day
        Test-Driven Changes to Your Environments
        An Automated Approach to Provisioning
        Managing the Configuration of Middleware
        Applying Configuration Management to Recalcitrant Middleware
        Managing Infrastructure Services
        Virtualization
        What Is Virtualization?
        Virtual Networks
        Cloud Computing
        Utility Computing
        DIY Cloud Computing
        Monitoring Infrastructure and Applications
        Splunk
        Summary
    Chapter 12. Managing Data
        Introduction
        Database Scripting
        Incremental Change
        Managing Technical Debt
        Rolling Back Databases and Zero-Downtime Releases
        Managing Test Data
        Data Management and the Deployment Pipeline
        Types of Test Data: An Example
        Summary
    Chapter 13. Managing Components and Dependencies
        Introduction
        Keeping Your Application Releasable
        Replacing an Entire UI Incrementally
        Creating Abstraction Layers
        Dependencies
        Components
        Using Components Doesn’t Imply Using an N-Tier Architecture
        Managing Dependency Graphs
        Apache Gump for Managing Dependencies
        Managing Binaries
        Managing Dependencies with Maven
        Summary
    Chapter 14. Advanced Version Control
        Introduction
        A Brief History of Revision Control
        Branching and Merging
        Version Control Horror Stories: #1
        Distributed Version Control Systems
        Stream-Based Version Control Systems
        ClearCase and the Rebuilding-from-Source Antipattern
        Develop on Mainline
        Version Control Horror Stories: #2
        Branch for Release
        Branch by Feature
        Feature Crews, Kanban, and Branch by Feature
        Branch by Team
        Version Control Horror Stories: #3
        Summary
    Chapter 15. Managing Continuous Delivery
        Introduction
        A Maturity Model for Configuration and Release Management
        Project Lifecycle
        ITIL and Continuous Delivery
        A Risk Management Process
        Common Delivery Problems—Their Symptoms and Causes
        Compliance and Auditing
        Access Control and Enforcing Traceability
        Summary