reading | iReading App Write | State Container library

The difference in behaviour can be accounted for by this behaviour, described in (for instance) the following note in ECMAScript 2022 Language Specification sect 14.3.2.1:

NOTE: If a VariableDeclaration is nested within a with statement and the BindingIdentifier in the VariableDeclaration is the same as a property name of the binding object of the with statement's object Environment Record, then step 5 will assign value to the property instead of assigning to the VariableEnvironment binding of the Identifier.

In the first case:

Looks like there is a "A415" value in your column. Could be a typo?

You can check if this is the case by getting a list of the unique values in this pandas column, like below. This is a quick way of knowing if all values look alright.

Surprisingly, this is not undefined behavior.

Static initialization [basic.start.static]

Constant initialization is performed if a variable or temporary object with static or thread storage duration is constant-initialized. If constant initialization is not performed, a variable with static storage duration or thread storage duration is zero-initialized. Together, zero-initialization and constant initialization are called static initialization; all other initialization is dynamic initialization. All static initialization strongly happens before any dynamic initialization.

Important parts bold-faced. "Static initialization" includes global variable initialization, "static storage duration" includes global variables, and the above clause is applicable here:

There are multiple ways. The easiest one will be to use split.

You are not measuring the elapsed time correctly:

1. total_send_time measures the duration of the spawn() call, but as the actual task is executed asynchronously, start_in.elapsed() does not give you any information about how much time the task actually takes.

2. The ran in time, as measured by start.elapsed() is also not useful at all. As you are using blocking sleep operation, you are just measuring how much time your app has spent in the std::thread::sleep()

3. Last but not least, your time_to_sleep calculation is completely incorrect, because of the issue mentioned in point 1.

It varies between implementations, but generally, this is managed by the cache coherency protocol of the multiprocessor. In simplest terms, what happens is that when CPU1 writes to a memory location, that location will be invalidated in every other cache in the system. So that write will invalidate the line in CPU2's instruction cache as well as any (partially) decoded instructions in CPU2's uop cache (if it has such a thing). So when CPU2 goes to fetch/execute the next instruction, all those caches will miss and it will stall while things are refetched. Depending on the cache coherency protocol, that may involve waiting for the write to get to memory, or may fetch the modified data directly from CPU1's dcache, or things might go via some shared cache.

We're looking in to the same issue currently and it seems apple are disabling the old binary interface which push sharp uses.

https://developer.apple.com/news/?id=c88acm2b

pushsharp has it on the roadmap to support the new interface but not completed yet.

Found this library which seems easy enough to use as a solution. hope this helps.

https://github.com/alexalok/dotAPNS

You have a column with a "struct type" and you want to flatten it. To do so call flatten before calling to_pandas