Companies don’t let you use production code in any language you choose. There is usually a discussion.
I was in a Perl shop many years ago and introducing Python was strongly discouraged.
I was in a Perl shop many years ago and introducing Python was strongly discouraged.
You might be surprised. At most companies I've worked at (over a dozen) that's largely true. Three jobs ago I was product architect for the entire company and spent a significant part of my time fighting just this kind of language proliferation. However, it's a very different story at a large company. Google seems to try pretty hard to keep this under control. OTOH, Facebook (where I work) prides itself on a "bottom up" "engineer driven" culture in which any such top-down prescriptivism doesn't fly. Don't know where the others fit in along that spectrum. The situation gets even murkier when code is inherited via acquisition or imported from open source. So such code often exists, whether it's "supposed to" or not.
Therefore in practice, giving engineers the freedom to make their choices doesn't lead to an explosion in the number of languages used in production.
An engineering team that can get started with a new, esoteric language without having to first build internal libraries is much more likely to try that new language.
Like Scala or Kotlin for example?
This requirement is a stumbling block for many languages. For example when compiling Rust, no one actually calls rustc directly, everyone uses cargo. Effectively this meant someone had to reimplement cargo within buck.
When you think about the dizzying array of touch points (logging, metrics/monitoring, service publishing and discovery, and on and on) that even the smallest component needs, the absurd wealth of libraries better than anything in open source, the standards-committee level expertise an email away that you have in one of the mainstream languages it becomes clear that you’d need more than a large incremental improvement in the language itself to break even.
The thing that might get Rust over the threshold isn’t memory safety (modern C++ with hardcore warnings-as-errors static analysis and automated ASAN/TSAN/UBSAN runs is rather solid), it’s build times.
Build times are the thing that will kill C++ unless they can come up with a modules solution that is cheaper to migrate than rewriting everything. At some point you just can’t fucking build the thing no matter how many boxes you throw at it. Rust may have a window of opportunity before C++ finds an answer on that.
Thrift generators and/or a decent FFI can resolve a lot of those. Yes, other teams might try to make noise and threaten not to support you, but I've yet to see one go so far as to blacklist a service because they disagreed with its implementation choices (including language).
> libraries better than anything in open source
Only in their authors' minds, in most cases. NIH at its worst.
> Build times are the thing that will kill C++
Certainly up there, and I wish more people realized this. Every test/deploy pipeline is an order of magnitude slower than it should be because of this, and perpetuating it is part of why I think those libraries aren't really better. In fact many of them make it worse, because they're the most aggressive users of features that increase compilation time.
folly/absl/gtest/glog/tf/pytorch/etc/etc aren’t perfect, but they have stuff that no one else has, and they had it before Github did.
“The guy who wrote the book” so to speak often works at one of these places, and while some of the stuff makes it into open source some of the time, some of it doesn’t.
Google gets Borg, OSS gets k8s.
Citing NIH is kinda flamey as an alternative to citing examples IMHO.
After eight years working solely on open source at Red Hat, I've seen nothing particularly exceptional about the quality of Facebook's proprietary code. People who have no experience beyond school see something new, they think it's the bees' knees, surely they think they must be blessed to work at a place where such things are created ... but they're not uniquely blessed. There are people all over this industry pushing the state of the art. Facebook engineers think that Facebook hires the best people in the world, but people at Google think that they do, and people at Apple think that they do, and people at random startups think that they do. Not without reason in any case, but still incorrectly. It's a common kind of sampling error. The reality is that there's good and bad code everywhere, and the larger a company is the more it tends to regress toward the mean.
I don’t know exactly why a tangent about having F14FastMap or MPMCQueue (and proprietary friends) before the rest of the world has evoked such a strong reaction in a point about C++ making sense at MegaCorp du jour, but calling people who think the cutting-edge internal stuff at the elite companies is a plus for C++ new grads is where I step off this train. I share your frustration with the consolidation of power, money, and talent at a small number of elite institutions to some degree, but you can take it out on someone else.
Rust can at least in principle do better than “recursive textual substitution of massive amounts of redundant code into translation units” and I imagine the Rust leadership is probably sharp enough to know that this is the chink in the armor of an otherwise rapidly improving safety and usability story for a deeply entrenched incumbent.
The rust compiler / internals section has very few experts. The compiler produces poor LLVM IR and compile times are as poor as C++ __Despite having modules__. Basic performance improvements like ```TrustedLen``` took a lot of time to surface despite everyone touting "zero cost abstractions".
Given the hype rust is getting by ruby/js hipsters learning it, you would think they would have a better, faster compiler backend instead of depending on LLVM cruft which can't even utilize rust's Mutable Xor Shared guarantees.
Lumping Apple together with software companies illustrates well why using this acronym out of context is silly. Apple is incredibly silo'ed in comparison. Teams have a lot more freedom since they don't need to reuse internal infrastructure so much.
However once you start getting into very heavily used production services, choosing a different platform becomes increasingly difficult.