Start with the core gameplay loop. Look for the fun. Look for what you can take out, not add.

Play-testing something like this with pencil and paper first might be a good idea. Once you work out why it always plays the same way, then you can look for how to perturb the gameplay.

It won’t (using your example explicitly) but in general what you’ve discovered is that:

1. Variables hold values
2. Some of those values are references to shared mutable objects.

Lists fall into the second category. There are ways to copy lists if you want distinct behaviour.

list2 = list1[:]

will perform a “shallow copy”. If you have a list of lists, however, the nested lists are still shared references. There is copy.deepcopy available to make a complete clone of something (including all its nested members).

Yeah, a more modern take on mutexes (as boxes for values) and support for structured concurrency would be fabulous. Those are somewhat orthogonal to the goal of being able to write straight-line code without function colouring. Long ago, eventlet provided something like this [although it had smoe subtle and deep bugs that took a long time to track down].

Potentially, a major stumbling-block would be providing machinery so that interleaved FFI & python calls can cooperate (if that’s determined as being in-scope, which it ultimately should be).

The writer is not wrong about the awful ergonomics of having to deal with async. Project Loom took a long time to land but it really demonstrates how to do this kind of thing right.

Spot on, yeah. Although as pointed out just above, this wasn’t actually Weizenbaum’s position. But in an era of letters to the editor, perhaps using a little rhetorical trickery to preempt a two-month-long back and forth might be excusable. It’s a strawman nonetheless; but this letter is a screed.

Having said that, that this is the kind of thing Altman might say unironically speaks volumes. He really does have a trillion-dollar monorail to sell.

I suspect he got asked it a lot. There was a lot of interesting work going on back then but people basically didn’t have any notion that there was a path from there to any kind of AGI. (In that respect they might’ve been somewhat more clued up than Altman.)

I think it’s a natural thing to preemptively defend against the obvious counterpoint when you’re railing against the thesis that current AI work isn’t going to deliver on the “I”.

It’s sarcasm. The question asks for unwarranted precision and the response is a joke.

You sound angry. Take a breath and grow up.

How is that checker configured?

It might be doing something like this:

import student_module
student_module.main()

and because you’re already invoking main as the module is imported, it’s getting stuck the second time around. Maybe add some indicative print at the entrypoint to your main function.

Another reply in here has supplied the standard idiom for making a module executable:

if __name__ == "__main__":
  main()