Sessions

Session Title

Session Description

Presenter(s)

Taking an Empathetic Approach to a Developer Platform

Hear how DoorDash built a Developer Platform organization that prioritizes developer empathy. Modern Developer Productivity studies point to frameworks like SPACE to guide roadmaps and measure success. This guidance factors into the engineer’s perception, while balancing traditional metrics such as those found in DORA. DoorDash went “all in” on putting developer empathy first and foremost as they built their Developer Platform org from the ground up. In this talk, they’ll discuss the major projects they took on and how they took some surprising steps that helped scale DoorDash’s engineering org– one that grew by more than 1000 engineers in the last two years.

Code Generation

A talk about how generated code (code created from running scripts) overtook the repo, slowed down our devs, and steps we’ve taken to reduce the pain.

Siri Developer Productivity Journey

Follow the transformations of the Siri build beginning from the migration from Maven to Gradle and how we have used the ecosystem offered by Gradle and Github to enhance the user experience of developers, increase the velocity of the feedback loop to developers and overall smooth out the experience from a Siri developer standpoint.

  • Migration of the build from Maven to Gradle
  • Declaring and tracking build inputs
  • Why too many inputs is bad
  • Why too few inputs is bad
  • Output stability & caching
  • Troubleshooting local configuration – Gradle build scans
  • Custom values in build scans
  • Mono repo vs mono build – breaking down the build in component to avoid rebuilding slow changing components
  • User experience focus – feedback to developers on the progress of their PR
  • Github App/Checks
  • Code owners for mono repos
  • Codeowners vs custom one

A More Integrated Build and CI to Accelerate Builds at Netflix

Find out how Netflix’s DevProd organization concentrates on the local development loop and ways to shrink the time spent purely waiting. Points of discussion will include:

  • Building dependency cache (Topcoat/Varnish + Dependency cache on CI agents with latest framework libraries)
  • Building caching at task level (push from CI, consume in CI and local)
  • Test distribution
  • Predictive Test Selection
  • Gradle build scans for triaging/debugging build issues
  • Integration with CI infrastructure
  • Viewing build scan metrics and exporting them for custom dashboards: task usage, plugin usage, build trends, more filtering
  • Share common pains when rolling out this: when you’re not on the paved path, & using maven or mill or SBT or other tools that we do not support

Chasing the Speed of Gradle Builds

AndroidX is a large collection of OSS Kotlin and Java libraries by Google built to make Android app developers’ lives easier. This talk will take you on a journey exploring how Gradle Build has evolved and grown from 12 to over 650 projects. Learn how Gradle kept CI times and quality at bay.

Dogfooding Developer Productivity: Development Process at JetBrains

This talk covers the development processes used for the largest project at JetBrains: the monorepo for the IDEs based on the IntelliJ Platform. This project spans 22 years of history, includes ~30M lines of Java and Kotlin code, and was supported by hundreds of contributors. Learn how JetBrains uses its products (TeamCity, YouTrack, Space, shared indexes, Toolbox Enterprise), as well as JetBrains custom tools to increase productivity.

Strategies to Make and Keep Builds Cacheable

Discover strategies and tooling to make builds cacheable and how to catch regressions in cacheability once the builds have been optimized. Learn about new ways to incrementally introduce build caching company-wide across multiple projects.

How Gradle Built Predictive Test Selection

Learn how Gradle created and productized a machine learning system that intelligently skips irrelevant tests from scratch. Also, find out about the company’s biggest challenges and how teams overcame them. Some included issues related to product planning, raw data collection, model selection, flaky test handling, dogfooding, and getting to production. This insightful talk is designed to inform developer productivity enthusiasts and data scientists, especially as ML is applied to more engineering tools.

Fast (Not Furious) Developer Experience

Developers like faster builds, performant IDEs, and modern tools. Achieving it at scale with thousands of developers working on a single codebase requires not just improving speed but also reducing developer pain points like migrations, refactoring, and new technology learning curves. This talk will cover ways to achieve a pleasant development experience despite the not-so-pleasant aspects of software development. It will also cover how Uber solves some of these problems at scale.

Descriptive to Prescriptive Analytics and Beyond for Developer Productivity

Developer productivity teams make the most impact by presenting the right insights to the right people at the right time. Now in the trenches of development, developer pain is often obvious and acute. But at the mile-high view of the executive level, understanding bottlenecks and priorities conjures the imagery of a crystal ball. See how the Developer Insights team integrated subjective and objective telemetry sources into analytics presented through a single pane of glass to all levels. At LinkedIn, development occurs in an ecosystem, and many kingdoms of biological diversity exist: backend, frontend, mobile, and more. Each of these kingdoms has patterns and nuances that no single team can understand. Moving through the four kinds of analytics: descriptive, diagnostic, predictive, and prescriptive, the Developer Insights team is now looking beyond. As LinkedIn continues to scale, the team is turning to data science and AI models for analytics and services.

Airbnb Developer Productivity Wins

Learn how the Airbnb developer platform team shares their organization’s developer productivity experience initiatives to overcome challenges, celebrate wins, and leverage lessons learned. Points of discussion include:

How Airbnb ships software and runs builds/tests/deploy
Software/Tooling stack
Build/test stats
DPE KPIs
Reducing developer tax
Improving the IDE experience
Moving development to the cloud (BDT in the cloud)

OpenRewrite: Making Your Source Code Fix Itself

The software industrial revolution has arrived. Software is now 80% open source and third party and 20% proprietary code that stitches it together into business critical applications.

We are challenged with the ongoing maintenance of increasingly large and diversely composed codebases and ecosystems. Dependencies are changing frequently and evolve at their own pace. Not updating leads to critical bugs, performance, and security issues.

In this talk we’ll introduce OpenRewrite, an automated refactoring technology that was born at Netflix in 2016. We’ll write the code for a recipe live that fixes a known issue and execute it across 300 million lines of open source code, culminating in pull requests to key open source projects. The recipe will be made available in open source for you to apply to your own codebase at the end of the session.

How your Monorepo Breaks the IDE, and What We're Doing About It

Dumping all your code into a single shared monorepository is all the rage. But our tooling is only catching up with the new paradigm. We’ll go over how large repositories and common patterns in them are breaking long-standing assumptions in IntelliJ IDEA in terms of project model, performance, and user experience. Then we will take a look at our current ideas and approaches to solving these problems in a monorepo world.

Empowering Productivity

In this talk, we’ll discuss how we can measure engineering productivity, as well as how to use that measurement to highlight areas of the code that are difficult to iterate on.

How we Built a Distributed Testing Platform

Test time is one of the key drivers of build times. Many factors contribute to test time, including running tests sequentially or dependencies on expensive external resources/services. The sheer number of tests to cover a wide range of inputs is also a factor. This often leads to running tests only on CI thereby considerably lengthening the feedback loop.

Join us in this session to take a behind-the-scenes look at the challenges the team building Test Distribution faced and how we solved them. To name a few: efficient file transfer, unstable network connections, scheduling, and auto-scaling. In addition, we’ll share experiences from customers adopting Test Distribution. What issues did they face when starting to distribute existing test suites? How did they overcome them? What successes/gains did they see?

Elastic's Dev Cloud Acceleration with GCP and Gradle Enterprise

Elastic uses Gradle Enterprise build and test acceleration technology to minimize CI build and test feedback cycle times. With Gradle Enterprise Build Scan data, Elasticsearch can also monitor and optimize resource usage and performance. In combination with Google Cloud’s compute performance and cost advantages, Elastic delivers superior service levels to its internal stakeholders and customers.

Specifically, you will learn about:

  • Getting started with Google Cloud Platform and the Gradle Build Tool
  • The benefits of running CI builds and tests in the Cloud
  • Best practices for transitioning to the Cloud leveraging Gradle Enterprise to (1) monitor GCP usage and performance trends with Build Scans and (2) optimize build & test feedback cycle times using Build Cache and Test Distribution

Personal Developer Productivity Tips: It's the Small Things

Many small productivity improvements add up. Focusing on your personal developer productivity.

“Small things” we will talk about:

  • Better error messages
  • Filing better bugs
  • “Ask for help” better
  • Learning keyboard shortcuts

Isolated Development

With the growth of codebases come more challenges: applications become larger, build times longer, and the iteration speed for developers decreases. To scale Square’s Android and iOS codebase horizontally and keep engineers productive the company started to invest in Isolated Development three years ago. The idea to run single features in a sandbox environment was a big shift on the engineering side but also enabled many opportunities. This talk discusses some of Square’s learnings, how they transformed the idea into reality, how teams adopted development apps, how they reduced build and IDE sync times by 10X, and where the journey is going next.

Building in the Cloud with Remote Development

Imagine developing on your laptop, but with the computing power of the cloud! LinkedIn successfully reduced the initial setup and build times from 10-30 minutes to just 10 seconds for most of their products with a new remote development experience. In this talk, learn about LinkedIn’s journey to achieve this goal.

Flaky Tests & Binary Repositories, a Year in the Life of a Google DPE Engineer

Google Fitbit’s developer productivity team shares their successful initiatives for improving developer experience in the last year. Learn about Google’s best practices around Flaky Test management. Also, find out about lessons learned from the migration from Artifactory to Google Clouds Artifact Registry.

Mobile Developer Productivity at Scale

Building large mobile apps is hard. Keeping developers productive while working on large mobile apps is harder. Most Android developer tools target smaller apps, so how do we think about building some of the largest apps in the world? In this talk, you’ll learn how Uber enables hundreds of Android developers to contribute to a handful of the app in a single monorepo while keeping developers feeling productive and shipping reliable apps quickly. We’ll cover:

  • How the mobile teams are structured
  • How developer productivity is measured and monitored
  • Custom tools like Bazel & Buck, our CI/CD diff pipeline, the testing and device lab infrastructure, the remote dev server environment, and custom IDE plugins and tools
  • How to modularize and use common app architecture and frameworks to keep consistency in all apps
  • How to prioritize open-source engagement and some best practices to continually evolve and modernize apps at scale to keep up with the fast-moving pace of Android.

Whether you’re planning for your own app’s scale or just curious about how it’s done in one of the largest apps, you won’t want to miss this talk.

Code Health Score: How Slack Tracks and Manages Code Tech Debt at Scale

All codebases have technical debt. Sometimes developers plan to clean it up later. Other times they act on the urge to go on a refactoring binge. Addressing technical debt can be rewarding and useful. But how can we make sure that it is not simply left to the whim of a good samaritan? And can such work be consistently seen and encouraged by engineering leadership?

Following the trope of “you can’t improve what you don’t measure,” Slack employs a code health score: an empirical measure that provides visibility into cumulative and team-based technical debt to address these questions. But measurement alone isn’t enough. Quality is important to integrate these measurements into the day-to-day engineering culture of the team.

This talk will provide the formula for building a code health score for any codebase, touch on the nuances of its implementation on Android/iOS, and share what lessons learned about integrating this tool into our engineering process.