Beautiful Builds cover page
Beautiful Builds

Beautiful Builds

Patterns for Growing Readable, Maintainable Automated Build Processes


A People Approach to Continuous Delivery and Build Automation with Patterns for Busy Engineers.
Beautiful Builds Edit
This book is 50% Complete

Updated

  • $12.00

    Minimum

  • $14.00

    Suggested

Bundles

Notes to a Software Team Leader
Beautiful Builds

Lead & Build

  • $39.00

    Regular Price

  • $30.00

    Suggested

2 Books

Learn more

About the Book

  • Important: This book is still in beta and is only 60% finished. You can purchase it now for a lower price and you'll automatically get the full book when it's finished.
  • You can also find a whole bunch of videos explaining concepts from this book at http://BeautifulBuilds.com

Agility, Continuous Delivery, TDD... All these things need context to exist. Sure, you can teach your developers to write unit tests, but if noone ever runs them, what good are they? 

An automated build pipeline is the context, the heartbeat in which your team and project live. It is the one combining blood vessel that goes through the entire workflow of the code - the only thing that ever matters in the end. From the code's humble beginning as a text file somewhere on a developer's hard drive, down the chain through multiple (oh dear) layers of source control branches, test machines, application environments, demos, customer machines, deploys, installs, rollbacks, acceptance tests, smoke tests and much more. 

Your code has to endure quite a bit to reach its final destination, safely in the hands of the customer. 

But that's not the hard part.

The hard part is making this happen multiple times a day, without wanting to kill yourself in the process. 

Hey, if it was easy, everyone would do it, right?

It's not easy becuase like everything in technology, all problems are really people problems at the root. 

This book takes a people approach to solving some of the most common problems in build automation. We try to look at the root cause of daily obstacles to continuous delivery:

  • The Security team won't let you deploy to a staging machine
  • The QA team won't let you deploy to a test machine
  • When is the best time to start the build process? 
  • How short is short enough for a build step not to be overlooked or ignored by developers? 
  • How can we make developers trust the build more? 
  • How can we get them to actually use it more? 
  • How can we get teams to use each other's depenedencies without breaking their code?

These and more are covered in this book.

The material here is carefully collected from my own personal experience helping to assemble and automate build processes with teams as small as one person, to projects as large as 300 people with a dozen teams across multiple locations. 

Read More

Table of Contents

      • About the Author
  • I Introduction
    • 1. What’s the point of Continuous Delivery?
    • 2. Tests and Builds are Made to be Broken
        • The Blame Game:
        • Lost Productivity:
  • II Separation of Concerns
    • 3. Pattern: Build Script Injection
        • Other Names:
      • 3.1 Problem:
      • 3.2 Solution:
        • Source control side script
        • CI Side Scripts/Actions
      • 3.3 Summary
    • 4. Build Pattern: Fill In the Blanks
      • 4.1 Other names:
      • 4.2 Symptoms:
      • 4.3 Problem:
      • 4.4 Solution:
      • 4.5 Possible Side Effects:
  • III Productivity
    • 5. Pattern: Shipping Skeleton
        • Other Names:
      • 5.1 Problem:
      • 5.2 Forces:
      • 5.3 Solution:
        • Basic Shipping Skeleton Structure:
      • 5.4 Summary
    • 6. Pattern: Pipeline Disintegration
        • Other Names:
      • 6.1 Symptoms:
      • 6.2 Problem:
      • 6.3 Forces:
      • 6.4 Solution:
        • A more explicit example:
    • 7. Accumulative Builds
      • 7.1 Symptoms:
      • 7.2 Problem:
      • 7.3 Forces:
      • 7.4 Solution
        • Example:
    • 8. Build Decomposition: Incremental Feedback Loops
      • 8.1 Other Names:
      • 8.2 Symptoms
      • 8.3 Problem
      • 8.4 Forces
      • 8.5 Solution
    • 9. Pattern: Gated Commit
      • 9.1 Other names:
      • 9.2 Symptoms:
      • 9.3 Problem:
      • 9.4 Forces:
      • 9.5 Solution:
      • 9.6 Examples:
      • 9.7 Side effects:
    • 10. Avoid XML-As-UI
  • IV Maintainability
    • 11. Fishbone Build Structure
        • Other Names:
      • 11.1 Symptoms:
      • 11.2 Problem:
      • 11.3 Forces:
      • 11.4 Solution:
      • 11.5 Example
      • 11.6 Summary
    • 12. Build Pattern: Location Agnostic Script
      • 12.1 Symptoms:
      • 12.2 Problem:
      • 12.3 Solution:
    • 13. Extract Script
      • 13.1 Symptoms:
      • 13.2 Problem:
      • 13.3 Solution
      • 13.4 Example:
      • 13.5 Possible Side Effects
    • 14. Extract Build Configuration Template
      • 14.1 Symptoms:
      • 14.2 Problem:
      • 14.3 Solution
        • Example:
        • Another common example:
        • Base_VersionedBuild
    • 15. Base Parameter
      • 15.1 Symptoms:
      • 15.2 Problem:
      • 15.3 Solution
      • 15.4 Example:
  • V Team Collaboration
    • 16. Dependency Stash
        • Other Names:
      • 16.1 Context
      • 16.2 Symptom:
      • 16.3 Problem:
        • The CI server
        • The Developer of the component
      • 16.4 Forces:
        • In short:
      • 16.5 Solution
        • Example
          • On the developer’s machine
    • 17. Pattern: Version by Snapshots Dependencies
        • Other Names:
      • 17.1 Symptoms:
      • 17.2 Problem:
      • 17.3 Forces:
      • 17.4 Solution:
        • The Dilemma
        • Having it both ways
      • 17.5 Summary
    • 18. Pattern: Tipping Point
        • Other Names:
      • 18.1 Symptoms:
      • 18.2 Problem:
      • 18.3 Forces:
      • 18.4 Solution:
      • 18.5 Summary
    • 19. Pattern: Public API Hook
        • Other Names:
      • 19.1 Symptoms:
      • 19.2 Problem:
      • 19.3 Forces:
      • 19.4 Solution:
      • 19.5 Summary
  • VI Stakeholder Patterns
    • 20. Pattern: Deploy by Proxy
        • Other Names:
      • 20.1 Symptoms:
      • 20.2 Problem:
      • 20.3 Forces:
      • 20.4 Solution:
      • 20.5 Example:
      • 20.6 Summary
    • 21. Pattern: Parallel Fire-hose
        • Other Names:
      • 21.1 Symptoms:
      • 21.2 Problem:
      • 21.3 Forces:
      • 21.4 Solution:
      • 21.5 Example:
        • work flow 1: Fully automated Pipeline
        • work flow 2: Pull Based QA Pipeline
      • 21.6 Summary
  • VII Branching Patterns
  • VIII Scalability Patterns
    • 22. Fan Out Agents
        • Other Names:
      • 22.1 Symptoms:
      • 22.2 Problem:
      • 22.3 Solution:
      • 22.4 Example
    • 23. Split To Parallel
        • Other Names:
      • 23.1 Symptoms:
      • 23.2 Problem:
      • 23.3 Solution:
      • 23.4 Example
      • 23.5 Step 1: Split the tests to runnable parts
      • 23.6 Step 2: Create a parallel test run hierarchy in the CI server
  • IX Trustworthy Builds
    • 24. Build Pattern: Binary Result
        • Other Names:
      • 24.1 Symptoms:
      • 24.2 Problem:
      • 24.3 Solution:
    • 25. Irrelevant Build
      • 25.1 Symptoms:
      • 25.2 Problem:
      • 25.3 Solution:
      • 25.4 Example:
    • 26. Big Ball of Mud Build
        • Other Names:
      • 26.1 Symptoms:
      • 26.2 Problem:
      • 26.3 Forces:
      • 26.4 Solution:
      • 26.5 Summary

Read More

About the Author

About the Publisher

This book is published on Leanpub by Team Agile Publishing


Team Agile Publishing is Roy Osherove's publishing house.

Other books by this author

The Leanpub Unconditional, No Risk, 100% Happiness Guarantee

Within 45 days of purchase you can get a 100% refund on any Leanpub purchase, in two clicks. We process the refunds manually, so they may take a few days to show up.
See full terms