Abstract:

This webinar, "Bazel 104: C++," introduces product developers to using Bazel for C++ projects, emphasizing its advantages over traditional build systems like CMake and Make. The presentation highlights Bazel's ability to ensure reproducible, hermetic, and portable builds through features like toolchains (LLVM/Clang), sysroots, and the Bazel Central Registry for third-party libraries. Key demonstrations include setting up a "Hello World" application, integrating and statically linking a third-party library (libmagic), configuring interactive development with editor integration (using clangd and a compilation database), and advanced topics like cross-compilation for different platforms (e.g., Linux ARM64) and publishing OCI (Docker) containers. The speaker also touches upon iBazel for interactive mode, testing, debugging, linting, and future automatic BUILD file generation, while critically discussing some existing Bazel behaviors like bazel run.

Bazel for C++: A Comprehensive Guide for Developers

• 0:00 Introduction to Bazel for C++: The webinar introduces Bazel 104, focusing on C++ development, and is designed for product developers rather than infrastructure engineers.
• 3:09 Why Choose Bazel for C++: Bazel offers significant advantages over traditional build tools like CMake and Make, not just for large-scale or multi-language projects, but also for ensuring reproducible, hermetic, and portable C++ builds through robust toolchain management and sysroots.
• 5:55 Key Bazel Concepts & Tools:
  • Bazel Central Registry (BCR): A repository for external C++ libraries.
  • Toolchains: Used to manage compilers (e.g., LLVM/Clang) and other tools for hermetic builds, decoupling them from the host machine's installed packages.
  • Sysroots: Essential for providing all necessary headers and libraries for a target platform, ensuring true hermeticity and enabling cross-compilation.
  • rules_cc: Bazel's native C/C++ rules.
  • Gazelle: A tool for automatically generating Bazel BUILD files.
• 10:08 Project Initialization: Demonstrates using aspect init to scaffold a new C++ project, including automatic download of the appropriate LLVM/Clang toolchain for the local architecture.
• 14:35 "Hello World" Example:
  • Shows how to create a simple hello.c program.
  • Explains using the cc_binary rule in Bazel instead of direct compiler commands, centralizing build configurations.
  • Uses bazel aquery to inspect the underlying compilation commands and identify initial non-hermetic paths.
  • Recommends keeping a Makefile for developer convenience and task running alongside Bazel.
• 26:17 Integrating libmagic:
  • Demonstrates how to integrate a third-party C library, libmagic, directly from the Bazel Central Registry, ensuring a hermetic dependency.
  • Illustrates challenges with version skew between host system libraries and Bazel-managed ones.
  • Highlights the use of the data attribute for runtime dependencies and environment variables for file resolution.
• 33:12 Interactive Bazel (iBazel): Explains iBazel as a watch mode for Bazel, useful for automatically rebuilding and running tests during active development.
• 36:39 Editor Integration with clangd:
  • Explains the role of clangd (LLVM's C++ language server) for providing features like syntax highlighting, error detection, jump-to-definition, and auto-completion.
  • Shows how Bazel generates a "compilation database" (compile_commands.json) to provide clangd with accurate build information.
  • Demonstrates enabling clangd and regenerating the compilation database to enable full editor support for Bazel C++ projects.
• 43:56 Cross-Compilation and Platforms:
  • Introduces the concept of "platforms" in Bazel, allowing developers to define target build environments (e.g., Linux ARM64).
  • Explains that sysroots are crucial for providing target-specific headers and libraries, making cross-compilation fully hermetic.
  • Demonstrates cross-compiling a C++ application for a Linux ARM64 target.
• 48:38 OCI (Docker) Container Integration:
  • Shows how to package the cross-compiled binary into a minimal OCI container (using rules_oci and distroless base images).
  • Demonstrates building and loading the container into a local container runtime (e.g., Podman) and running the application to verify its execution on the target platform and glibc version.
• 54:06 Bazel Transitions: Explains "transitions" as a way to automatically apply platform configurations to build targets and their dependencies, enabling simultaneous builds for multiple architectures (e.g., ARM and x86) within a single Bazel command. This is useful for cost savings (e.g., AWS Graviton) and flexible deployments.
• 57:46 Linting with clang-tidy: Briefly demonstrates the bazel lint command (part of Aspect CLI) which integrates clang-tidy to provide static analysis results, helping maintain code quality and facilitating code review.
• 59:42 Future of Build File Generation: Mentions ongoing work on automatically generating BUILD files for C++ code, aiming to eliminate the need for manual BUILD file creation.
• 1:01:05 Discussion on bazel run: The speaker criticizes bazel run for its unpredictable working directory and non-hermetic behavior, recommending the use of Makefiles for task running.