is it a data race if I write a memory area over JTAG? it is, right? I think other people have mostly covered it, but I did want to try answer this directly: * If you modify a "normal" variable inside of a running rust program, e.g. something with a `&` or `&mut` active, or that is owned, that is UB, because the program is allowed to assume it doesn't change outside of where it does in the program * If you have something like an `UnsafeCell`, and use some kind of synchronization, either using separate "read" and "write" pointers like defmt-rtt does, or using your debugger to check "is the lock already taken before I write some data" or something, it can be sound My answer here is that you should model data that you poke with the debugger like you would with another thread, or between a kernel and application, etc. You still need to follow the rules of safe rust, and provide adequate synchronization, or it is UB. The maybe partial exception is that the debugger doesn't give AF about some kinds of UB, you can read "owned" memory all day, and you might observe surprising/torn/invalid values if you do that unsynchronized, and you can choose whether to deal with that or not.