@Lensflare I also would like to know why submodules are a bad idea for development, I'm considering using them

I rewrote the request-notify duplex comm primitive on top of it, it works well, and testing is a bliss

And that's a stepping stone laid.

https://crates.io/crates/...

I'm excited because this should pave the road towards testing some important and complex subcomponents, not even considering how it will enable dylib plugins.

@retoor no deadlock I just messed up the test because I thought an i32 was 8 bytes. It works fine as best I can tell.

@retoor I extracted it and wrote a nice test scaffold with random sized reads and writes:

https://git.lbfalvy.com/Orchid/...

There's a deadlock in it somewhere but I cannot for the life of me figure out where, this has me wondering if there's a rule about futures that I didn't learn right that's causing all these weird deadlocks in Orchid as well.

This is pretty solid but not nearly sufficient testing, I want to try some weird scenarios with flushing and closing as well once this one passes, and probably a benchmark for the use-case of a sequence of many small writes of varying sizes followed by a sequence of matching sized reads, because this is how Orchid and I imagine most real-world binary protocols use their channels.

to begin with, a non-thread-safe ringbuffer pretty much only makes sense if your architectural decisions are as weird as mine.

@retoor I'm not sure what kind of projects @BlindXfish is expecting us to upload, and this is purely a vibes-based assertion, but it seems very visual with all the cards and stuff so I'm guessing that a non-thread-safe async binary-safe ringbuffer library for Rust probably doesn't fit very well.

@whimsical It's actually moved, https://devplace.net now works and it's probably better if we link to that one (although I've no idea whether pagerank is still worth anything)

@Lensflare i mean you have to be a _little bit_ smart about it, but just blasting through all 1M combinations of 1000 coordinate triads with a loop is more than feasible. If you avoid expensive operations in the loop, it's indeed a couple of seconds in a compiled language.

@Lensflare I avoid bruteforce solutions in AoC even when they're possible because I think they're boring.

@Lensflare I realized day of that this would be bruteforceable in Rust and probably manageable with just 5x5x5 chunks in Python even, but I think this solution is fun so I'm sticking to it.

@TrayKnots you gotta submit part 1 to get part 2. The idea is that part 2 is usually a more complex form of the problem that you shouldn't plan for when you come up with the simpler strategy for part 1.

Still building an octree for day 8. If I accomplish nothing else for the rest of AoC but finish this, it will have been worthwhile.

AI generating a rant is weird and sad

but whatever really, it's not like most of us here are normal or happy

General purpose large scale competitions are stupid. Who's the best singer in Europe is a dumb question. Who can do the best aria of the night queen or the best death growl may be interesting questions, but a general purpose judge is ill equipped to judge either.

I mean, if people want to watch this crap then go right ahead, but let's all recognize that from the very principle it's purely a competition of tastes and not a competition of talent because talent doesn't compare across genres. No wonder then that it attracts party politics and flag-waving rather than meaningful conversations about social issues.

@BordedDev I used Itertools::coalesce, my absolute favourite iterator adapter, and indeed one of my favourite functions from any library. sort > coalesce > fold did it just fine. I just made an error in the coalescing (coalescence?) callback.

On the other hand, 5b can bite dirt, it took way too long and it was fully my fault. Range sequence processing has just a few too many cases to remember to handle all of them.

Actually, it would be less error prone to support pulling a codepoint by a single index, because the default workaround people go for is &str[i..i+1] which panics on non-ASCII whereas the &str returned by &str[i] could be a single multiwide char.

It actually bothers me a lot that Rust is so insistent on avoiding positions in the string API. I get how it encourages correct string handling, but there's no rule that says &str[usize] can't return &str just because &str[usize..usize] returns &str.

Custom parsing isn't bad, very often you can cut AoC tasks in half if you do the parsing in a slightly clever way.

I took the index range from one operator char to the next, read through that index in each previous line from top to bottom, skipped spaces, and folded up each digit d by 10*x+d

not only is this a garbage take, the logic doesn't even check out internally.

some laws are morality put into writing =/=> legality is morality

Not even gonna engage with whether the first one is true, very basic knowledge about any form of governance that ever existed would tell you why it isn't, so even suggesting that it is tells me that the state is a sort of opaque black justice box to you.

@12bitfloat Well. I kinda assumed that the compiler would recognize many cases where the Rc is guaranteed to have other copies and generate a decrement. Actually, why is a heavy branch so important if it's not taken anyway?

I use Rc but that's because I don't want to care about memory management. If I did, for sure I would use arenas (and investigate whether pointers are actually a good choice while I'm at it, Zig had some interesting findings about that)

This is an incredibly cool project, but why GC in a compiler? It's like the perfect example of a short-running multi-stage compute-heavy task, one you should back with a set of arenas for each stage if you want to pay attention to memory management at all.

3 years in Java, 5 years in Script.

Familiarity with ECMA is a plus.

the only way this makes sense is if you think AGI will save you from utter domination by both state and capital once you start using it for something significant, and also that you can amass enough of a technological edge to have exclusive access to the technology for a useful amount of time. So, how would you use your extremely limited time window if you did manage to create AGI?

aye that's the one

There's a pretty cool youtube vid I can never find when I want to, that shows what a basic rendered city scene would look like if light speed was 1m/s. I think I would notice pretty quickly because things gain weird geometry and colours when I'm on a train going 10% the speed of light.

it _shouldn't_ deadlock, destructors are guaranteed in Rust and Tokio also has a fair scheduling liveness guarantee to ensure that eventually the forked future will run, but this technique of forking from a destructor has been a major source of bugs in the past because it's literally impossible to tell when they actually run. Currently destructor safety is guaranteed by blocking on these loose references before exit and relying on Tokio's liveness guarantee for them to be freed quickly since nothing else is happening.