You are viewing content from a past/completed QCon

Presentation: Evolving Continuous Integration: Applying CI to CI Strategy

Track: Developer Experience: Level up your Engineering Effectiveness

Location: Ballroom BC

Duration: 11:50am - 12:40pm

Day of week: Wednesday

Level: Intermediate

Persona: DevOps Engineer, Technical Engineering Manager

Share this on:

What You’ll Learn

  1. Understand principles for deciding how to build on top of existing CI tooling to improve the developer experience.

  2. Hear a practical approach of building tooling, such as Bitbucket/Jenkins plugins, to iteratively improve the CI process.

  3. Learn some of the lessons and challenges we found in evolving our CI strategy in this way.

Abstract

Continuous integration as a practice has come to be virtually synonymous with the tools that enable it. As developer workflows grew increasingly diverse and complex, we saw the need to extend and support continuous integration beyond the commit/test/fix cycle. While our existing tooling generally worked for building commits and running suites of automated tests, we found that reliably building pull requests and simplifying the common cases while still supporting complex configurations still presented challenges.   

Inspired by developer feedback and the friction we faced with our existing tooling, we began evolving our continuous integration strategy to focus on increasing velocity, simplifying builds, and providing a more integrated developer experience. This session will explore how we leveraged the best practices and opinions of other CI-first tools, fast feedback and requests from our engineers, and an iterative approach to begin building a new suite of tools to support a diverse set of workflows. We will also dive into the technical considerations and approach we are using to minimize configuration while enabling reliable, traceable builds integrated with our existing toolchain.

Question: 

What is the focus of your work today?

Answer: 

I'm on the Build and CI team (which is part of the productivity engineering organization) at Netflix. My focus is primarily on the continuous integration phase. We use Jenkins as one of our primary tools, but a lot of what I'm doing is working on building our next phase of tooling for continuous integration.

Question: 

What's your motivation for the talk?

Answer: 

The talk is focused on the work we're doing, specifically through the lens of how we've approached improving our developer experience, at the point of continuous integration. Instead of migrating to a new tool for the potential benefits of a few new features, we’re focusing on improving the experience by building some of those capabilities into our existing toolset with more first class support.

I think it's a really powerful story, especially from an enterprise background, to show that to improve your process and give developers what they want—a better experience and the ability to build the way they want—you don't have to replace all of the tools you're using. You can leverage what you already have and that makes for a more meaningful and smooth migration.

Question: 

Who are you talking to? Are you talking to a developer or to someone who works specifically building frameworks or tooling, etc.?

Answer: 

The target persona is someone who works on tools being produced for developer consumption. Whether that's a developer building tooling or someone in a more senior role who is informing some of those decisions, it's people who are thinking about the developer mindset and are in positions where they're trying to improve that developer experience.

Question: 

Can you give me an example of something you might talk about?

Answer: 

I will talk about, for example, how we built a Bitbucket plugin and a Jenkins plugin to make our CI more event-driven as opposed to using the polling mechanisms that are supported by the existing tooling. We could achieve something resembling that with the existing tooling, but it required more complex configuration and we wanted to move towards a more truly event-driven model. I'll also talk about how we made those decisions and what we've learned along the way.

Question: 

What do you want someone that comes to your talk to leave with?

Answer: 

The key takeaway is how easy it can be to start improving the developer experience by building on what you already have. Instead of trying to take on a huge migration of builds to a new system, how do we start thinking about places in our existing system we can tweak? Where do we see problems now and how can we start to address them?

Question: 

People are going to ask you if you push your changes back upstream.

Answer: 

We haven't yet. It's definitely something that's on our roadmap for where we'd like to go, but we're a fairly small team so that hasn't been realistic for us yet.

Question: 

Last question what technology issue keeps you up at night?

Answer: 

There are so many, but lately I've been thinking more about chatops and the developer experience. I think there are many ways we could be leveraging that model to improve the developer experience and reduce some of the cognitive overhead introduced by our tool chains and processes.

Speaker: Elise McCallum

Senior Software Engineer @Netflix

As a senior software engineer on the Productivity Engineering team, Elise McCallum develops and supports the tools that enable continuous integration at Netflix. Elise has a deep interest in optimizing the development lifecycle and path to production to make delivering value as frictionless as possible. Prior to Netflix, Elise worked as a senior consultant at ThoughtWorks, helping companies to tackle challenges both technical and organizational.

Find Elise McCallum at

Tracks

  • Building & Scaling High-Performing Teams

    To have a high-performing team, everybody on it has to feel and act like an owner. Organizational health and psychological safety are foundational underpinnings to support ownership.

  • Evolving the JVM

    The JVM continues to evolve. We’ll look at how things are evolving. Covering Kotlin, Clojure, Java, OpenJDK, and Graal. Expect polyglot, multi-VM, performance, and more.

  • Trust, Safety & Security

    Privacy, confidentiality, safety and security: learning from the frontlines.

  • JavaScript & Transpiler/WebAssembly Track

    JavaScript is the language of the web. Latest practices for JavaScript development in and how transpilers are affecting the way we work. We’ll also look at the work being done with WebAssembly.

  • Living on the Edge: The World of Edge Compute From Device to Application Edge

    Applied, practical & real-world deep-dive into industry adoption of OS, containers and virtualization, including Linux on.

  • Software Supply Chain

    Securing the container image supply chain (containers + orchestration + security + DevOps).

  • Modern CS in the Real World

    Thoughts pushing software forward, including consensus, CRDT's, formal methods & probabilistic programming.

  • Tech Ethics: The Intersection of Human Welfare & STEM

    What does it mean to be ethical in software? Hear how the discussion is evolving and what is being said in ethics.

  • Optimizing Yourself: Human Skills for Individuals

    Better teams start with a better self. Learn practical skills for IC.

  • Modern Data Architectures

    Today’s systems move huge volumes of data. Hear how places like LinkedIn, Facebook, Uber and more built their systems and learn from their mistakes.

  • Practices of DevOps & Lean Thinking

    Practical approaches using DevOps and a lean approach to delivering software.

  • Microservices Patterns & Practices

    What's the last mile for deploying your service? Learn techniques from the world's most innovative shops on managing and operating Microservices at scale.

  • Bare Knuckle Performance

    Killing latency and getting the most out of your hardware

  • Architectures You've Always Wondered About

    Next-gen architectures from the most admired companies in software, such as Netflix, Google, Facebook, Twitter, & more

  • Machine Learning for Developers

    AI/ML is more approachable than ever. Discover how deep learning and ML is being used in practice. Topics include: TensorFlow, TPUs, Keras, PyTorch & more. No PhD required.

  • Production Readiness: Building Resilient Systems

    Making systems resilient involves people and tech. Learn about strategies being used from chaos testing to distributed systems clustering.

  • Regulation, Risk and Compliance

    With so much uncertainty, how do you bulkhead your organization and technology choices? Learn strategies for dealing with uncertainty.

  • Languages of Infrastructure

    This track explores languages being used to code the infrastructure. Expect practices on toolkits and languages like Cloudformation, Terraform, Python, Go, Rust, Erlang.