9 ms·
I think Rust's biggest threat is that it's repeating the same mistakes C++ did, despite the hindsight. C++ tried to be everything for everyone -- a language ela
by pron 6y ago
I think Rust's biggest threat is that it's repeating the same mistakes C++ did, despite the hindsight. C++ tried to be everything for everyone -- a language elaborate enough to write applications in a style that appears high-level on the page, and yet not give up on the full control required for low-level programming. For a while, it worked. The problems only became apparent some years later, when large applications had to be maintained, and people realised that low-level languages, no matter how high-level-looking, all make a certain sacrifice: low abstraction. Clients of components are sensitive to implementation details of those components, and so the maintenance of applications costs as much as that of low-level code does. OTOH, the complexity of the language made portability hard (low-level code is often written for custom hardware) and also hard to analyse. C continued to dominate the embedded space, the application space went to true high-level languages, and C++ kept an intermediate, though important niche, of games and software platforms for capable-enough hardware, which it firmly holds on to.
Rust is now doing the same. Few in the embedded space find it appealing, many of those who use C++ do (as it is certainly a cleaned-up C++, and a nice improvement in comparison), but too often not appealing enough to switch now, and some in the application space who don't know or don't remember the C++ lesson do adopt it now (sometimes out of sheer novelty) but will likely abandon it later for similar reasons C++ was largely abandoned in that space. So it is really competing for a pretty small and conservative niche -- albeit an important one -- and one with a strong incumbent. If it does very well, in 20 years we might find that 60% of the C++ space has switched over to Rust, and that's about it.
What Rust needs is focus, but it won't have it because I think some of its designers still believe in what C++ believed. That you can have a language that is both high-level and low-level, with the benefits of both and the downsides of neither.So it's being pulled in multiple directions, all while showing poor performance in the market (C++, at least, wasn't just hyped but actually popular). It's not even going after C++'s market seriously, but after the nonexistent market C++ thought it could occupy; the only market it seems to be actually competing over and doing well in is HN-front-page real-estate, the space formerly occupied by Ruby and Haskell. When I was at University in the late '90s, everyone was talking about Haskell will be the language of the future. With almost constant levels of hype, more than twenty years later, it still is. It turns out that for various reasons, when it comes to programming languages, hype and market performance can be completely out of sync for decades. Rust's designers need to choose between adoration and actual popularity. The latter will require some tough decisions. If it's going after the C++ market, it should make itself extremely appealing, irresistibly so, to C++ programmers.
- tiddles 6y agoMaybe this is why Zig might end up being a better choice for embedded and very low level programming, as an explicit competitor to C.
- pron 6y agoI have no idea what Zig might turn up to be. I like it a lot aesthetically, but it's far too early to tell what market adoption, if any, it will see. But at least its strategy is clearer: it ignores the (incidental?) "C++ niche" altogether, and says that there are only two categories, low and high, and it's going after low. This covers all of C and the majority (>75%) of the C++ space.
- Ygg2 6y agoPreface. I disagree. I definitely don't get the feeling that C++ was that popular, I distintcly remember many Linus rants about it. It's just that after years of usage it carved its own niche. However one pain point Rust does address is parallelism. If you want to use modern systems, and you're going with C++. Good luck. You're gonna need it. As for the popularity, I think that's moot. But I do agree Rust can't be everything to everyone. One problem it will have for the forseable future, is the slow compile speed. But on the flip side, Rust has been super popular. But it does one thing no other language does. Safe concurrency without GC. It's like a seatbelt in a car. Once you get used to it, you'll be paranoid its not there. ---- Where I do agree with article author was rate of change. IMO Pin should have never been added to standard library as it currently is. But async was rushed, for god knows what reasons.
- jcelerier 6y ago> If you want to use modern systems, and you're going with C++. Good luck. You're gonna need it. if you're doing modern stuff you just use a task-based parallelism lib and pass things by value with libs such as https://github.com/taskflow/taskflow https://github.com/taskflow/taskflow, https://github.com/cameron314/concurrentqueue https://github.com/cameron314/concurrentqueue ...
- carols10cents 6y ago