No matter if C or C++ was more "fun", CMake is not and I think the the "fun" parts of coding are worse with Rust but the particularly unpleasant ones are relatively good. In that sense Rust's success might be due to it being more or a "pain pill" than a "vitamin"
Michael Hashimoto has made comments to the effect that Zig is attractive to him relative to Rust simply because it's more enjoyable to write but I think there's very few people for whom that could outweigh the lack of ecosystem
Rust probably has more to learn and is indeed probably _more difficult to learn_ than Zig in that it's simply a bigger language (which is quantifiable, even if only approximately) but difficultly of learning vs. enjoyment of reading/writing/speaking are different questions.
It's a bit like saying German is unfun to read and write. To who? To Germans?
If it is done right, the language might feel nice to use or elegant but users might not articulate why that is. That can be a key selling point. And of course there are a lot of languages where the type system was a bit of an afterthought that got popular anyway. Javascript and other dynamically typed languages comes to mind. Rust kind of sits on the other end of the spectrum. And it has a deserved reputation for being a bit hard to learn because of it.
So it helps to choose a drill brand with the ecosystem you like, not just one that's a serviceable drill.
(Or you could argue that a language's ecosystem is part of the dang language. Which I agree with).
Honestly I'm not trying to downplay Node, I respect Node for what it was and is, but Go punched above its weight early on too.
I think the industry was starved for a back-end language that was simple, compiled natively (removing a lot of environmental setup overhead) and was production ready out of the box.
Node.js was 90% of the inspiration for Go to exist in the first place.
Swift also would have never came about if it wasn't for people doing iOS way better in JavaScript.
SwiftUI is basically React conceptually
The Go community made Go work on Windows leading up to 2009, the core maintainers of Go did not make the Windows build themselves, they didn't care about Windows being a target. I say this to emphasize how quickly popular it became that it built up a community that wanted it to build for Windows, and they did.
2013 is when the rest of the world was starting to catch on to Go I suppose, Docker came out in 2013, but I distinctly remember learning Go on Windows in 2009 and building web apps, without any third party packages.
Go 1.0 was released in 2013 (I don't even think the "official date" of March 28, 2012 is correct, or at least, nobody had heard of it).
Apple doing Swift and Google doing Go was basically in response to Node.js
> but I distinctly remember learning Go on Windows in 2009 and building web apps
Very highly doubt it
This is a strange and ahistorical take. Go was heavily discussed in 2009 after it was first announced by Google. It didn't go four years between public announcement in 2009 and people finally learning of it in 2013.
Major themes of discussion in 2009: Does it have generics and if not, why not? How does it compare to Erlang? And why did they reuse the name from this language Go! we all just heard about five minutes ago? https://news.ycombinator.com/item?id=936544 - from the day after the language was publicly revealed.
The first two topics (generics and how it compares to Erlang) are still discussed today, though the former is now mostly complaining that it has generics instead of complaining that it doesn't have generics.
Go was absolutely not mainstream in 200 fucking 9. When Flash dominated the web and everyone did Wordpress for websites. Nobody (at large) did Go before they did Node.
You are pointing to extremely early design discussions you absolute twat. Get real. Anyone who was active in their career in ~2013 knows that's exactly when Go came out.
I am from San Francisco and lived here my whole life - and it wasn't the epicenter of tech then (2013) but Mountain View sure as fuck was, and it's like 45m away and I would fucking know if Go was written in 2009 and it wasn't.
You're a liar. Go away
I started college in 2011 and I was telling the professors about it before it was popular, Vitess was in 2010, used in production by YouTube. JavaScript predates NodeJS even so.
I did use Linux in 2009 so I could be misremembering when it was ported, after all this was over a decade and some change ago.
Edit:
My overall argument still stands, in production at YouTube by 2010, by 2013 we already had Docker in the works, when you say it "just came out" but many people were eyeballing Go and waiting for it to be fully on Windows.
So 2010 they were talking about the Windows port, guess I blended the years a bit, everything before my college years is all smashed together for me.
I don't doubt it has a searchable history back to 2010.
Why do you think people put up with Spring?
I consider npm to be part of "the interface of JavaScript" and to your point it's one of the strongest reasons beyond performance to use Node over some other dynamic language like Ruby or PHP.
Python earned its keep mainly because of its library ecosystem (again to your point) but also due to its simple, teachable syntax.
My point is that Python is not used because it's highly performant - it's basically the slowest language there is. But because people like the syntax and the library ecosystem (AKA the interface to the language)
If you are just building a table then hopefully you are not trying to do the whole thing with a keyhole saw.
Where one has a large library and runs on many platforms, and the other doesn't?
Where one behaves like PHP with respect to equality, and the other doesn't?
The closer metaphor is the handle. A saw handle may be ergonomic, that doesn't mean the quality of the blade is good, or even suitable for what you're trying to cut.
Best rebuttal here - yeah didn't think of that obvious one!
I had a larger point about language idealism / putting code on a pedestal vs getting the job done but yeah, this crowd can't handle that lmao
But it's the syntax and semantics what determine whether I'd want to use the language to begin with, and how maintainable the resulting code is.
Python was harder to write - it was less expressive to me than perl, which could say stuff like "unless <bleh>" while python would require "if not <bleh>"
it was more regular, more compact and was visually easier to read
but it was the python standard library that kept me going back, because I could solve lots of problems without reinventing the wheel, or becoming a sysadmin to install a package my lowly script required.
Switching languages is a big time commitment. Or at least it used to be. I find myself more open to that now that I can hit the ground running with AI coding tools in most languages. But still, it's a time investment to learn a language, its idioms, its way of doing things, all the tools, libraries, and frameworks, etc. It's not something you do an in afternoon. And certainly not mid project.
The languages that people gravitate to are the ones that look like they are safe, future proof bets. If you are going to spend all this energy learning one, you want to know it's a good investment. Successful languages have lots of users, decent tools, good libraries, etc. Or at least they look like there are serious people behind them. Many people make these bets early in their careers and then stick to them as well. I meet a fair share of people my age that are still sticking to Java. Because that's what they learned when they were in their twenties. I'm 51 now.
Rust is a good example of a language that's hard to learn but managed to get off the ground because of the solid people behind it. It wasn't just an academic exercise: Mozilla was trying to solve a real problem and they managed to get a nice community behind the language and it grew from there. This is not something that happens a lot. People create new languages all the time. But many stay very niche and the projects around them tend to go stale very quickly if they fail to attract a community of users.