---
product_id: 3696590
title: "Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation (Addison-Wesley Signature Series (Fowler))"
price: "E£ 10159"
currency: EGP
in_stock: true
reviews_count: 8
url: https://www.desertcart.com.eg/products/3696590-continuous-delivery-reliable-software-releases-through-build-test-and-deployment
store_origin: EG
region: Egypt
---

# Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation (Addison-Wesley Signature Series (Fowler))

**Price:** E£ 10159
**Availability:** ✅ In Stock

## Quick Answers

- **What is this?** Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation (Addison-Wesley Signature Series (Fowler))
- **How much does it cost?** E£ 10159 with free shipping
- **Is it available?** Yes, in stock and ready to ship
- **Where can I buy it?** [www.desertcart.com.eg](https://www.desertcart.com.eg/products/3696590-continuous-delivery-reliable-software-releases-through-build-test-and-deployment)

## Best For

- Customers looking for quality international products

## Why This Product

- Free international shipping included
- Worldwide delivery with tracking
- 15-day hassle-free returns

## Description

Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation (Addison-Wesley Signature Series (Fowler)) [Humble, Jez, Farley, David] on desertcart.com. *FREE* shipping on qualifying offers. Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation (Addison-Wesley Signature Series (Fowler))

Review: Delivering value continuously is an achievable reality - Continuous Delivery from Jezz Humble and David Farley is an important contribution to the field of software development. It takes continuous integration to the logical conclusion and covers how to set up a continuous integration system which covers everything from check-in to delivery to production. It doesn't state you have to deliver directly in production, but it will explain how technically it is achievable to do that and what enormous benefits this brings to your organization. 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.
Review: How to deliver software to users at the click of a button - This is one of the most important software books published in years. From the beginning and throughout the book, the authors emphasize the importance in establishing one delivery team consisting of various experts throughout the software lifecycle - developers, DBAs, Systems/Operations, network specialists, testers and so on. The overarching pattern the authors describe is the Deployment Pipeline, which is basically a staged process consisting of all of the steps to go from bare/virtual metal to a working system whenever there is a change to source files. Of course, the only way this can be done is through copious amounts of automation. The other key point the authors make is that this automated delivery system - itself - is versioned with every change. Not just the custom source code, but also the operating system(s), tools, configuration and everything necessary to create a working software system - a crucial aspect of the Deployment Pipeline. To sum up key points from the book in a few bullets: * The purpose of Continuous Delivery is to reduce the cycle time between an idea and usable software * Automate (almost) everything necessary to create usable software * Version complete software systems (not just source code) for every change committed to version control system * Employ a Deployment Pipeline in which the entire system is recreated whenever a change is committed to the version-control system and provide continuous feedback * Identify one delivery team consisting of various delivery experts - build, deploy, provisioning, database, testing, etc. - a concept emphasized in the DevOps movement The authors go into great detail in describing each of these themes. So, if you want the process of delivering software to any target environment - including production - to be a click of a button and something that can be accomplished as often as the business requires, get this book. When you employ the practices in this book, no longer will you need to artificially throttle changes delivered to users for months or even years because of the expense and risk required to deliver software.

## Technical Specifications

| Specification | Value |
|---------------|-------|
| Best Sellers Rank | #145,889 in Books ( See Top 100 in Books ) #22 in Software Design & Engineering #57 in Computer Programming Languages #107 in Software Development (Books) |
| Customer Reviews | 4.6 out of 5 stars 772 Reviews |

## Images

![Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation (Addison-Wesley Signature Series (Fowler)) - Image 1](https://m.media-amazon.com/images/I/71dgKGehIgL.jpg)

## Customer Reviews

### ⭐⭐⭐⭐⭐ Delivering value continuously is an achievable reality
*by B***E on October 19, 2013*

Continuous Delivery from Jezz Humble and David Farley is an important contribution to the field of software development. It takes continuous integration to the logical conclusion and covers how to set up a continuous integration system which covers everything from check-in to delivery to production. It doesn't state you have to deliver directly in production, but it will explain how technically it is achievable to do that and what enormous benefits this brings to your organization. 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.

### ⭐⭐⭐⭐⭐ How to deliver software to users at the click of a button
*by P***L on September 13, 2010*

This is one of the most important software books published in years. From the beginning and throughout the book, the authors emphasize the importance in establishing one delivery team consisting of various experts throughout the software lifecycle - developers, DBAs, Systems/Operations, network specialists, testers and so on. The overarching pattern the authors describe is the Deployment Pipeline, which is basically a staged process consisting of all of the steps to go from bare/virtual metal to a working system whenever there is a change to source files. Of course, the only way this can be done is through copious amounts of automation. The other key point the authors make is that this automated delivery system - itself - is versioned with every change. Not just the custom source code, but also the operating system(s), tools, configuration and everything necessary to create a working software system - a crucial aspect of the Deployment Pipeline. To sum up key points from the book in a few bullets: * The purpose of Continuous Delivery is to reduce the cycle time between an idea and usable software * Automate (almost) everything necessary to create usable software * Version complete software systems (not just source code) for every change committed to version control system * Employ a Deployment Pipeline in which the entire system is recreated whenever a change is committed to the version-control system and provide continuous feedback * Identify one delivery team consisting of various delivery experts - build, deploy, provisioning, database, testing, etc. - a concept emphasized in the DevOps movement The authors go into great detail in describing each of these themes. So, if you want the process of delivering software to any target environment - including production - to be a click of a button and something that can be accomplished as often as the business requires, get this book. When you employ the practices in this book, no longer will you need to artificially throttle changes delivered to users for months or even years because of the expense and risk required to deliver software.

### ⭐⭐⭐⭐ Good Principles to Follow
*by L***Z on August 12, 2023*

This was a good read. The authors teach a good amount of principles to adhere to when creating your CI/CD pipeline(s). As mentioned by others, the book is a bit repetitive and could have been condensed a bit without diminishing the value from what was taught. There were also some parts that I felt were outdated, but the book is over 10 years old so that would explain it. Nonetheless, I recommend picking it up for a read to get some good nuggets of practical knowledge on CI/CD. There are still some principles taught that I believe hold value to this day.

## Frequently Bought Together

- Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation (Addison-Wesley Signature Series (Fowler))
- Accelerate: The Science of Lean Software and DevOps: Building and Scaling High Performing Technology Organizations
- Modern Software Engineering: Doing What Works to Build Better Software Faster

---

## Why Shop on Desertcart?

- 🛒 **Trusted by 1.3+ Million Shoppers** — Serving international shoppers since 2016
- 🌍 **Shop Globally** — Access 737+ million products across 21 categories
- 💰 **No Hidden Fees** — All customs, duties, and taxes included in the price
- 🔄 **15-Day Free Returns** — Hassle-free returns (30 days for PRO members)
- 🔒 **Secure Payments** — Trusted payment options with buyer protection
- ⭐ **TrustPilot Rated 4.5/5** — Based on 8,000+ happy customer reviews

**Shop now:** [https://www.desertcart.com.eg/products/3696590-continuous-delivery-reliable-software-releases-through-build-test-and-deployment](https://www.desertcart.com.eg/products/3696590-continuous-delivery-reliable-software-releases-through-build-test-and-deployment)

---

*Product available on Desertcart Egypt*
*Store origin: EG*
*Last updated: 2026-03-31*