This is an excerpt from The Art of Agile Development, Second Edition. Visit the Second Edition home page for additional excerpts and more!
This excerpt is copyright 2007, 2021 by James Shore and Shane Warden. Although you are welcome to share this link, do not distribute or republish the content without James Shore’s express written permission.
- Programmers, Operations
When we’re ready to code, nothing gets in our way.
Imagine you’ve just started working with a new team. One of your new teammates, Pedro, walks you over to a development workstation.
“Since you’re new, we’ll start by deploying a small change,” he says, sitting down next to you. “This machine is brand new, so we’ll have to set it up from scratch. First, clone the repo.” He tells you the command. “Now, run the
Commands start scrolling up the screen. “We use a tool for reproducible builds,” Pedro explains. “It’s detected that you don’t have anything installed, so it’s installing the IDE, development tools, and images needed to develop and run the system locally.”
“This will take a while,” he continues. “After the first run, though, it’s instantaneous. It updates again only when we commit changes to the config. Come on, I’ll show you around the office.”
When you come back, the build is done. “Okay, let me show you the app,” Pedro says. “Type
rundev to start it up.” Once again, information starts scrolling by. “This is all running locally,” Pedro explains proudly. “We used to have a shared test environment, and we were constantly stepping on each other’s toes. Now that’s all in the past. It even knows which services to restart depending on which files you change.”
Pedro walks you through the application. “Now, let’s make a change. Run
watch quick. It will build and test the files we change.”
You follow his instructions and the script starts up, then immediately reports
BUILD OK in green. “Nothing’s changed since we last ran the build,” Pedro explains, “so the script didn’t do anything. Now, let’s make a small change.” He directs you to a test file and has you add a test. When you save the changes, the
watch script runs again and reports a test failure. It takes less than a second.
“We’ve put a lot of work into our build and test speed,” Pedro tells you. He’s clearly proud of it. “It wasn’t easy, but it’s totally worth it. We get feedback on most changes in a second or two. It’s done wonders for our ability to iterate and be productive. I’m not lying when I say this is the best development environment I’ve ever been in.”
“Now let’s finish up this change and deploy.” He shows you the production change needed to get the new test to pass. Once again, when you save, the
watch script runs the tests in about a second. This time, it reports success.
“Okay, we’re ready to deploy,” he says. “This is going into production, but don’t worry. The
deploy script will run the full test suite, and we also have a canary server that checks to see if anything goes wrong. Type
deploy to kick things off.”
You run the script and watch it go through its paces. A few minutes later, it says
INTEGRATION OK, then starts deploying the code. “That’s it!” Pedro beams. “Once the integration succeeds, you can assume the deploy will too. If something goes wrong, we’ll get paged. Welcome to the team!”
It’s been less than an hour, and you’ve already deployed to production. This is zero-friction development: when you’re ready to code, nothing gets in your way.
...to continue reading, buy the book!
In this Section
- Zero Friction
- One-Second Feedback
- Know Your Editor
- Reproducible Builds
- Dependency management
- Local builds
- Five-Minute Integration
- Key Idea: Optimize for Maintenance
- Control Complexity
- Automate Everything
- Automate Incrementally
- Automating Legacy Code
- Alternatives and Experiments