bazel

Unfortunately, Bazel also does not support file names w/ spaces https://github.com/bazelbuild/bazel/issues/374

That Makefile works with BSD and GNU make, no extensions used. Bazel isn't really nicer than the autotools when you need something complicated, if it even supports your platform. Here's a fun bazel bug report: https://github.com/bazelbuild/bazel/issues/4350#issuecomment... I've always managed to avoid autotools unless it was used before with things like LDFLAGS='-lsocket -lns' make ...

What's wrong with the Java dependency? There's even a single-binary Bazel executable[1] that brings its own embedded OpenJDK. My company is using Bazel and the Java dependency has never been an issue. Even if you write custom rules, you use the Python-like Skylark language and never interact with Java code. [1]: https://github.com/bazelbuild/bazel/releases (the single-binary distribution is bazel-1.1.0-linux-x86_64, it's only 40MB).

Bazel, like most Google open source projects, has a strong focus on Google's internal needs. Another similar Bazel surprise is how many hoops you have to jump through for the rare task of... debugging a cc_binary on macOS: https://github.com/bazelbuild/bazel/issues/2537

Companies using bazel [1]: * Asana * Databricks * Dropbox * Google * Huawei * Lyft * Pinterest * Stripe * TwoSigma * Uber ... This is not a new project that needs pushing. [1] https://github.com/bazelbuild/bazel/wiki/Bazel-Users

"Blaze" is littered all around the code base [0]. [0] - https://github.com/bazelbuild/bazel/search?q=blaze&unscoped_...

Bazel is here to stay. Sooo many companies are jumping on this bandwagon [1]. Bazel is better than Maven, Pants... you name it. Think of this like Protobuf or Kubernetes. It's an open source tool used to build things at scale. There will be lots of users and contributors. A cottage industry will spring up, and this will grow well beyond Google. [1] https://github.com/bazelbuild/bazel/wiki/Bazel-Users

In my experience this is only true for C/C++ (with a decent amount of work to setup CROSSTOOL properly). As soon as you start to get into Python, and Python<->C++ interop, it becomes very leaky. I heard that Google has some tools internally that build the Python interpreter with Bazel and use that in order to guarantee hermeticity, but that doesn't seem to be possible with public tooling (at least not without some major hacks, for example https://github.com/bazelbuild/bazel/issues/4286 ) It would be interesting to see how Google manages languages such as Python at scale (and other languages that have similarly leaky package management).

I'd say the main the challenge that both Bazel and Buck have to face in the C++ land is that it's still too much work to migrate an existing cmake/autotools project to them. One nice project that tries to tackle that is https://github.com/bazelbuild/rules_foreign_cc. But yes, there are minor things that make migration from Bazel to Buck or vice versa not as smooth as it could be, and I'm confident those will be fixed. To me the biggest added value of Bazel is the remote (build and test) execution (which will get a nice performance boost from https://github.com/bazelbuild/bazel/issues/6862 in Bazel 0.25; also mentioned in [3]). (Your [3] doesn't compare Bazel and Buck, only Bazel with remote caching and without it, so it's not clear from it that Buck leverages caches better than Bazel). And one nit, Bazel doesn't allow you to download anyt

> What's your take on Bazel? Here a couple key points: - Buck and Bazel are very similar. - Buck currently models C++ projects better [1]. - Buck leverages remote caches currently better than Bazel [3] - Bazel is very easy to install - Bazels "toolchains" make it very easy to onboard newcomers (to any project and language) but also ensure the build will run as expected. - Bazel is less opinionated and more extensible than Buck. In fact Bazel is so powerful that you can have Buildfiles that download a package manager and use it to resolve more dependencies. This is great to get things off the ground, but makes things less composable because the package manager won't see the whole dependency graph. As a result you might get version conflicts somewhere down the line. To summarize: I think having a very opinionated build-system is easier to

Overall Buck and Bazel are quite similar as they are both converging to Starlark DSL. However there are still some differences: Buck is much more opinionated than Bazel. Buck models slightly better C++ projects[1] and currently it's remote cache is more efficient[2]. Bazel is more extensible and offers also remote execution. Bazel has a bigger community and it's roadmap is public. There has been more than 350 C++ [4] libraries been ported to Buck for the Buckaroo Package Manager[3]. There are also technical details that manifest in some odd ways but are not significant. There is a nice paper by Simon Peyton Jones (creator of haskell) and others that goes into the design details [5] [1] https://github.com/bazelbuild/bazel/issues/7568 [2] https://github.com/bazelbuild/bazel/issues/7664 [3] https://github.com/LoopPerfect/buckaroo [4] https:/

bazel can’t even build static libraries https://github.com/bazelbuild/bazel/issues/1920