That's better than the games not being made in the first place because the Ministry of Culture deems it unimportant and puerile, which is what happens in Communism. You also can't have indies, because you can't publish anything without the state's approval, not to mention you also can't sell things for monetary gain.

I think 80-ish days to recompile and old binary is a much better alternative to the total death of human arts and innovation, and the unending list of crimes against humanity that Marx's theory has led to every time it has been applied.

But to keep it a bit more videogame related, Marx always reminds me of this speech by senator Armstrong of Metal Gear Rising: https://www.youtube.com/watch?v=IMpuUUV2HeE . "We will use an absolute totalitarian state to abolish the state" - a lofty goal turned into complete lunacy.

There was a lot of discussion around the time it was being removed[0], but it seems the glibc people simply didn't want the support burden and Emacs was the single user of that interface. I think the issues could have been resolved by checking if all shared libraries are exactly the same as when unexec was called, that the kernel is the same and that the CPU is the same, and failing if anything doesn't match, thus falling back on slow startup. That said, portably serialising the state and loading it back is a better solution IMO.

[0] https://lwn.net/Articles/673724/

If writing a GUI was as easy and stable as writing a TUI, yeah we should write more GUIs. I can run practically any ancient TUI program on a terminal emulator, but running a GUI program that uses an older version of GTK means going through dependency hell to compile and install all the old library versions. If they even compile with the new GCC... I really wish we had a standard way to spawn a webview (or similar) and connect stdin/out to it.

You could have also learned how to edit the saves to give yourself the radio :) . A tall ask of an 8-year-old of course, but not beyond the realm of possibility. Funny you mention Bennett Foddy's Getting Over It, because that's kind of how I "beat" it. After about 6 years of on and off attempts that always died around the church, I got fed up and edited the physics constants to make the game significantly easier. Since I used my own skill to hack the game and not an outside patch, I consider that "beating" the game in a sense.

I am now thinking if you can pull off an adventure game where some puzzles require editing the save file. It would be pretty tricky to make it understandable to most people. Now that I think about it, I wouldn't put it past Deltarune to eventually have an easter egg that can only be reached from a save state, which is impossible to achieve through normal gameplay. I know it doesn't have one right now, because all the scripts have been examined in depth and nothing like that was found.

I would suggest, without spoilers, that you go play the original Doki Doki literature club right now.

I did, but found it somewhat boring. Yes, I did get to the stuff you're thinking about, but personally it felt too forced. The game was trying to present itself as breaking the fourth wall in a way that is impossible with something built on Ren'Py. That is, I would say DDLC tries too hard and ends up stretching my suspension of disbelief past its breaking point.

Also, past the weird bits, there isn't anything there. I have no reason to care for these characters. It feels like a vertical slice of a longer game, or a proof of concept.

DDLC has a really cool idea that should be tried again, in a way that remains consistent within its game world, with more character depth and a longer story.

Some of them also had some cheat/debug commands you could get into. I know you could teleport to other screens, but I don't recall if you could use a command to get an item, particularly in PQ1. Or if there was a way to get back to the state you were in before that if you e.g. teleported to the station to pick up something and then tried to teleport back to the screen where you needed the item.

I remember I could not get the obscure nonsensical spells right in KQ3 but I could sort of skip past them to see most of the plot.

For me, cracking open the data for some castle adventure ascii character game was one of the first steps to being a real programmer.

I think I spent more time figuring out how the character save files worked in the original Bard's Tale CRPG than actually playing the game; I certainly made more progress with doing so!

Was this on DOS? "ASCII castle adventure game" brings back memories!

wave wand

i remember using a hex editor to edit save games to give me more in game money. felt like a hacker in a movie :)

Or the author could get in touch with GoG, who currently distribute several classic Sierra games. I'm sure they would be happy to offer patched versions.

It's more like legalized crack, it's almost never used for any remotely positive use

I like the idea, but I hate how verbose it is. Would be nice if there was also a macro that would transform all arithmetic within a block into algebraic arithmetic. The name is also a bit misleading, as I would expect "alebraic_add" to give an exact algebraic result, but instead it enables optimisations based on associative semantics.

As a sidenote, if implemented as a macro, e.g.

    fn fast_sum_f64(values: &[f64]) -> f64 {
        let mut total = 0;
        fp_opt!(associative, {
            for value in values {
                total += value;
            }
        });
        return total;
    }

A question arises what happens when operating on custom types that overload arithmetic operations. I think the cleanest approach here would be to let the custom type define optimised versions, or have another macro that automatically generates them based on the existing ones, i.e. propagate the optimisation flags.

You can create an `struct Algebraic<T>(pub T)` newtype that overloads operators using algebraic methods. In fact such wrapper might be added to std (it was discussed but decided that not yet. Such wrappers exist for wrapping and saturating arithmetic).

The "nuclear waste" argument is so weird to me. We take radioactive rocks from the ground. Make them less radioactive. Put them back in the ground. There is no output that wasn't dug up out of the ground originally. It would have been polluting the original location already.

It's a matter of concentration

Well no, the software should be configured in its best state by default. Otherwise you run into the case where the user has to read the documentation like a legal contract to find all the footguns that need disabling. If STRICT is strictly better, than that should be the default. The correct approach here would be for the user to pass along a "compatibility version" tag when first connecting, which would set the defaults to whatever was default in that version. That should be something you force each user to set in their source and it should never ever have a "latest" value. It may be too late for sqlite, but if I were designing an API that had to remain stable for decades now, I would put an enum with possible versions in a header and require the user to pick one.

> It may be too late for sqlite, but if I were designing an API that had to remain stable for decades now, I would put an enum with possible versions in a header and require the user to pick one.

I read an essay about XML once where the author noted that he got a warm feeling inside whenever he saw the opening tag:

    <?xml version="1.0">

He noted that there were no higher versions. (Though they're now up to 1.1.) But he considered that the inclusion of a version number from the beginning of the standard was a shining example of why they hadn't needed a new version.