Trapped | based adventure game based of the popular Battle Royale | Game Engine library

There are multiple reasons, all touched on in the comments.

1. Lifetime. The process id is simply a number, knowing the id does not keep the process alive. Having a open handle to a process means the kernel EPROCESS structure and the process address space will stay intact, even if said process finishes by calling ExitProcess. Windows tries to not re-use the id for a new process right away but it will happen some time in the future given enough time.
2. Security/Access control. In Windows NT, access control is performed when you open a object, not each time you interact with the object. In this case, the kernel needs to know that the caller has PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process. This is related to point 3, efficiency.
3. Speed. Windows could of course implement a WriteProcessMemoryById function that calls OpenProcess+WriteProcessMemory+CloseHandle but this encourages sub optimal design as well as opening you up to race conditions related to point 1. The same applies to "why is there no WriteFileByFilename function" (and all other Read/Write functions).

I've read through Microsoft "about_Trap", and its looking like the answer is no. https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_trap?view=powershell-5.1

Read the blue "Important" boxes on the page. "trap statements may be defined anywhere within a given scope, but always apply to all statements in that scope" and "A Trap statement is scoped to where it compiles. If you have a trap statement inside a function or dot sourced script, when the function or dot sourced script exits, all trap statements inside are removed."

The "Trapping errors and scope" section of this page shows an example where a trap is set before function2 is called and the trap catches the error that happened inside function2. But technically, the call to function2 is in the same scope as the trap, so I believe even that was a same scope situation.

I did an experiment where I set a trap in a function in a module:

Try this: HTML

Is this correct? Does strncmp_sse4_2 read more than n bytes?

Yes.

Even if it does: Doing 16 bytes at a time should stop at 0x7ffeff58. Why does it read till 0x7ffeff60?

You are assuming that it started using movdqu from the address you passed in. It likely didn't. It probably aligned the pointers to cache line first.

If so, how does this not potentially cause a page fault?

If you have a 16-byte aligned pointer p, that means p+15 points to the same page as p so you can read 16 bytes from p with impunity.

If so, how do we tell distinguish acceptable read of uninitialized data from cases indicating bugs? E.g. how would Valgrind avoid reporting this as an uninitialized read?

Valgrind does this by interposing its own copy of strcmp (for dynamically linked binaries). Without such interposition, valgrind produces false positives (or, rather valgrind produces true positives which nobody cares or could do anything about).

Finally, I put this to the side for some time when I got more R savvy. Instead of trying to overcomplicate things, I decided to make a really simple SEM path plot, then apply what was said in the comments here earlier to solve the issue.

So the major issue I kept having was getting the title to map on. For some reason I couldn't understand what was causing the issue...until I figured out the order of operations for printing out the plot. So here is basically what I did. First I used a well-oiled data frame and wrote a model based off the old lavaan manual:

Trapped shell signals are not delivered until after foreground commands — a command the shell is waiting to exit before it advances to its next instruction – are completed. (The wait builtin is an exception to this.) (POSIX.1-2008 Shell and Utilities §2.11) Thus, your sleep has exited by the time the USR1 or USR2 trap is sprung.

For example:

The role of crossover in genetic algorithms is to spread the beneficial mutations of population members that let them achieve a high fitness value to more members of the population.

The key is that only the fit members of the population crossover with each other and thereby spread beneficial mutations to more members of the population with the intent that the offespring (/new members) might also benefit from the mutation of the parent. Thereby crossover leads to a spreading of mutations that lead to a higher fitness value spread throughout the population - leading to your observed faster convergence.

Take for example a neural network that plays a jump and run video game and is optimized with a genetic algorithm. One member might have received a high fitness score through a mutation that makes him jump over obstacles. Another member might have received a high fitness score through a mutation that makes him collect lifes on the map. Crossing over fit parent members spreads the beneficial mutations faster than if the rest of the population would need to learn these fitness increasing mutations itself by chance.

You can have your client_handler take a queue as an argument, and use functools.partial to create a function that you can pass to websockets.serve

Selectively use a try / catch / finally statement to act on a terminating error caused by an individual statement (see also the bottom section):