Confirm Download

Simultaneous file downloading works best in FireFox, Chrome, and Safari browsers. Please keep this window open until all downloads are complete. Some customers prefer using file download managers for Chrome or Firefox to better manage large and multiple file downloads.

Cancel Download

Engineering Practices for Continuous Delivery

    • What Problem Are We Trying to Solve?  (Free)

      Continuous Delivery describes a set of engineering practices for effective software delivery. This segment describes the problem, motivations for adopting these practices, and advice on corporate transformation.
    • 00:26:11

    • Introduction to Deployment Pipelines  (Free)

      The new technical artifact introduced by Continuous Delivery is the deployment pipeline. This segment describes the fundamental concept, how a deployment pipeline compares to a continuous integration server, shows the types of stages, and describes triggering behaviors.
    • 00:22:50

    • Deployment Pipeline Stages  (Free)

      This segment performs a technical deep dive on the practical application of a deployment pipeline, using the open source Cruise-Go deployment pipeline. It shows how to configure pipelines, managing status and output, and triggering.
    • 00:16:11

    • Fan In & Fan Out

      A deployment pipeline may have projects that "fan in" to a common integration point, and also "fan out", spawn multiple related builds in parallel. This segment shows how to model both Fan In and Fan Out in Cruise-Go.
    • 00:22:34

    • Deployment Pipeline Challenges

      This segment highlights some common challenges and pitfalls when using a deployment pipeline, such as force cleaning environments and controlling triggering.
    • 00:17:55

    • Verifying Forward & Backward Compatibility

      A quite common scenario: I have an existing service that has undergone change, and I need to verify that it works correctly with the current production application and the current trunk of new features. This segment shows how you can automate this verification, allowing you to build for multiple targets with confidence.
    • 00:15:43

    • Testing Practices

      Testing is an important engineering practice for Continuous Delivery. This segment deconstructs the various types of tests you need (unit, functional, UAT, showcases, exploratory, etc) along with an analysis of the target audience (which determines efficacy) of various tests. I also explore metrics, pragmatic effort, and lots of best practices.
    • 00:35:52

    • Continuous Integration and Trunk-Based Development  (Free)

      The practice of continuous integration is an important building block for other engineering practices, yet many projects inadvertently throw it away. In this segment, I describe how common engineering practices like feature branches harm continuous integration, along with alternatives to restore it, and other engineering practices like opportunistic refactoring. Avoid the trap that meta-work is more important than work!
    • 00:25:50

    • Incremental Deployment Strategies

      One of the goals of Continuous Delivery is to reduce risk of release, and one way to cut down on risk is to release software incrementally rather than in a big bang. This segment describes several incremental release strategies, along with some potential pitfalls to avoid.
    • 00:14:39

    • Data Management & Migration

      Databases and DBAs are a natural part of the developer ecosystem, and this segment describes how to incorporate them into the iterative practices of Continuous Delivery, including tools, best practices, and pitfalls to avoid. I also discuss database refactoring techniques, along with the expand/contract pattern of decouple application and database updates.
    • 00:24:19

    • DevOps

      DevOps represents the merging of the development and operations silos. This segment describes the modern role of DevOps, how to manage infrastructure programmatically (along with a slew of benefits), modern options like Docker containers, and team organization.
    • 00:29:34

    • Continuous Delivery for Architects

      The practices of Continuous Delivery have greatly affected how we think about architecture. This segment describes the intersection of software architecture and the engineering practices in Continuous Delivery. I discuss component and service best practices, coupling and cohesion metrics, visualization tools, and some techniques to deconstruct monolithic architectures into (micro)service architectures.
    • 00:38:53

    • Microservices Introduction

      The microservice style of architecture is intriguing because it is the first post-DevOps revolution architecture: it's the first architectural style that fully embraces the concerns of operations. As such, it illustrates many benefits and difficulties for modern architecture. This segment introduces the basic concepts of microservice architectures, comparing and contrasting with monoliths, and highlights some best practices.
    • 00:24:17

    • Microservices Design

      In this segment, my colleague Rachel Laycock takes a deep dive on how to design for microservices, including considerations and pitfalls.
    • 00:20:40

    • Microservices Integration

      Continuing to investigate microservices, Rachel Laycock describes integration scenarios, orchestration versus choreography integration styles, and some engineering best practices to allow teams to work effectively together in a distributed architecture.
    • 00:20:31

    • Microservices Refactoring

      In this segment, Rachel describes practices and issues when refactoring in a microservices architecture.
    • 00:13:55

    • Engineering Practices for Microservices Part 1  (Free)

      In this segment, my colleague Ryan Murray describes a number of engineering practices utilized in a microservices environment. In this first segment, Ryan talks about some key principles like Last Responsible Moment, risk sliders to assess benefit versus risk, heatlhchecks, and metrics.
    • 00:27:17

Engineering Practices for Continuous Delivery

  • Publisher: O'Reilly Media
  • Released: March 2015
  • Run time: 8 hours 9 minutes

Releasing software to actual users can be a painful, risky, and time-consuming process. With this video workshop, experienced developers, testers, and operations engineers learn the principles and technical practices that enable rapid, incremental delivery of new, high-quality, valuable functionality to users.

This video from Neal Ford (and guest experts Tim Brown, Rachel Laycock, and Ryan Murray) demonstrates the engineering practices that allow you to get fast feedback on the production readiness of your application every time there is a change to the code, infrastructure, or configuration.

You’ll learn that, through automation of the build, deployment, and testing processes—and improved collaboration among developers, testers and operations engineers—delivery teams can get changes released in a matter of hours (sometimes even minutes), no matter how large or complex the project is.

Topics include:

  • Introduction to deployment pipelines
  • Deployment pipeline best practices with Cruise Go
  • Testing practices
  • Continuous integration
  • Trunk-based development
  • Incremental deployment strategies
  • Data management and migration
  • DevOps impact on all facets of a project
  • Continuous delivery for architects
  • Contract tests
  • Engineering practices for microservices
  • Metrics and monitoring
  • Details on setting up deployment pipelines
  • How continuous delivery works with Fan-in and Fan-out integration
  • How to ensure automated backwards compatibility among evolving services

Neal Ford is Director, Software Architect, and Meme Wrangler at ThoughtWorks, a global IT consultancy. Proficient in a variety of languages, paradigms, and architectural styles, his primary consulting focus is the design and construction of large-scale enterprise applications.

About the O’Reilly Software Architecture Series

Clearing a path from developer to architect and enriching that path once you arrive

Software architecture is a massive multidisciplinary subject, covering many roles and responsibilities, and it is a fast-moving discipline where entire suites of "best practices" become obsolete practically overnight—yesterday’s best practice is tomorrow’s anti-pattern. No single path or curriculum exists; different types of architecture—application, integration, enterprise—require different subject emphasis. And yet, year after year, the job "software architect" places in the top ten of most Best Jobs surveys.

Keeping up with new approaches is challenging because you must maintain both technical depth and breadth. Whether you are at the outset of a career as an architect or in the midst of such a career, the O’Reilly Software Architecture series brings together a rich variety of topics, deep dives, innovative thinking, practical tips, and unfettered access to expert know-how that you can incorporate into a path that makes sense for you.