Abstract:

This webinar provides a comprehensive guide for product developers on leveraging Bazel for C++ development, addressing common pain points and highlighting its advantages over traditional build tools like CMake and Make. The presentation covers fundamental concepts such as hermetic builds, toolchains, and sysroots, demonstrating how to achieve reproducible and portable C++ builds. Key topics include integrating external dependencies from the Bazel Central Registry, configuring editors with clangd using a compilation database, and performing cross-compilation for different target platforms, including Linux AArch64 and OCI containers. The session also touches upon testing with GoogleTest, debugging with LLDB, static analysis with clang-tidy for linting, and automated BUILD file generation using Gazelle, emphasizing efficient workflows and robust CI/CD integration.

Bazel for C++ Development: A Comprehensive Guide

• 0:10 Introduction to Bazel for C++: The session is aimed at product developers who want to make Bazel approachable for C++ projects, emphasizing its benefits beyond just large-scale or multi-language monorepos due to inherent C++ build tool shortcomings.
• 4:33 Key Bazel Tools and Concepts: Overview of essential tools including the Bazel Central Registry (BCR) for C++ libraries, toolchains_llvm for hermetic C++ toolchains and sysroots, rules_foreign_cc for integrating legacy builds, rules_cc for Starlark-implemented C++ rules, and Aspect CLI's Gazelle plugin for automated BUILD file generation.
• 8:48 Discussion on Nyx and Bazel: Explores the challenges and interest in combining Nyx (a competing hermetic environment) with Bazel, noting difficulties due to Nyx's absolute path dependencies.
• 10:08 Project Setup and LLVM Download: Demonstrates initializing a new Bazel C++ project using aspect init, which automatically configures the environment and downloads the hermetic LLVM/Clang toolchain.
• 14:31 Hello World and Build Inspection: Shows how to create a simple hello.c program and build it with cc_binary. bazel aquery is used to inspect the underlying clang commands and flags, revealing initial non-hermetic include paths (e.g., MacOS SDK).
• 20:15 Integrating with Makefiles: Recommends keeping existing Makefiles as a task runner or interface to Bazel, to ease developer migration and leverage existing knowledge.
• 26:06 Understanding iBazel: Explains iBazel as an interactive "watch mode" for Bazel, particularly useful for running tests continuously during development.
• 26:18 Hermetic External Dependencies: Demonstrates obtaining libmagic from the Bazel Central Registry (bazel_dep) to ensure hermeticity and avoid reliance on host-installed system libraries.
• 30:57 Static Linking and Runtime Data: Configures cc_binary to statically link libmagic and handle its runtime data dependency (magic.mgc) using env and data attributes in the BUILD file.
• 36:38 Editor Integration with clangd: Explains how to set up clangd (LLVM's C++ language server) with Bazel by generating a "Compilation Database" using hedron_compile_commands, providing in-editor features like error highlighting, jump-to-definition, and code completion.
• 39:32 Enhanced Editor Features: Shows how clangd provides accurate code completion and identifies clang-tidy warnings, improving developer productivity.
• 41:51 Testing with GoogleTest: Briefly covers cc_test for integrating GoogleTest into Bazel projects.
• 42:43 Debugging with LLDB: Mentions bazel run with config=lldb for debugging, requiring specific .bazelrc and .lldbinit configurations.
• 43:51 Cross-compilation and Platforms: Introduces Bazel's platform concept (user-defined OS, CPU, ABI) and the distinction between dev, host, exec, and target platforms, highlighting cross-compilation as building for a target different from the exec platform.
• 47:27 Sysroot for Cross-Compilation: Discusses the necessity of a sysroot (linkable libraries and headers for the target platform) for cross-compilation and provides options for obtaining one.
• 48:09 Linux AArch64 Cross-Compilation Example: Demonstrates cross-compiling a C++ binary (including gnu/libc-version.h) for linux-aarch64 by fetching a pre-built sysroot and using the --platforms flag.
• 49:34 OCI Container Deployment: Shows how to package the cross-compiled binary into a minimal Docker (OCI) container using rules_oci and tar.bzl, then loading and running it to verify the glibc version.
• 53:50 Build Transitions for Multi-Platform Support: Introduces platform_transition_binary to automatically apply target platform configurations to dependencies, enabling simultaneous builds for multiple architectures without repetitive --platforms flags.
• 57:07 Benefits of Multi-Architecture Images: Explains how building multi-arch OCI images can save costs (e.g., on AWS Graviton ARM architectures) and provide deployment flexibility.
• 57:44 Linting and Formatting with clang-tidy: Details how clang-tidy warnings appear in the editor and can be enforced across the codebase using aspect lint with Bazel aspects, including integration into CI/CD workflows for code review.
• 59:38 Automated BUILD File Generation with Gazelle: Explains Gazelle's function in automatically creating and maintaining BUILD files by analyzing source code includes and generating cc_library targets and dependencies, highlighting its Starlark extensibility.
• 1:01:08 Critiques of bazel run: The presenter expresses dissatisfaction with bazel run due to its unpredictable working directory and advocates for using Makefiles for task execution.
• 1:03:08 Coverage Tooling Critique: The presenter suggests that Bazel's built-in coverage tools could be better implemented as an aspect-based approach, similar to linting.