Stable rust hasn't broken in my experience.
Stable rust hasn't broken in my experience.
And don't go saying I should use rust-up. That's a symptom of the very problem I'm describing. What other compiler is only usable if you install from some website instead of your repos? I can't think of any.
Edit: Just re-read your comment. Maybe ping the guys in Debian to update their repos?
Hard to see this as a problem with the language per se. What is the language supposed to do, ship working features but ask people politely not to use them? Not ship new features even if they solve acute problems?
As a library consumer, if you want you can just stick to >6 month old versions of all the libraries you depend on, and they should work fine with your 6 month old compiler version.
Eventually maybe in 5 years Rust will have it's major pains solved and things slow down a bit. Maybe then the release schedule will actually change as well? Who knows
As for major language features I remember async await from a year ago, const generics recently and that’s it. If you can remember more features that fundamentally changed how we write code, please let us know.
I don’t think many features are expected in the near future apart from maybe generic associated types. But not any time soon either.
I think you might be seeing releases every six weeks and assume that each of these bring massive changes. They don’t. Each is a small iterative improvement. Take a look at the Rust release notes if you like.
Custom allocators and anything else required to build bare-metal software.
Compiling Rust itself, especially std::core. I hit that wall when trying to cross-compile using stable Rust that came with my distro.
Eventually the Rust dev community will grow enough to have non-language-specific-enthusiasts devs as a majority and it will slow down and begin to target actually stable releases. But as of now you have about 5 months functionality per "stable" release.
You live by some principles. Most people don't care about the principles you seem to care very much about. Most just have problems that need solving and Rust is the best tool for solving them. If the tool works differently to how they are used to working, they adapt and get on with their lives.
Just because they can doesn't mean you can. They solve Google problems.
And they use Rust to solve specialized problems because at their scale it is worth squeezing every advantage.
For mortals like you and me most problems should be faced with a completely different mindset.
I'm addressing your statement that says a language is of general use if used by the likes of Google and Facebook.
They have infinite amounts of enginering and very special problems to solve. What makes sense for them often does not for smaller teams solving trivial problems.
> Strange how a language according to you is unsuitable for general use. Yet it is used by Google, Facebook, Apple, Amazon, Dropbox, Microsoft, Mozilla, Huawei, etc.
For example, as I understand it the rust compiler team literally compiles every public crate with each version of the rust compiler to make sure they haven’t broken anything. The platform generally expects users to mostly keep up to date - as a web developer I can now use new features in chrome and FF within a month or so of the feature being released. Gone are the days of leaving behind large swathes of users because they’re still using FF 4.0 or IE 6. Nodejs has its own support table. I don’t care what version of nodejs Debian LTS has; when version 8 of nodejs stopped being officially supported and maintained, I immediately dropped support for it in my npm packages.
The “minimum supported rust version” flag in cargo will help with this going forward. But more generally I think this model of software development makes sense and we’ll see it more and more going forward. There was a kernel bug a few months ago caused by a bug in an old version of gcc. The gcc bug was fixed years ago but the patch was never backported to ancient gcc versions. Some distros were compiling Linux using ancient gcc versions, and then got upset when they ran into problems. The answer here is for gcc to say the same thing nodejs does - “these versions are supported and get bug fixes. These versions do not. Use old versions at your peril - they have known bugs.” Explicit support periods is better than vague, ambiguous expectations that software will work forever. Microsoft has the same policy with windows patches.
I think the era where it makes sense for apt to carry that burden by serving us ancient software packages is slowly coming to an end. As software packages take responsibility for evergreen stability, it also makes sense for users to get evergreen software. It would be nice if we could do that without needing app specific version managers like rustup and nvm.
https://wiki.debian.org/Teams/RustPackaging/Policy
If you restrict yourself to packages in the repo, won’t that resolve the issue? The idea of a distro is that all the packages in the distribution should play nicely together, but if you go outside that then version compatibility won’t be handled for you.
Debian's policies are simply incompatible with the Chrome-like "evergreen" release model that Rust uses. I feel sorry for anyone who tries to use Debian's Rust. It is an awful experience.
- you will only use an old compiler because that’s your preferred source of installing tools
- you will only use the latest and greatest packages that require the newer compilers.
And this is somehow the languages fault. The language needs to fix the problem of library authors using language features? Seems to me like it’d be easier for you to relax one of your two requirements. They’re fundamentally incompatible.
The second problem is that even if 90% of your dependencies support older compilers, it doesn't matter, because the 10% that insist on newer compilers will still break. It can be a single dependency, and you usually have hundreds, with vastly different policies.
There are solutions to this problem, like MSRV aware cargo. They just need someone to implement them (as well as someone to compute MSRV numbers).
I'm just not sure how what you're describing would work.
Safety-critical systems may need these guarantees, but I object to them externalizing the costs they need to bear on the whole community.
Almost everyone should be on up-to-date compilers, assuming the compilers promise that they won't break old code. The more we move towards that world the better.
However there is hope for a better future: https://github.com/rust-lang/rust/issues/65262 will allow crates to specify a minimum supported rust version (MSRV), this way, we can imagine cargo resolving algorithm taking the installed rust version into account when picking the version of a crate to download so it would pick the last version of the crate that still compile on your system.
Another thing is the Sealed Rust / Ferrocene initiative [https://ferrous-systems.com/ferrocene/]. The idea is to have a version of rust supported for a long time, and it is likely that many core crates from the ecosystem will decide to keep compatibility with that LTS version.
The recommended way to manage your rust installation is rustup. It makes it trivial to set up and manage tool chains, globally or otherwise.
> what other compiler is only usable if you install from some website instead of your repos?
What compilers' recommended installation is some 3rd party package manager that lags behind the latest stable release by months?
Rustup is a useful tool, it's dumb to ignore it.
And this is a terrible development that we should all try to resist, as it leads to a combinatoral explosion of dependencies and problems, as soon as you introduce another language. So then we end up using docker to encapsulate things because they are hard to manage on one box.
It just seems crazy, but I don't really have much of a solution, tbh. Perhaps we could just install the build tool (in this case rustup) for supported languages and stop trying.
If all of software respected those assumptions then we wouldn't need containerization nearly to the degree we have it today.
I mean, I know how to handle it, but it's pretty depressing that I need to do it, when in the past one could rely on relatively recent versions of everything existing with a system package manager.
I always need C/C++/Java dependencies in DS, so maybe I just feel the pain points more.
Modern package management in a nutshell is "don't do what we do in C because we learned from those mistakes."
If you had chosen a rolling distro like Arch, you wouldn't have to use Rustup.
Lets see... i had this problem with python all the time, the system python version was notoriously old and out of date on macos, redhat, debian, etc. This is how pip and pyenv and a dozen other tools were born.
Similar things with node. Or when the distro gcc has a bug that your code hits. Go has this problem too - e.g. the pain around moving from nothing -> dep -> modules was real (if not widely publicized).
The language provided version/package manager solves a very real problem. That problem is a mismatch in what a system package should be vs what a development package should be. In some sense containers, nix/guix stye package management, and language specific dependency managers are different approaches to solving the problem: what my computer runs for daily use should be relatively stable and generally I won't need the latest and greatest package features in software I use - upstream developers have generaly dealt with various library deficiencies bugs in their dependencies. In software I develop though, I regularly hit api bugs and sure would like to just use version+1 instead of spending time developing around it. Particularly when the output of my development is a binary that is running in a container on some server.