Maybe people mean GenAI. Back then, AI meant stuff like computer algebra systems like Macsyma which produce deterministic, provably correct results. I'm totally OK with that kind of AI. What I don't like are probabilistic text generators getting shoved into absolutely everything.

Great video, thanks for the link!

Many language learning books used to come with audio media. I'm old enough to own a few that came with cassette tapes.

Books are still worthwhile IMO, if only because they provide a bit of structure to one's learning. With free resources it's way too easy to become paralyzed by choice.

I am old enough to remember them. Comparably, you got maybe 4 hours of media - meaning sentences from the book being read and short boring dialogs. You cant compare it to what is currently available. It is like comparing a puddle of mud to Atlantic Ocean. And I mean it in a positive way - those audio tapes were almost nothing comparably.

Beyond projects like Dreaming Spanish, you have around infinite amount of French, Italian, Spanish or German Youtube about whatever topic you want to. There are even dedicated playlists for total beginners you can start to consume with zero knowledge. You have thousands of shows on Netflix in foreign language with various difficulty - some actually suitable for beginners. Some you have already seen in own language, so you can understand them more easily.

For major languages, there are dozens if not hundreds of podcasts with simplified news, "for beginner" discussions. Some of them are useable with literally miniscule amount of knowledge.

First example doesn't look bad in C++23:

    auto get_ids(std::span<const Widget> data)
    {
        return data
            | filter(&Widget::alive)
            | transform(&Widget::id)
            | to<std::vector>();
    }

To me, the cool (and uncommon in other languages' standard libraries) part about C++ ranges is that they reify pipelines so that you can cut and paste them into variables, like so:

    auto get_ids(std::span<const Widget> data)
    {
        auto pipeline = filter(&Widget::alive) | transform(&Widget::id);
        auto sink = to<std::vector>();
        return data | pipeline | sink;
    }

This looks awesome!

I'm really want to start playing with some C++23 in the future.

I cheated a bit, I omitted the namespaces. Here's a working version: https://godbolt.org/z/1rE9o3Y95

This is not functionally different from operator<< which std::cout has taught us is a neat trick but generally a bad idea.

Unlike the iostreams shift operators, the ranges pipe operator isn't stateful.

There's state when you try to use the final result, though. It's not threadsafe due to caching.

https://www.youtube.com/watch?v=c1gfbbE2zts

> The websites I run generally have a honeypot page which is linked in the headers and disallowed to everyone in the robots.txt, and if an IP visits that page, they get added to a blocklist which simply drops their connections without response for 24 hours.

I love this idea!

Yeah, this is elegant as fuck.

Also, x86 has an instruction that multiplies two 32-bit registers and stores the 64-bit result in two 32-bit registers. So you get the result of the division in the register with the high part of the multiplication result, and don't need to do a shift.

Same as Strava, now it has a completely pointless AI assistant.

Hey, I've seen some of your IOCCC entries. Even had some fun trying to understand them back in the day.

IOCCC gang rise up. This is mine: https://www.ioccc.org/years.html#2005_persano

Somehow, I have a rather small one: https://www.ioccc.org/2012/kang/kang.c

I think I have submitted once or twice before that got won, and all other entries were excessively long to be honest. Guess a conciseness is a virtue.

> Guess a conciseness is a virtue.

Indeed; quoting from my winning entry [1] that same year:

> This program celebrates the close connection between obfuscation and conciseness, by implementing the most concise language known, Binary Lambda Calculus (BLC).

> The submission implements the universal machine in the most concise manner conceivable.

[1] https://www.ioccc.org/2012/tromp/hint.html

Also relevant: https://en.wikipedia.org/wiki/Moravec%27s_paradox

There's a nice recreation on Shadertoy:

https://www.shadertoy.com/view/lstSRS

No idea if it's doing the same simulation though.

So beautiful, thanks for sharing.