Protocol Buffers: Google's Data Interchange Format Continues to Evolve with Bazel 8+ Support and GCC 10 Testing

What Changed

Protocol Buffers (protobuf), Google's widely adopted data interchange format, has undergone several recent updates focusing on build system integration, compiler support, and internal development processes. Key changes include the introduction of Bzlmod support for Bazel 8+, updates to the Bazel CI presubmit matrix, and the removal of older GCC versions from GitHub Actions testing in favor of GCC 10.

Specifically, the project now explicitly supports Bazel with Bzlmod for Bazel 8 and newer versions, allowing users to specify protobuf as a dependency in their MODULE.bazel file. This modernizes the Bazel integration, offering an alternative to the traditional WORKSPACE approach. Concurrently, the .bazelci configuration has been updated to remove macOS (Intel Macs) from the presubmit matrix, revise Debian and Ubuntu distributions, and incorporate Bazel 9.x testing.

In terms of compiler support, the .github workflow for C++ testing has been refined. GitHub Actions matrix entries testing GCC versions prior to GCC 10 (specifically 7.5, 9.1, and 9.5) have been removed, and a GCC 10.4 test has been added. This aligns the testing infrastructure with the project's current support matrix, ensuring compatibility with more recent compiler versions.

Internal refactoring also occurred, such as the extraction of OptionInterpreter to option_interpreter.h and option_interpreter.cc from descriptor_builder.h and descriptor.cc respectively. Furthermore, the C# protobuf implementation saw a version update to 37.0-dev, indicating ongoing development across various language bindings.

Technical Details

The integration of Bzlmod for Bazel 8+ signifies a move towards a more modular and efficient dependency management system within the Bazel ecosystem. Developers can now declare a dependency on protobuf in their MODULE.bazel file, with an option to override the repository name for compatibility with existing WORKSPACE setups. This streamlines dependency resolution and build graph management for projects utilizing Bazel.

The updates to the .bazelci presubmit matrix reflect a continuous effort to maintain a robust and up-to-date continuous integration environment. The removal of Intel Mac testing and the addition of Bazel 9.x indicate an adaptation to evolving build environments and toolchain versions. This ensures that changes to the protobuf codebase are validated against relevant and current build configurations.

The adjustment of GCC testing in GitHub Actions is a direct consequence of updating the supported compiler matrix. By focusing testing on GCC 10 and newer, the project ensures that the C++ runtime and compiler are compatible with modern C++ standards and features, while reducing the overhead of testing against deprecated compiler versions. This change is documented as aligning with the project's support matrix.

The internal refactoring, such as the extraction of OptionInterpreter components, points to ongoing efforts to improve code organization and maintainability within the protobuf compiler and runtime. Such changes often facilitate future development, bug fixes, and feature additions by creating more modular and testable code units. The C# version increment to 37.0-dev indicates active development and maintenance of the C# language binding, ensuring it keeps pace with core protobuf advancements.

Developer Implications

For developers using Protocol Buffers, these updates primarily impact build configurations and compiler compatibility. Those leveraging Bazel for their projects will benefit from the explicit Bzlmod support, potentially simplifying their dependency declarations and build processes, especially when migrating to Bazel 8 or newer. The project explicitly recommends pinning to a release commit on a release branch when building from source, particularly for C++ users, to mitigate potential instability from the head revision of the main branch.

C++ developers should be aware of the updated GCC testing matrix. While the project aims for broad compatibility, the focus on GCC 10 and above in CI suggests that development and testing efforts are concentrated on more modern compiler versions. This might necessitate updating local development environments or CI pipelines to match these newer compiler requirements for optimal compatibility and to avoid potential build issues.

Developers working with the C# protobuf runtime can anticipate ongoing improvements and features, as indicated by the version bump to 37.0-dev. This continuous development across language bindings ensures that protobuf remains a viable and up-to-date data serialization solution for a diverse range of programming languages.

Overall, the changes reinforce the project's commitment to stability through supported releases and modern build practices, while also acknowledging the dynamic nature of software development environments.

Bottom Line

Google's Protocol Buffers project continues its evolution, with recent updates enhancing its build system integration and compiler support. The introduction of Bzlmod compatibility for Bazel 8+ and the shift to testing with GCC 10 in CI reflect a strategic move towards modern development practices and toolchains. These changes aim to improve the developer experience by streamlining dependency management and ensuring compatibility with contemporary compilers. While the project emphasizes working from supported releases for stability, the ongoing updates demonstrate active maintenance and a commitment to keeping protobuf a robust and versatile data interchange format across various programming languages and platforms.