Location: Horizon Hall
In the 30 min Keynote, Jeff Cox, Sr Director of Engineering, who leads Google’s Core Developer Services organization, will share Bazel short term and long term goals for 2023, current and future OSS investments and provide insights into Bazel value both to Google and 3rd party developers globally

Location: Horizon Hall
Radhika, Sven and John will share 2022 achievements, customer successtories and 2023 plans. Learn about Bazel roadmap, community contrinutions and how you may partipate in advancing the state of Bazel

Location: Horizon Hall
Shared actions are barely documented, obscure feature. It's not even exactly clear what they're good for. However, their implementation touches several core parts of Bazel such as action execution, input discovery, artifact conflict checking, and artifact "ownership". So, by exploring shared actions much can be learned about Bazel internals.

Location: Horizon Hall
Complete, explicit dependency declarations allow Bazel to provide fast and correct builds. Bazel helps to enforce this within your project, but it is easy to inadvertently introduce implicit dependencies on system tools or libraries. The Nix package manager makes implicit dependencies explicit and gives you access to nixpkgs, the largest package repository out there. Get the best of both worlds by combining Nix + Bazel.

Location: Horizon Hall
At Stripe, we maintain a large Bazel monorepo with over a thousand contributors consisting of multiple languages (Java, Scala, Python), each with millions of lines of code. Developers often have to laboriously enumerate dependencies in their BUILD files, which is toilsome and a major source of friction.

In this talk, we’ll show how we’re tackling this problem with Build Helper, a tool we implemented with Gazelle extensions and 3rd party dependency indexing that automates much of this process for our internal users. Along the way, we’ll also talk about some of the challenges we faced, tradeoffs about the codebase to be made, and our future plans for Build Helper

Location: Horizon Hall
Fuzz testing (also known as “fuzzing”) is a testing technique based on feeding automatically generated data to a program to catch bugs and security vulnerabilities. Modern fuzzers rely on instrumentation to receive feedback on code coverage and state exploration from the program under test, allowing them to progress deep into the code and uncover security issues with essentially no false positives.

This talk will demonstrate how easy it is to fuzz test Bazel C/C++ and Java projects locally using the new open-source CLI tool cifuzz developed by Code Intelligence and rules_fuzzing, to which we have contributed Java support. Commercial on-premise and SaaS analogues of RBE and BES for fuzzing complement the open-source tooling, providing CI/CD triggered remote fuzzing runs and a web UI for managing findings and fuzzing performance. Multi-service, multi-language web applications (including Go services) with REST or gRPC APIs can also be fuzz tested using these platforms.

Location: Horizon Hall
VS Code is popular and a lot of developers at using it today. The Java support in VS Code works with Gradle and Maven. As we were migrating our monolith from Ant and Maven to Bazel, we needed a solution to support Java development. This talk will introduce you to the Bazel VS Code Java extension and show what's possible today and what limitations exist. We'll also talk about new feature coming in the next year.

Location: Horizon Hall
Google open-sourced Blaze, and some large companies have been able to replicate Google's success in using it. However, many more companies have tried, only to discover that Bazel doesn't have "batteries included".

Aspect's goal is to make a build system based on Bazel that's easier for companies to adopt and operate, both on developer's machines and on hosted services like CI.

Come hear about our offering and our product roadmap.

Location: Horizon Hall
How can we make sense of a dependency graph with tens of thousands of targets and dependencies? At Spotify we have developed a set of data processing pipelines, metrics, and dashboards that combine static graph analysis, Bazel build data, and behavioral aspects about how our developers interact with the code. We have used this to successfully identify architectural bottlenecks, to understand what code changes that have a degrading impact on the rest of the organization, and to prioritize engineering efforts based on high-reward targets for refactoring.

In this talk, we’ll introduce Bazel Dependency Metrics. How did we come up with these metrics, and how do we collect and track them? We’ll walk you through our dashboards and share some early indicators on how this has guided our complex migration efforts.

Location: Horizon Hall
This talk shares our experience from migrating a large Ant and Maven using monolith to Bazel in an incremental way. Dealing with challenges such as transitive dependencies, unresponsive/inactive teams, insufficient test coverage and lots of deviation from Maven best practices made us go back to the drawing board a few times during the journey, not to mention the transformation of the build graph that has yet to happen.

Location: Horizon Hall
More and more iOS apps continue to adopt Bazel to tremendous benefit, but a successful migration must be prepared for challenges not only technical, but cultural as well. In this talk I’ll recap observations being on two iOS teams that moved to Bazel, including the recent Slack migration, with a focus on impact the teams, the people, and strategies for ensuring a smooth adoption and long-term success

Location: Horizon Hall
By default, Bazel requires that all targets agree on a single version for external dependencies. However, for Airbnb's JVM monorepo, one version is just not enough.

In this talk, we'll share our approach to overcoming the single version requirement and unblocking our Bazel migration.

Location: Horizon Hall
It starts with the gist of extending Bazel. Then, cover using the robust open core via BlazeModule subsets in new ways. I’ll conclude with ideas and issues related to building powerful features and APIs that aren’t suited for Bazelbuild it’s self

Location: Horizon Hall
Bazel provides fast and correct builds, if build actions are hermetic and reproducible. Rule sets go to great lengths to control the environment and the precise toolchains used in build actions, but one corner is often overlooked: Shell scripts and generic rules frequently assume that the tools they use are installed globally and behave consistently across build environments. This is not always the case! In this talk you will see how to tighten that gap using the hermetic shell toolchain provided by rules_sh.

Location: Horizon Hall
We've made changes around the Bazel docs, and invite you to join us in making more! bazel.build now sports new and refreshed content, improved information architecture, and a better external contribution workflow. Come learn how to propose changes to Bazel's documentation, ask questions or give feedback to the docs team, and maybe even identify a page you want to adopt.

Location: Horizon Hall
Tecton AI maintains a polyglot Bazel build targeting multiple CPU architectures and Operating Systems. Integrating Python into our build presented some unique challenges due to the nature of the broader Python packaging ecosystem. In this talk I'll introduce those challenges, share from my team's experience solving them, and give advice on how to integrate Python into your own builds.

Location: Horizon Hall
At Stripe, a typical microservice depends on thousands of Bazel targets. It sounds extreme—and our new tool is proving that it's unnecessary. Learn how we used Bazel, the Javac API, SQLite, and some light graph theory, to remove hundreds of dependencies from our engineers' code.

Location: Horizon Hall
With immense variety in open source projects and communities, defining “project health” can be a daunting and elusive exercise. In this talk we will discuss an overview of measuring open source health at Google as well as explore community driven initiatives stemming from the CHAOSS project. We will explore both generalized and specific examples of metrics programs with the goal to help community leaders define and implement measurements that align with their goals. 

Location: Horizon Hall
In order to share foundational code between iOS and Android, at Lyft we have started leveraging bazel's flexibility to build Rust for mobile platforms. This talk will go through some of the issues we hit along the way and some practical tips for debugging issues.

Location: Horizon Hall
Learn how to use rules_xcodeproj to generate Xcode projects for your Apple-flavored Bazel workspaces (e.g. iOS or macOS). Projects generated with rules_xcodeproj fully support Xcode-specific features, such as debugging, indexing, integrated testing, and SwiftUI Previews, as well as Bazel-enabled features, such as Focused Targets.