They are not. Turbine engines require much higher quality manufacturing and tolerances and operate at much higher speeds and pressures. There is more to it than the perceived number of moving parts.
Katee Sackhoff did an interview with Ron Moore on her podcast, and one of the topics they discussed was how they would write the "technobabble" in Star Trek (and BSG). Moore said they would write the script and just say things like "they tech the tech with the tech until it techs" and then fill in the actual technobabble words later!
My go to analogy is that conservatives will underfund the assembly of a car, deliver a car that only has two wheels that are both the wrong size, and then say "See? Cars will never work!"
I think it is amazing that in a country as "exceptional" as the US, the answer to "Why can't we provide affordable and accessible healthcare to everyone?" is "We are going deport liberal scum like you".
It switches the detection range, but not the actual power supply. You can ramp from <5 uA up to 500 mA and back all you want. I haven't noticed any glitching on the actual supply.
It really seems like it has to be something like that. The problem is there is no detail in the docs and no status bits in the chip. There's no way to know when the auto-cal runs.
One of the several things I did to eliminate the problem was to disable the auto-cal during a UART reception (the STM32 is the bus master so it knows when it will be receiving) and re-enable it when it is finished. It absolutely confirmed that is the glitch, but I don't think I'll ever get a true why unless an ST engineer wants to chime in!
This is a good resource, however, it didn't apply in my situation because it describes the manual calibration process, not the auto-cal (which the F0 probably doesn't even have).
I still haven't come across anything that explains in detail how the auto-cal works and precautions one needs to take when it is running. The reference manual section is something like one paragraph and can be summarized as:
"You can turn this on and it will calibrate your clock. You can also turn it off."
If I had to guess, it probably does something similar to the manual process, but just in the MCU logic. It's the lack of detail that got me: I basically ran out of things to try on the UART itself and started looking around at other parts of the chip to see what could at least be indirectly related.
My guess is that the receiver clock glitches in some way when the MSI auto calibration runs, but it never showed up on the transmitter (and the device on the other side of the connection has never had a reception issue).
I ended up disabling the auto cal feature during a UART reception and then turning it back on when the reception is done.
SPI is definitely better as far as clocking, but MCU support as a SPI receiver is sometimes a lot less convenient to deal with.
A lot of UARTs have a synchronous mode which adds a dedicated clock signal - I've used that before out to a couple MHz.
In this application though, I'm only running 1 MHz so I really didn't think I should need a separate clock (and, it turns out, still don't).
The GIL is not there to prevent data corruption on shared objects - it only protects the interpreter's internal state. The fact that sometimes you can get away with it is an accident of the GIL's implementation, not a feature anyone should rely on. It also means that you cannot rely on that behavior not to change on a successive versions of CPython.
The only safe way to do shared state between threads in CPython is locks/mutexes/message passing/etc. Even things like a simple addition to an integer are absolutely not made thread safe by the GIL.
There are TNG episodes that specifically deal with that, and the problems it causes. I think ENT had a few as well, instances which led them to the creation of the Prime Directive.
Mars isn't happening, at least not on his watch.