Keynote: The Neuroscience Behind Developer Productivity Engineering
This keynote discusses the neuroscience of developer productivity. It provides a thought-provoking take on the psychological root causes and “cognitive fatigue” associated with developer bottlenecks like unnecessarily long feedback cycles, protracted troubleshooting times, and toolchain failures. It discusses how a lack of understanding of this dynamic leads to a misalignment between leadership’s incremental perspective on the potential impact of DPE and that of their developers who feel the cognitive pains every day and see the impact of addressing these pains as transformational. Translating the productivity benefits of removing cognitive fatigue pain into a hard business case for leadership consumption remains a challenge. But, meeting that challenge is the key to realizing the “DPE multiplier”, which is the number of times developers say they could be more effective with a more efficient toolchain (usually 2X-5X). The presentation concludes by making the connections between productivity, developer experience, and joy.
Keynote: Why DPE is Needed Now More than Ever
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.
Keynote: Communicating for Productivity
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
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:
- From enabling to managing constant change
- Keeping projects up-to-date with latest opinions and practices
- Validating changes before shipping to consumers
- Improving the build performance and consistency experience
- Dependency resolution time reduction
- Build & Artifact caching
- Remote test execution
- Improving self-serviceability
- Enhanced build insights for a given build
- Flaky test detection
- What’s in the horizon
- Predictive Test Selection
- Container experience for Integration Testing
- IDE experience Enhancements
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.
Foundations of Predictive Test Selection
Developers typically change a vast minority of their codebases at any one time, and yet small changes often require many hours of testing time, even though very few tests are actually affected.
The time and energy costs of this phenomenon are monumental, which is why “Test Impact Analysis” is a trending concept in and around the realm of developer productivity.
In this talk we will discuss why Gradle decided to invest in Predictive Test Selection as a promising Test Impact Analysis solution, the tenets and tradeoffs we made intentionally to provide a solid developer and build engineering experience, and how we think this technology is best used by software engineering teams.
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.
Learn how Meta has quantified developer velocity through a standardized and objective velocity metric, and how we’ve used that metric to help developers identify problematic areas of the codebase.
We’ll also talk about some related ways that Meta is helping developers move more quickly and safely, including
- Categorizing diffs to show code that is most often affected by bugs and incidents.
- Tracking knowledge dispersal within a team to highlight areas of the code that will lose knowledge if specific individuals leave the team.
- Exposing a team velocity dashboard that helps teams visualize the state of their code, processes, and velocity.
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?
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.
Breeding 10x Developers with Developer Productivity Engineering
Over the last decade, DevOps has emerged as a core business philosophy and practice, helping businesses drive high-quality software to market faster and at scale. DevOps focuses on the elimination of bottlenecks that occur when development and operational resources are too divorced from one another. How can we reduce toil, friction, and frustration in areas that are outside of the focus of DevOps such as slow builds, flaky tests, and other avoidable failures?
We will demonstrate how Gradle Enterprise’s comprehensive Developer Productivity Engineering solution–including build and test acceleration, failure analytics, and observation technologies–can address all of these concerns.