1,242 karma · joined May 23, 2021
Linux, as in "in the desktop environment", has a HUGE (a can't highlight and stress enough the word HUGE) technical debt. It runs on a graphical server that was designed way before GPUs were even a thing (let alone multi-GPU, variable refresh rate monitors, HDPi, HDR, etc...). And because of all the design limitations, X just can't compete with either Windows nor MacOS (in that specific environment setup that you're asking for). It just can't. Period.
Mir and Wayland were born precisely to fix this entire mess. Mir never really took off (because of community backlash?), while Wayland is... well... it has been "in progress" for +10 years and it's still not "there". It will get there, eventually, at which point it might be able to offer the "it just works" experience. Or it might not. We'll have to wait and see.
The audio system was already fixed. A few times... We jumped from Jack, OSS and Alsa to PulseAudio and now to PipeWire and things look promising, but PipeWire is also in the progress, so we're not entirely there yet either.
Bottom line is: There can't be a distro that "just works", because we're missing the pieces to assemble such a distro.
Basically, you're ("you" as in figuratively speaking) smashing the functionality of a package manager into the interpreter. I'm not convinced at all that making a single tool do more and more stuff is a good idea, but let's keep on.
Then, you're writing URLs (for the libraries you're importing) all over the code (which is just bad). Deno's solution (from the link in my prev reply) is to just put all the URLs in a single file (so, basically a "packages.json", but now inside your code, ¿because that's somehow a good idea?).
Then there's the entire thing about replacing NPMJS, which has full-time engineers working on security, maintenance, etc... with a bunch of different servers, maybe maintained, maybe not, by random people.
Then there's the entire "but how can I be sure that the code didn't change?" thing, to which Deno suggests to use a "--lock command flag". This sounds like "npm.lock / yarn.lock".
And finally, there's the availability concern ("what happens if any of these servers goes down?"), which Deno just dismisses by saying that this can happen to any server. And while that is technically true, pulling all your dependencies from a single place, instead of N different places, reduces the points of failure to 1 (instead of N).
So, this entire "import directly from URLs" sounds just like a package manager with different steps, without providing anything new, without fixing any specific problems with package managers, and introducing new problems (which are in fact old problem, because as I said, we've been there already when PHP thought remote includes were a good idea).
Please don’t say HTTP imports are a good idea. Please.
Not an excuse for having typos in the product’s website, but a very common explanation for it.
This might be feasible with some limited-in-features apps, like an audio/video player, an IM client, etc...
Upgrading has turned from a joy to a completely fearful experience. And don't get me wrong, the omnibus installer is rock-solid and hasn't failed me once. The fear comes from me wondering if I have missed any of the dozens of things that got deprecated / changed and causing a major downtime in my Gitlab installation.
I wish Gitlab could slow down a little bit, but I totally understand this is not possible.
Please, run your backup servers on machines designed to do so, capable of receiving regular software updates, etc...
The writer starts by saying that servers were treated as pets, which inherently means difficulty (as the author clears out). I assume that, at some point, their services got reworked to a shape where they could be deployed in servers treated as cattle. This is a work the author had to pay no matter if the final goal was Kubernetes, Autoscale Groups or any other solution.
Then the author explains how they got to the conclusion that they need to containerise their service(s) in order to be able to use K8s, which would then, in turn, allow them to scale properly (adding on top the Go rewrite that is mentioned at some point in the post). The author also explains that Autoscale Groups were discarded because of their complexity.
It's not clear to me that K8s was the actual thing that helped them scale, but rather the work they put into reworking their services. In my experience, once your service(s) are ready to be deployed in servers that can be managed as cattle, the benefits show up independently of the deployment solution that is used to deploy the service(s) (K8s, Autoscale Groups, etc...).
Just to add on my point, wouldn't the result (in terms of performance / resources usage) be the same if instead of "containers" the author had chosen "AMIs" and instead of "Kubernetes" the author had opted for "Autoscale Groups"?
If that were the case (which I believe it might have), the other thing to consider would be the difficulty of managing a K8s cluster vs the difficulty of managing an Autoscale Group. I've seen quite some horror stories about K8s[1] and I'd rather choose ASG over K8s.
[1]: https://k8s.af
Either way, props to OP for the great work!