Wow, I didn’t know that! That’s absolutely wild

… The root of the thread you’re replying’s main body is stuff JSO has actually achieved.

I’m assuming this is referring to JSO.

https://en.m.wikipedia.org/wiki/Just_Stop_Oil

Beginning on 1 April, they carried out England-wide blockades of ten critical oil facilities, intending to cut off the supply of petrol to South East England.[33][34][35]

On 26 August, the group blocked seven petrol stations in Central London and vandalised fuel pumps. Forty-three people around London were arrested on suspicion of criminal damage.

On 20 June, the protestors spray painted private jets at a private airfield at Stansted Airport. The group had been targeting a jet belonging to singer Taylor Swift, but could not locate it.[140]

Yes, a lot of their protests are “awareness” stuff (basically none of which do actual damage. Unlike oil, actually!). No, it’s not just that. The UK isn’t an active warzone so bombing stuff is slightly more difficult to justify.

Ahh, that makes sense. Powers of two are real convenient. Your math is a little wrong though: X != (X & 0xFF) + (X >> 8), but X = (X & 0xFF) + (X >> 8) << 8 The right half can be removed entirely if you’re doing modulo 16, since the first 4 bits will always be 0. So it simply becomes X & 15! Much cleaner for sure.

Would you happen to remember what the optimization was, mathematically?

https://stackoverflow.com/questions/20036698/subdivide-a-modulo-function-16-bit-but-can-only-do-8-bits-at-a-time#20036828 seems to say that it’s “impossible afaik”, and I can’t seem to optimize it myself (though this kind of math isn’t my forte)

As far as I know Switzerland only had one and we call it the Sonderbund war

Also, the reason this is a CVE is because Rust itself guarantees that calling commands doesn’t evaluate shell stuff (but this breaks that guarantee). As far as I know C/C++ makes no such guarantee whatsoever.

In general: non-intrusive, non-tracking ads, with robust verification (i.e. not scams or lies), such as the ones you find on https://modrinth.com, or duckduckgo

With adnauseam: https://github.com/dhowe/AdNauseam/wiki/FAQ#what-is-the-effs-do-not-track-standard-and-how-it-is-supported-in-adnauseam

The best part is that more ethical ads are harder to block, because trackers are one of the easiest ways to identify ads.

Hell, the adblocker I use (adnauseam) doesn’t block ethical ads by default.

Having read a significant portion of the base WASM spec, it’s really quite a beautiful format. It’s well designed, clear, and very agnostic.

I particularly like how sectioned it is, which allows different functions to be preloaded/parsed/whatever independently.

It’s not perfect by any means; I personally find it has too many instructions, and the block-based control flow is… strange. But it fills a great niche as a standard low-level isolated programming layer.

AI. Black guy in the background on the right has a white hand.

On the left the arms and legs are in very awkward positions too (the second guy has like… two left legs?)

Interesting! I’ll try that out!

Rust: https://codeberg.org/Sekoia/adventofcode/src/branch/main/src/y2023/day17.rs

WOW that took me forever. Completely forgot how to dijkstra’s and then struggled with the actual puzzle too. 1h20 total, but I was still top 1500, which I guess means most people really struggled with this, huh.

I went with a completely different approach:

! iterate over our string. Whenever you hit a non-empty, check if the next N are also possible to be a # (N being the first element of our sequence) and that the N+1th isn’t a #. If they are, we can truncate the first N+1, the first element of our sequence, and recurse. If you hit a #, you know that the first element has to start here at the latest, so you can break. With this method, memoization is enough to get part 2 down to 25 ms. To make the memoization more efficient you can also truncate all the way up to the next non-empty when recursing. !<

1. Setting up boilerplate beforehand, I only need to fill in the functions (and the return types)
2. Really good parsing library (aoc_parse). Today my entire parsing code was parser!(lines(repeat_sep(i64, " ")))
3. Iterators! Actually really ideal for AoC, where pipelines of data are really common. Today both the main part (sum of lines) and inner part (getting a vec of differences) can be done pretty easily through iterators

Today was pretty ideal for my setup. In general I think Rust is really good for later days, because the safety and explicitness make small mistakes rarer (like if you get an element from a HashMap that doesn’t exist, you don’t get a None later down the road (unless you want it, in which case it’s explicit), you get an exception where it happened.

I just really like Rust :3

Rank 148!! Even beat Leo Uino today!

Optimized: https://codeberg.org/Sekoia/adventofcode/src/branch/main/src/y2023/day9.rs

Less optimized, though not quite my initial version: https://codeberg.org/Sekoia/adventofcode/commit/72dfd77b92518aefd9dbe3e661885528f737f861

Thank you! That’s exactly the kinda thing I was looking for!

Friend and I are comparing times, but since he uses Jai, I can’t compile his.

One option could be to emulate a full CPU and run it on that, and count the cycles on that. One issue is linking/syscalls. Maybe compiling to smth like WASM could work?

Sure, but that makes a lot of optimizations nonexistent (e.g. cloning the input on an O(n) algorithm is “free”)