- Series: Addison-Wesley Signature Series (Fowler)
- Hardcover: 512 pages
- Publisher: Addison-Wesley Professional; 1 edition (August 6, 2010)
- Language: English
- ISBN-10: 0321601912
- ISBN-13: 978-0321601919
- Product Dimensions: 7.1 x 1.3 x 9.3 inches
- Shipping Weight: 2.1 pounds (View shipping rates and policies)
- Average Customer Review: 97 customer reviews
- Amazon Best Sellers Rank: #23,580 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation (Addison-Wesley Signature Series (Fowler)) 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
Fulfillment by Amazon (FBA) is a service we offer sellers that lets them store their products in Amazon's fulfillment centers, and we directly pack, ship, and provide customer service for these products. Something we hope you'll especially enjoy: FBA items qualify for FREE Shipping and Amazon Prime.
If you're a seller, Fulfillment by Amazon can help you increase your sales. We invite you to learn more about Fulfillment by Amazon .
"Rebound" by Kwame Alexander
Don't miss best-selling author Kwame Alexander's "Rebound," a new companion novel to his Newbery Award-winner, "The Crossover,"" illustrated with striking graphic novel panels. Pre-order today
Frequently bought together
Customers who bought this item also bought
Customers who viewed this item also viewed
From the Publisher
“If you need to deploy software more frequently, this book is for you. Applying it will help you reduce risk, eliminate tedious work, and increase confidence. I’ll be using the principles and practices here on all my current projects.”
–Kent Beck, Three Rivers Institute
“Whether or not your software development team already understands that continuous integration is every bit as necessary as source code control, this is required reading. This book is unique in tying the whole development and delivery process together, providing a philosophy and principles, not just techniques and tools. The authors make topics from test automation to automated deployment accessible to a wide audience. Everyone on a development team, including programmers, testers, system administrators, DBAs, and managers, needs to read this book.”
–Lisa Crispin, co-author of Agile Testing
“For many organizations Continuous Delivery isn’t just a deployment methodology, it’s critical to doing business. This book shows you how to make Continuous Delivery an effective reality in your environment.”
–James Turnbull, author of Pulling Strings with Puppet
“A clear, precise, well-written book that gives readers an idea of what to expect for the release process. The authors give a step-by-step account of expectations and hurdles for software deployment. This book is a necessity for any software engineer’s library.”
–Leyna Cotran, Institute for Software Research, University of California, Irvine
“Humble and Farley illustrates what makes fast-growing web applications successful. Continuous deployment and delivery has gone from controversial to commonplace and this book covers it excellently. It’s truly the intersection of development and operations on many levels, and these guys nailed it.”
–John Allspaw, VP Technical Operations, Etsy.com and author of
The Art of Capacity Planning and Web Operations
“If you are in the business of building and delivering a software-based service, you would be well served to internalize the concepts that are so clearly explained in Continuous Delivery. But going beyond just the concepts, Humble and Farley provide an excellent playbook for rapidly and reliably delivering change.”
–Damon Edwards, President of DTO Solutions and co-editor of dev2ops.org
“I believe that anyone who deals with software releases would be able to pick up this book, go to any chapter and quickly get valuable information; or read the book from cover to cover and be able to streamline their build and deploy process in a way that makes sense for their organization. In my opinion, this is an essential handbook for building, deploying, testing, and releasing software.”
–Sarah Edrie, Director of Quality Engineering, Harvard Business School
“Continuous Delivery is the logical next step after Continuous Integration for any modern software team. This book takes the admittedly ambitous goal of constantly delivering valuable software to customers, and makes it achievable through a set of clear, effective principles and practices.”
–Rob Sanheim, Principal at Relevance, Inc.
From the Back Cover
Getting software released to users is often a painful, risky, and time-consuming process. This groundbreaking new book sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. Through automation of the build, deployment, and testing process, and improved collaboration between developers, testers, and operations, delivery teams can get changes released in a matter of hours- sometimes even minutes-no matter what the size of a project or the complexity of its code base. Jez Humble and David Farley begin by presenting the foundations of a rapid, reliable, low-risk delivery process. Next, they introduce the "deployment pipeline," an automated process for managing all changes, from check-in to release. Finally, they discuss the "ecosystem" needed to support continuous delivery, from infrastructure, data and configuration management to governance. The authors introduce state-of-the-art techniques, including automated infrastructure management and data migration, and the use of virtualization. For each, they review key issues, identify best practices, and demonstrate how to mitigate risks. Coverage includes - Automating all facets of building, integrating, testing, and deploying software - Implementing deployment pipelines at team and organizational levels - Improving collaboration between developers, testers, and operations - Developing features incrementally on large and distributed teams - Implementing an effective configuration management strategy - Automating acceptance testing, from analysis to implementation - Testing capacity and other non-functional requirements - Implementing continuous deployment and zero-downtime releases - Managing infrastructure, data, components and dependencies - Navigating risk management, compliance, and auditing Whether you're a developer, systems administrator, tester, or manager, this book will help your organization move from idea to release faster than ever-so you can deliver value to your business rapidly and reliably.
Author interviews, book reviews, editors picks, and more. Read it now
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
That said, there are some good gems inside. My favorite parts might be the many real-world stories of how things can go wrong or how applying some of the principles smoothed things out. The detail, diversity and verisimilitude of those anecdotes sets the book apart from many books in the field.
I wish I could say this was a "must have" book, but it's really more of a "must skim" sort of book.
I don't rate this book as just 1 star, as it has some good ideas, but it could have been written in 150 pages (max) rather than 450. Some of the concepts that are repeated until boredom are:
- Don't build the binaries at each stage of the deployment pipeline, create them once an reuse them.
- The capacity testing environment should be as similar as possible to the production environment.
- Script everything!
- Don't let builds that fail unit or acceptance test into production
- Put all the configuration in version control (network, firewall, OS, etc)
I also found the book more directed to manager who don't really know or care about the technology, but want to talk "in techie" language to their engineers. There are too few examples of how to use technology to build a deployment pipeline and most of the talk stays at a very abstract level.
My bottom line, I strongly suggest to read some blog posts and watch some presentations (check infoq) about this subject, it takes less time and it's more enriching than reading this book.
Continuous delivery consists of three parts: 1) Foundation, 2) Deployment Pipeline, and 3) Delivery Ecosystem
The first four chapters cover the fundamentals the rest of the book is based on. The first chapter provides some problems with more traditional approaches and also introduces some principles extracted out of continuous delivery. The next three chapters cover topics that provide the basics of continuous delivery. Someone involved with agile development for a while is probably aware of most of this and it will be a quick read. For new people, these chapter provide a quick introduction to these topics so that you can understand the rest of the book. The chapters are: "configuration management," "continuous integration," and "implementing a testing strategy."
The second part is the core of the book. It explains the continuous delivery pipeline. This pipeline is a series of stages (a series of continuous integration systems) each stage covering higher-level wider-range of testing so that the confidence in the product increases the later the stage in the deployment pipeline passes. The stages the authors recommend in the deployment pipeline are: commit, acceptance, capacity, manual, production. Each of these stages (except for manual) has its own chapter which explains tools and practices that the authors have found useful in that stage of the deployment pipeline. The part also contains an additional 'foundation' chapter about build and deployment scripting.
The last part of the book is one that I myself found most interesting which covers perhaps some 'advanced' topics. The part is called "delivery ecosystem" and the chapters aren't directly related to each other but each chapter covers a common topic related to the deployment pipeline. Chapter 11 talks about managing and automating your infrastructure as part of your build also. It introduces a vast amount of topics related to automation (pupper, chef), virtualization, cloud computing and monitoring. Unfortunately, the book is only able to touch a little upon each of these topics as each of them could easily fill several others books (and they do!). Chapter 12 covers a very frequent problem in testing and test automation related to managing data. It explains several different approaches and then evaluates them and shares the experiences and recommendations of the authors. Managing test data is a common problem and is rarely covered in the amount of detail as this book does. Chapter 13 discusses different scaling options by componentizing the product and what effect this has on the continuous deployment pipeline (basically adding another dimension to the pipeline). Chapter 14 is about version control and can be summarized as "avoid branching" but the authors do a good job explaining that message and why the alternatives are indeed worst. Chapter 15 was a short (and I slightly disliked this chapter) about managing continuous delivery. It felt like the standard "and now... what actions to take"-chapter. It was a bit shallow though.
When the book was published, I read it through rather quickly and liked it but didn't appreciated the depth of the book yet. I re-read it the second time more thoroughly and enjoyed the careful comparisons and explanations of the recommendations of the authors. They shared the experiences they have had very clear. The book is interesting to me as it covers a vast area and thus it is hard to not touch everything shallowly, but they don't, they go in more depth at the points where the authors feel it is appropriate (for example, parts that are controversial or often done differently).
The book isn't perfect though! As some other reviewers pointed out, it is repetitive and should have been thinner. I agree with that. Also, sometimes the book side-tracks in interesting facts that are unlikely to help the reader a lot such as the history of version control. Next, the book contains some very basic things that could have perhaps been left out (or put as appendix), such as an explanation of maven. My last comment is that the book sometimes contradicts itself such as the recommendation to do things "at the beginning of the project" but then later stating that "at the beginning of the project, all these decisions will change". There I still felt the influence of standard 'project' thinking.
With all these drawbacks, I still decided to rate the book five stars because I do think it is an very influential and important book. It tells and *shows* that continuous delivery is not just a perfection state but that it can be achieved today. Not only that, it can be achieved in larger projects, not just small web projects. This is a huge contribution to the industry and I think and hope that the practices of continuous delivery will become standard practices everywhere. Excellent read (except for the repetition) and highly recommended.