Mateon1

The problem it's originally fixing is bad scrapers accessing dynamic site content that's expensive to produce, like trying to crawl all diffs in a git repo, or all mediawiki oldids. Now it's also used on mostly static content because it is effective vs scrapers that otherwise ignore robots.txt.

Several sites using cloudflare are partially down since just after 18:00Z. AO3_Status reports it's Cloudflare routing issues for IPv4 traffic. (but the Cloudflare status page reports nothing useful)

I'm using Windows on this laptop, this seems to affect all sites with any sort of Cloudflare protection, including Cloudflare's support and discourse sites, pubs.acs.org, and annoyingly some sites necessary for my current projects, that I need to access daily.

To clarify, this is the "Verifying your connection is secure" captcha before the site is even displayed, not a reCAPTCHA after the site is loaded.

I've tried clean browser profiles with no difference, on my normal profile I just use uBlock, Tree Style Tabs (FF)/Tabs Outliner (Chrome), and Tampermonkey for some sites (but not the ones affected by the captcha loop, in this case).

Seems to affect all sites, even cloudflare's own sites like http://community.cloudflare.com/ and https://support.cloudflare.com/, so I can't even report this directly to them without entering the captcha loop.

I mean, technically they have? Maybe not in this update, but they include local AI models for webpage translation. It's pretty useful (when it's a supported language pair, at least)

Yes, you'd just need to have a way to provide input (probably easiest as a demo file), and a machine big enough to simulate the pattern. You'd definitely be waiting for a while to see any action, though :P

If you're interested in dives that deep, you might like Gynvael Coldwind's hello world in Python on Windows dive [1]. Goes through CPython internals, Windows conhost, font rasterization, and GPU rendering, among others.

[1] https://gynvael.coldwind.pl/?id=754

The `single_ref` field is a fixed-size array in both of the objects referenced in this line, so this line can't panic, and no bounds checks are involved (since the compiler sees the index < length at compile time and doesn't even need to emit one -- although I think it still does, and it's LLVM that gets rid of it actually)

Causing memory leaks is possible in safe Rust even without any arcane invocations, you can construct a cycle of Rc<T> counted objects. There's even a perfectly safe Box::leak in the standard library that gives you a &'static reference to any object by leaking it. Preventing leaks is outside of the scope of Rust's safety system.

In my experience, if you have to build an older maven project, you have to go through a lot of painful hoops, mostly around HTTP vs HTTPS repos and java source/compiler versions. I have encountered many old projects that don't build out of the box, and of those, I've only managed to get about half working.

I went back and forth, both ways. I started out in Python with snake_case identifiers, then moved to Javascript with camelCase, and now I mostly use Rust with snake_case for names and UpperCamelCase for types.

I don't find either style better than the other, the only time I notice anything is when I switch between style conventions (e.g. switch between JS and Rust or C++), because I need to break the habit of typing one way rather than the other.

Still, I find readability of the two styles pretty much identical at all times once you get used to both.

I took a look at other days of your musical advent. I think my favorite is day 23.

Day 4 strongly reminds me of the True Lab music from the Undertale soundtrack [1].

[1] https://www.youtube.com/watch?v=y49b8aiQVBg - Undertale OST: 83 - Here We Are

Unfortunate that this project is only a partial reimplementation of QuickCheck. I was hoping that this would use fuzzing coverage.

Coverage guided QuickCheck has been on my mind for a while, I believe it would greatly improve fuzzing experience and allow to easily and thoughroughly check/fuzz things that aren't parsers/decoders/deserializers or functions that operate on strings in general.

BitTorrent isn't "not practical". It is however less practical than IPFS.

With IPFS, you can effortlessly link from one tree to another, already existing tree.

In BitTorrent, you have to include a .torrent file, or an infohash in some file, but no software that I know of will easily follow that link.

This linking ability is an extremely useful property, that allows you to cheaply create a copy of a merkle tree, with a subset of the data replaced. The tree will operate identically to one created from scratch.

You also don't need to hold all the data to "patch" the tree, which I imagine is useful in this Hadoop filesystem.

Unfortunately there is no real API for operating on torrents. You could say WebTorrent is pushing in the right direction to fix this, but there doesn't seem to be much adoption for it.

While I haven't looked for more info, I can assure you IPFS is a slower protocol than HDFS.

The existing IPFS implementation involves a lot of overhead in memory, CPU use, and latency [and as you can see in the MapReduce bar graph, it's slower], but overall, it improves performance when bandwidth is the bottleneck.

IPFS is pretty similar to BitTorrent, just more practical.

`let` is block scoped, while `var` is function scoped.

Essentially:

    function do_something() {
      if (true) {
        var x = 42;
        let y = 42;
      }
      console.log(x); // 42
      console.log(y); // Reference error: y is not defined
    }

    for (var i = 0; i < 5; i++) {
      setTimeout(function () { console.log(i); }); // => 5, 5, 5, 5, 5
    }

    for (let i = 0; i < 5; i++) {
      setTimeout(function () { console.log(i); }); // => 0, 1, 2, 3, 4
    }

Is this project open source?

Googling is ineffective due to an NES game called Mappy.

Recently I came across the NASA Astronomy Picture of the Day website[1], it's old-school HTML, started in 1995 and still updated today.

All the HTML takes 2-4 kB on average, but you might not get much use from the site in a terminal :)

[1] https://apod.nasa.gov/apod/archivepix.html

See how GNU units resolves this:

  1/10 m -> 0.1 / m
  1|10 m -> 0.1 m
  27 ^ 2/3 -> 243
  27 ^ 2|3 -> 9