This would be pretty terrible if anyone actually cared about DNSSEC, but luckily for us, no one cares.. So let's keep things this way.

And things only gotten better since - we now have CT logs, and browsers require them, so any mis-issuance can be detected automatically, by any interested third party.

If we go to DANE, we lose this all. "Oops, our CT uploader process failed, we will fix Real Soon(tm) we promise" - and what are browsers going to do? Distrust the entire country?

[0] https://blog.mozilla.org/security/2011/09/02/diginotar-remov...

With all the problems with Web PKI, at least the bad actors are getting distrusted, and this provides a very strong enforcement on the rest. And Certificate Transparency makes sure the mis-issuance would be caught. It is not perfect by any means, but things are getting better.

With DANE (or other country-issued certificates), every government will absolutely double-issue certificates to police, secret service and friends of goverment, and no one will have any recourse. (In the past I'd say that only countries like Russia would do it.. but with today's climate, I am sure both US and many European countries will do that too)

Thank eletrek for converting information yo a much faster to comprehend form!

A matrix multiply seems much easier than neural networks, mutation, genetic operations - and still have much higher Φ.

[0] https://scottaaronson.blog/?p=1799

The screenshots have broken X axis, and the hyperlinks are not highlighted.

Sadly many security teams are just theater, introducing inconvenience without any tangible benefits. They will happily harass developers for having a CVE in the _internal documentaion tool_ which gets nowhere close to untrusted input, but at the same time will happily approve internal tool which keeps the credentials in a plain-text file and would recommend that tool to everyone.

> No automated test suite — verify by running the browser.

> No code comments beyond one header line per file

Those would be completely cached/pre-rendered, so the cost would be very low and there will be no potential for abuse. And yet the visitors could at least get some idea about the quality of your search engine.

URL parsers don't break, the amount of code to change is not that big, and many of the user-space applications can keep working with no changes at all, as long as they use high-level network libraries.

If you really hate this for some reason, use some other characters. How about underscores (_) for example? Those are not valid in DNS, so there is no chance of confusion.

Choosing colon when URLs were already using it is either very stupid or very mean.

     function make_widget(parent& x):
       w = new Widget()
       x.children.add(w)

If this one is too easy, make function return "w" as well, or make it add a widget to two different lists

[0] https://docs.edera.dev/technical-overview/architecture/kvm/

But seriously, those "payment required for smart toothbrush" laments are getting old. Yes, there are people who will happily sell you a smart toothbrush which requires payment. But there are also very good non-smart toothbrushes which need neither payment nor the internet! If you got a smart toothbrush for some reason and don't want to pay, then throw it away and get a dumb one. And if you are getting value of the internet connection, then go use it and stop complaining.

This goes for many other things - if you don't want to pay google to store screenshots, delete them, the button is right there. If your playlist is "20 songs on repeat" , Amazon sells unlocked MP3's now for $1.29, buy them and organize them like we used to. If you don't want to pay hosting provider, self-host.

(There are some cases where subscription is the only choice, but that's not what this post talks about)

Saying "using RAII for memory management" is insufficient - with just RAII, you cannot even assign a class into a passed-in variable. The language designer _must_ make make more choices to get a useful language - maybe affine types, or linear types, or prohibit many C++-like idioms, or maybe just good-old refcounted shared pointers (but I'd argue this is a form of GC...)

> Ü is memory-safe and race-condition-safe, as long as no unsafe code is involved at all or as long as unsafe code is correctly written.

How is this achieved? The docs mention in passing that there is some sort of thread-safe immutable structs, but it is not really clear what's the overall picture and how they interact with non-trivial code. And the examples have nothing on thread.

Go to website like https://hackaday.com and there will be plenty of projects like those. (Although this one is more complex than usual, so you might have to lookover a few months' worth of history to find something on that level)