"Rust is a real pleasure to use for web development, and I thoroughly recommend it. It is so versatile that, without a doubt, it’s the last programming language I learned. Ever."
This doesn't inspire much confidence in the evaluation of the writer.
This doesn't inspire much confidence in the evaluation of the writer.
I'm very interested in programming languages and expect new and better ones to be discovered in the future. At the same time yesterday I noticed that I'm not as hungry for new languages as I were before: Rust is good enough that I can live with it being the last language in existence.
Praises are generally dismissed when they seem to contradict this principle
That being said I'm sure that rustaceans disagree about the "No Silver Bullet" part (when you can compile to WebAssembly, write HTTP / TCP servers, embedded development and much more).
For distributed problems I'd prefer something like Elixir. This may even be true for web dev (I admit I haven't explored it as much in Rust; just, a lot of what I've had in web services is IO bound, with strong process isolation expectations, and that's perfect for Elixir)
For heavy math, Julia or maybe Python + libs.
To build a DSL, a Lisp.
For something largely integrative of other libraries, whatever language those libraries are built in.
For certain types of problem solving and optimization problems, a logic language like Prolog.
Etc.
Rustaceans tend to be a pretty practical bunch, so I'd imagine most of them do agree with it. It was also the one part of your post I didn't agree with (if taken literally)
I'm certain they don't. For one, Rust can't even be used in a niche but important class of safety/mission critical software until a certain level of certifications (i.e. DO-178C) are reached so by that measure alone it is disqualified. For two, what targets the languages compile to are a necessary but far from sufficient measure of a language's practicality - the most important ones have nothing to do with the language and everything to do with ecosystem and tooling.
While it's doubtful there's a single programming language to rule them all, I seriously doubt the panoply of languages we are faced with is the optimal solution. At some point as a developer new languages stop bending your brain in new ways, they just become the same thing with all new baggage to deal with. I can certainly see where a person is legitimately in search of the last language they ever need to learn.
Is that contradictory? Non-adjustable wrenches still exist, and are still used on a regular basis. If you do a lot of work on at a single size they're nice because they weigh less, fit in smaller spaces, and you don't have to worry about then getting jostled and changing size on you.
This is, of course, folly. Just as one who thinks himself the best to rule the kingdom is probably the worst choice for the job, so too the one who thinks himself 100% enlightened is the least likely to actually be considered enlightened by his peers.
Something I realized doing c++ professionally for the first time last year, it's nearly three different languages. There's an inner core of procedural C, the mid-90s new/delete/raw pointers OO business that got big during the heyday of COM/ATL/other Microsoft technologies, and then what's come to be known as "modern C++", with smart pointers and a lot more automatic stuff.
What I most enjoyed about C++ is how, as someone put it, it feels like an armory with everything on offer from a pocketknife to a nuclear weapon. It integrates with everything, you can write code any way you want from embedded assembly up to functional, and it runs everywhere, on any platform, and can link with Android, Windows, Linux, .NET, Java, whatever.
I'm starting to think garbage collected languages are headed for obsolescence. Like maybe, with better languages, we could ditch all the bullshit of pip, and gems, and all that, and get back to a time where you could just download something, run it, and not have to worry about some gigantic runtime environment that eats all your memory and requires a ton of configuration. It we could pull that off without making it incredibly hard to write simple code, that'd be cool.
In short: I'm pretty sure GC isn't going anywhere, even if some of its usecases start to get covered by non-GC'd languages.
It really didn’t seem horrible back then.