In no particular order: the early-game shooting mechanics that make you wonder how Shepard ever got out of basic training, the ludicrously overpowered biotics that, once leveled up, can basically be rotated to permastun enemies, the Mako driving controls and physics, RNG equipment upgrades that make it difficult to get meaningful late-game armor upgrades without save scumming, the fact that every indoor environment outside the main hubs uses one of three maps with different props all come immediately to mind.
Note that the Legendary Edition addressed a couple of these, specificially the shooter mechanics and Mako controls.
With that said, ME1 is one of my favorite games of all time, warts and all, and despite the fact that I didn't get into the series until after Andromeda released, it's probably one of my most-played, as well, with at least one 100% Insanity run on every character class (with at least one per class carried through ME2 and ME3).
Ruby has the reputation of being a very slow language, but Python has been slower still since Ruby jumped ahead with version 1.9, almost 20 years ago. Ruby also has had far more success with JIT compilers than Python has.
>Ruby also has had far more success with JIT compilers than Python has.
Ruby is on its third (I think?) JIT now? I'm a little surprised, given Ruby's reputation as a wacky "anything goes" language with a very complex grammar, and it makes me wonder why that is? Does it have to do with the design of the runtime itself more than the language semantics? Or is it more incidental, e.g. many popular ibs are C wrappers, already generates bytecode files, and so on.
The difference is that Ruby follow the BDFL model, and Ruby's BDFL was willing to allow people to experiment with in-tree development of JITs.
If the Python steering committee isn't willing to do the same, they'll probably won't get a working JIT any time soon. Developing a JIT externally, or even from a branch, is just too hard.
Getting a JIT right is hard work because time spent by the JIT is time not spent doing actual work, and finding the correct tradeoffs is very much an empirical problem.
> Unladen Swallow died for lack of upstream interest
IIRC Unladen Swallow was, despite the extreme hype, nothing more than the internship project of a couple of students. It died because their internship was over.
Otherwise you're right, though. Lots of CPython alternatives suffer from lack of upstream interest - the Python language designers don't seem very interested in anything other than CPython. In particular, they appear to only consider CPython when adding features to the language. Two examples:
- Requiring `dict`s to be ordered because that's how they work in CPython, without considering how they work in other implementations
- Adding pattern matching syntax that's suitable for CPython's PEG parser, even though it's not LL(1) so can't be parsed by, say, MicroPython
> we don't feel we have the personal bandwidth to carry the current version forward
Are the JIT developers the same people who were working on Faster CPython at Microsoft? No surprise that they don't have the same amount of energy to dedicate to the JIT now that it's gone from a full-time job to a hobby project.
Surprising, even though (IIRC) the performance of the JIT was always fairly underwhelming.
What about the other major change to Python's implementation: free threading? Has it lived up to expectations? I assume it's not also in doubt, despite Guido recently saying "Personally I wish we’d stuck with the GIL"? [0]
Getting a JIT from underwhelming to actually good is always going to be a whole lot of iterative work to remove blocking parts of the existing implementation. In Ruby-land we have had a good JIT for a while now, but it took many release cycles and a ton of resources before it was able to outperform the non JITed version when using Rails. Don't expect quick fixes that make great strides and any investments in it needs to be persistent and apply over time.
It boggles my mind that it apparently is the case that such a popular language as Python isn't able to get the resources to do this.
It is more than that. CRuby have had multiple JIT attempt before YJIT landed. From what I can tell CPython didn't have that. And luckily enough we now have ZJIT replacing YJIT.
It is unfortunate it didn't stick with it. I suppose that's why Go emerged, as that was also its claim to fame with the added benefit of seeing what happens to that principle when you try to chase every fad.
What difference does AI make? Teal simply gives you the option to add static types to your Lua code, to enable additional compile-time correctness checks.
Surely that’s useful, no matter whether you’re writing the code yourself or having an agent do it.
I was trying to find the song “Lobachevsky” by Tom Lehrer, but had forgotten both the title and the artist. So I searched for something like “plagiarism song”.
Google told me it was unwilling to help me violate copyright law
This looks like a really thorough examination of async-await i.e. stackless coroutines, but it doesn’t seem to cover Lua-like stackful coroutines.
Apologies if it does and I’ve glanced over it - but if it doesn’t, is there another resource that compares stackful coroutines to stackless in a similar way?
Stackful coroutines are cooperatively scheduled, unlike traditional threads, and context switch much more inexpensively. It is the reason people write stackful coroutine libraries instead of just using threads.
Specifically, I didn’t find the gameplay of ME2 to be much better (and in some places, e.g. the Probing Uranus minigame, it was worse).
reply