I use the "Unhook" Firefox extension to customize the YouTube page. You can hide shorts, comments, recommendations, the home page feed, and more.

https://unhook.app/

A post about big-endian testing with QEMU was posted on HN just a few days ago:

https://news.ycombinator.com/item?id=47626462

https://www.hanshq.net/big-endian-qemu.html

Clang’s C++2c implementation status page simply says “no” for both reflection and contracts. GCC’s says “yes”.

https://clang.llvm.org/cxx_status.html

https://gcc.gnu.org/projects/cxx-status.html

That much I'm aware, but that's just about feature availability. I was wondering how far the implementations have progressed internally, despite the features being unavailable.

Clang basically doesn't implement anything regarding reflection right now. There is some support for parsing (https://github.com/llvm/llvm-project/blob/main/clang/test/Pa...) but that's it. There are some open PRs for other parts though.

Thanks, yeah, I was worried that might be the case. Given how complicated these features sound, it makes me wonder if they're gonna finish before the decade is over...

Tell us about your concrete experience of development in Perl.

'x' is an operator

OpenCode's creator acknowledged that the ease of shipping has let them ship prototype features that probably weren't worth shipping and that they need to invest more time cleaning up and fixing things.

https://x.com/thdxr/status/2031377117007454421

Uff. This is exactly what Casey Muratori and his friend was talking about in of their more recent podcast. Features that would never get implemented because of time constraints now do thanks to LLMs and now they have a huge codebase to maintain

Not terrible if they proactively depricate slop features

What to release > What to build > Build anything faster

Well that's good to hear, maybe they'll improve moving forward on the release aspect at least.

I was curious why some expressions in the code used the character ù, such as “If Zù500”. It looks like a character encoding error, but the code presumably works correctly. ChatGPT says the byte value for ≤ in TI-BASIC is the same as ù in ANSI/Windows-1252 (0xF9).

Looks like LLMs also find Dafny easier to write than Lean. This study, “A benchmark for vericoding: formally verified program synthesis”, reports:

> We present and test the largest benchmark for vericoding, LLM-generation of formally verified code from formal specifications … We find vericoding success rates of 27% in Lean, 44% in Verus/Rust and 82% in Dafny using off-the-shelf LLMs.

https://arxiv.org/html/2509.22908v1

Not surprising, as Dafny is a bit less expressive (refinement instead of dependent types) and therefore easier to write. IMHO, it hits a very nice sweet spot. The disadvantage of Dafny is the lack of manual tactics to prove things when SAT/SMT automation fails. But this is getting fixed.

And they can get “too build to fail” bailouts from the US government after they are dependent on ChatGPT.

Good PR for Anthropic: the DoD already has contracts with OpenAI and xAI, but is still so eager to use Claude that they must threaten Anthropic.

> Version two: hide foes?

That's a good idea.

Here's my bad idea: the extension auto downvotes foes and auto upvotes friends. :)

automations get your account in trouble, it's against the rules

It already happens today