Bazel

SMPM, SBT, Maven, Gradle, Python.

Yeah, so, or Bazel.

I think, what's it called, Bazel? Bazel? Something.

I don't know.

Yeah, I noticed even the prior tool would work for different build systems because they're pragmatic.

But I also felt like there were some technical tools that didn't scale as well with our code bases I would have hoped.

And as I looked into this problem space, I realized big companies like Google, they had this internal build system blaze that inspired the open source Bazel, built around all these amazing techniques, but it was exceptionally difficult to adopt.

There wasn't really something that made those techniques available to the everyday engineering org.

And that was a large part of the motivation for wanting to co-found and build RWX.

And I think some of this is also a consequence of the shift that we made in the industry over the past decade towards using more ephemeral infrastructure, because there's a lot of nice properties of that as opposed to using more persistent environments.

But there was also some consequences and trade-offs there.

And as I looked in this space, I realized that build tools like Bazel, tools like Nix, had these really interesting ideas built in them.

But there wasn't really something that took those same concepts and applied it to continuous integration really broadly and comprehensively and in a way that worked really well, you know, across a wide variety of runtimes and frameworks and different tech snacks that organizations are using.

To the extreme opposite, the Google style mono repo where you have 1,000 services inside of one repo, and the cognitive load that comes along with that.

I can acknowledge the beautiful things that can also happen with a mono repo, but a lot of teams also don't have the sophistication to operate things like Bazel the way that Google does.

Therefore, where I'm seeing is a really nice hybrid model where you have a number of repositories in an organization with a collection of services that are loosely related to each other and don't have tight couplings across.

Because you never wanna have two services tightly coupled across two different repositories or you're in deployment hell.

something still has to check it.

The Bazel agent is published under an image name that looks like a repository of its own, and no repository has that name.

The agent ships from the hub's own repository, DiFi publishes four images from one repository and moves them together.

So on Teton September, a single DiFi release produced four reviews, four not found answers, and four verdicts of needs attention that carried no information about the upgrade at all.

I haven't seen it for a long, long time.

But then that became Bazel externally.

It became Buck.

There's some other, you know, people went to Facebook and they like, that was awesome at Google.

We can just kind of implement, you know, the dependency kind of update engine directly.

And then that's where the performance improvements were able to come in.

So like, because I Google scale, like when you have a large repo in general, like my understanding is that the reason Bazel and Buck are so popular for large code bases is it can help you improve your build performance.

It gives you a lot more levers to play around with from caching, from being smart about cache generation to obviously just raw performance.