qalmakka

that's nice and all - but where are the native Darwin containers? Why is it ok for Apple to continue squeezing people with macOS CI jobs to keep buying stupid Mac Minis to put in racks only to avoid a mess? Just pull FreeBSD jails!

The point is not that he doesn't deliver anything, or that he never achieved any sort of success - he did, he is incredibly successful. The point is that he constantly oversold what his goals were and made promises that couldn't be kept, often to get the funding he needed to reach his definitely less ambitious concrete goals.

Yeah he made the electric car popular, but it can be argued that in order to make his company economically viable he basically lied to his investors and customers about self driving cars for almost a decade, when he had nothing real in his hands. Thanks to those promises he got the money to keep the company afloat until it had the manufacturing capability to actually deliver the cars they sold; and someone may argue he would have failed if he had been honest from the beginning, and that maybe people wouldn't have invested the money they did if he hadn't set unachievable goals to begin with

And this is a pattern you can see in all of his companies; he promises the world Mars, gets a lot of funding and then instead of delivering on the "dream" target, he uses the money to deliver a valid but definitely less "romantic" product he can actually sell. One time is ok, but it's basically a modus operandi now. And this gives me a strong suspicion that the product was the real goal all along, and he knew he had to lie about the "dream" in order to get the capital at all

well, in Musk's defence he's been selling BS to people for the better part of the last three decades and people are still giving him money, so...

Very cool project!

Web interfaces are fine for advanced users, but they suck for "standard" users. VMs are hard enough to understand for your average user; the more your UI looks like VirtualBox or VMWare the better

That requires a bit of hacking in general, it's not that easy to achieve that with closed source OSes. Windows supports that via RDP, btw.

Windows implements and X11 _server_ (the client in X11 jargon is the app, which if remote works on a remote server - yeah it's confusing. You can have the X11 server on a thin client showing data from an X11 client running on a remote server). They also added Wayland support, too.

GNOME has great software, nice UI, horrible UX. It's like as if the designers actively tried to make their software as opinionated and as castrated as they physically could

It's not that simple to do a bounty program, my uninformed guess is that they are almost definitely targeting a number of jurisdictions whose laws are familiar with and/or they have some kind of representive in

Finally! This is just shy of being 10 years late though. Lots of people would basically stop buying laptops with something like this on their phones (and that's why Apple will never do it)

I don't know, AI seems quite antithetical to what Duolingo supposedly stands for. AI raison d'etre is to allow people to do stuff they cannot do themselves or replace human skill with automated processes. Duolingo literally sells language courses, in a world where translation jobs are getting less and less necessary thanks to AI being especially great at translating stuff.

Also "AI first" is BS, until AI has a 100% accuracy it is only useful as long as there are still competent people around that are able to understand what the AI does. A level of competence that gets harder and harder to get in a world where AI assistants allow you to get by by just pressing enter and producing poor quality slop.

Companies and management want to _replace_ human labour because just they don't understand that AI works best _alongside_ people. This doesn't surprise me; one of the worst problems in IT right now is that IT is both pervasive and extraordinarily sector-specific. Capital is in the hands of people that not only don't understand how IT and computers work in detail, but don't even understand how little they understand in the first place

It depends on the country or area unfortunately

This is nice and all, but the main issue with UB and C++ IMHO has never been that "nice", modern codebases are problematic - modern C++ in the hands of competent people is very nice, really. The problem is that 90% of all C++ development ATM is done either on legacy codebases full of ancient crap or with old frameworks and libraries that spam non-standard containers, raw pointers, allocate manually, ...

In my experience, introducing modern C++ in a legacy codebase is not that much easier compared to adding Rust to it. It's probably safe to argue that C++03 stands to C++26 almost like K&R C stood to the original C++

This is awesome. IMHO the Windows 2000 UI was the pinnacle of UX, it's still unmatched to this day. I'd love to see the SerenityOS UI ported on Linux+Wayland someday.

Most cities in North America built in the XX century were deliberately built with the car in mind. The suburb doesn't make sense without cars, unless of course you have a very good local train network (which in the USA is almost close to impossible to find nowadays). You can see the opposite issue in Europe, too: very old cities are a nightmare to travel in a car, my city has existed for >2000 years and because of that the city centre has a lot of roads that only make sense if you expect most people to walk or at most ride a horse

I know, but it's not incredibly hard to work with them to be fair. People have been mixing C and C++ for decades now, we know where the sharp edges are pretty well

Or rather, given that every relevant C compiler is also a c++ compiler, just compile as c++ and use std::unique_ptr? I love C but I just can't understand the mental gymnastics of people that prefer this kind of hacks compared to just using C++

I just can't wrap my head around tiling WMs (and I've been doing Linux since a _long_ time ago). I just don't see how usable they can be when you have a "small" screen to be honest.

It's a bit naive to expect US bases in Europe to still be there in the next 20 years. First, Trump clearly wants to pull out of Europe, because the current Republican party has basically no interest in Europe whatsoever (and it may even be seen as an enemy by them - it's the embodiment of all the "social state" fears they harbour). Second, if the US stop cooperating with the EU on security and forces Europe to rearm, they would probably become redundant and an easy target for populist movements - especially when Trump is out and will be replaced by a less appealing figure. Meloni, ... won't be able to sell Trump as a role model to their voters for long if he really plans on fucking up the European economy; if there's little to be gained it's easier for populists and nationalist in general to just paint him as an enemy.

As a European there's been a lingering feeling of anti-Americanism in Europe that's been somewhat dormant for the last 30 years. It's clearly awakening now, and it risks going mainstream too, which would basically make the position of US bases untenable unless there's a direct reward for them (like, having security guarantees)

Good, reliable ways to do hole punching were not available until relatively late (STUN, ICE) and were somewhat finicky for a long time, especially on crappy routers.

Also, multiple levels of nat are unfortunately common and make STUN unreliable

I think that NAT is a major reason why P2P and self hosting failed to take off in any significant way. I think that the internet would have been a wildly different place were IPv6 widespread in the early '00s.

So it's not a Clang regression per se, it's an issue with the LLVM core? Clang is just a frontend, and Rust AFAIK does not use it at all. If you run LLVM 18's `opt` on bytecode generated by Clang 19 and then compile it, does it also generate the same bad assembly?

> the readability and aesthetics of Rust code

I've been writing C/C++ code for the last 16 years and I think a lot of mental gymnastics is required in order to call C "more readable" than Rust. C syntax is only "logical" and "readable" because people have been writing it for the last 60 years, most of it is literally random hacks made due to constraints ({ instead of [ because they thought that array would be more common than blocks, types in front of variables because C is just B with types, wonky pointer syntax, ...). It's like claiming that English spelling is "rational" and "obvious" only because it's the only language you know IMHO.

Rust sure has more features but it also way more regular and less quirky. And it has real macros, instead of insane text replacement, every C project over 10k lines I've worked on has ALWAYS had some insane macro magic. The Linux kernel itself is full of function-like macros that do any sort of magic due to C not having any way to run code at compile-time at all.

mutable global variables are intrinsically incompatible with a multithreaded environment. Having mutable shared state is never the right solution, unless you basically can live with data races. And that's before taking maintainability in consideration too

So basically doing the same at runtime for the last 55 years was somewhat OK?

C++20's concepts IMHO are a massive update over C++11. You can basically remove almost 90% of inheritance with them without incurring in any issue (you could do that earlier too, but at the expense of incredibly hard to read error messages - now that's basically solved thanks to concepts).

> Qt

That's EGLFS, it's used quite a bit in automotive AFAIK. It's slowly getting replaced by Wayland and Weston though.

GUI git clients are amazing in the hands of expert users, but terrible for any newcomer that has to actually use Git (and it's not like a designer checking out the source once or twice a month).

The gripe I have is that unless you expose people to CLIs early on, they will just not learn how to use a CLI at all. Whenever something inevitably breaks badly due to GUIs abstracting away how git really works in favour of a nicer UX, they'll end up asking someone that know Git how to fix their mess. And then, it's too late - they already know how to be productive-ish with git and how to deliver something. They can't justify investing time into learning the CLI (especially if they're not that great with Powershell or UNIX shells) so they constantly keep leaning on a colleague instead of learning.

This is not an hypothetical scenario - this really happened regularly at a place I worked at. Innumerable internal training lessons on Git went wasted due to people forgetting everything immediately by using Fork instead of the shell, and then pestering a handful of senior devs. Once IT banned Fork people were forced to use the terminal more often, so they had to learn how to use git for good and actually retained that knowledge via muscle memory.

The adage I've learnt over the course of the years is that the majority of people will go to any length to avoid learning new stuff. It's mentally less tiring to either waste their time doing stuff in an unproductive way than learning new things. IMHO it's better to force people to learn stuff the "right way" early on than let them pick up bad habits and then having to correct them later.

As a decade-long user and as a professional C++ developer, I'm so happy they've managed to successfully port the shell to Rust. While I have a lot of fun writing C++ (and Rust), I must admit that Rust is vastly nicer to use.

People can complain as much as they want about the borrow checker, but you basically have to be as strict as Rust is in C++ if you want to really avoid use-after-free issues, ... I've been writing "Rusty C++" since before Rust was a thing, because that's the only sane approach to memory safety. I'd rather have a program check that I don't fumble up instead of running sanitizers when things go awry (often years later). The best bug is a bug that can't happen at all.

Static analyzers are sadly too limited compared to what a borrow checker can do in my experience. Some bad stuff will always slip in in C/C++.

I still do LAN parties every once in a while with a group of friends. Meeting in the same room with laptops and bulky desktop PCs to play old 00s games is still a lot of fun!