pitfall | Pulumi Integration Testing Framework | Infrastructure Automation library

Complete vectorization is suboptimal for your case. It’s technically possible, but I think the overhead of producing that array of uint64_t values (I assume you’re compiling for 64 bit CPUs) will eat all the profit.

Instead, you should load chunks of 32 bytes, and immediately convert them to bit masks. Here’s how:

Yes, that is a valid implementation, however I'd write it differently

the solution to my problem was answered in this article about all PWA strategies: https://jakearchibald.com/2014/offline-cookbook/#network-falling-back-to-cache

and what I had to do was add this piece of code to the end of my service-worker.js file:

In practice the backward reinterpreting will probably work most of the time, in view of the strong constraints of the forward reinterpreting impose (see on cppreference, std::complex, implementation notes).

However, I'm not totally sure that such backward reinterpreting would in always work in theory:

• Let's imagine an absurd and hypothetical implementation of a complex library that would maintain a list of addresses of active complex objects (e.g. for debugging purpose). This (probably static) list would be maintained by the complex constructor and destructor.
• Every complex operation in this library would verify if its operands are in the list.
• While forward reinterpreting would work (the complex objects were well constructed and its parts can be used as doubles), the backward reinterpretation would not work (e.g. despite a compatible layout, you would reinterpret as complex a pair of doubles and if you'd perform any complex operation on them, it would fail since the complex was not properly constructed, i.e. its address is not in the list).

As said, this complex library would probably be a stupid idea. But such a library could be implemented and compliant with the standard specs. This is sufficient to prove that there is no reverse guarantee in theory.

The last point of your question is easier and more obvious to answer, supposing we would have an implementation where the reverse reinterpretation works. The missing last column would lead to an access of a part that is out of bounds. This would therfore lead to UB.

Additional readings: This working paper of the standard committee requests a general convertability feature that would generalize the bahavior of reinterpret_cast on complex for other types. It explains the complex case in section 4 and the special handling required from the compiler to make it work if complex is not itself implemented by an array.

The main pitfall with something like this is that it's 'astonishing', which is generally frowned upon in Python - we expect the default list to behave like the default list.

Aside from that, your implementation mostly looks complete to me. There are maybe a couple of issues:

• What happens if we use __setitem__ or __delitem__ and list the same index more than once?
• What happens if we give __setitem__ lists with mismatched lengths?

There's one key thing that I think it would be worth changing: get rid of lists of indexes, and use tuples instead.

If you pass a comma separated list of indices to __getitem__, these are actually parsed as a tuple!

The only reason to use hooks or other state tracking functionality is if you plan on changing the state within the component itself. From the example you gave, that is not the case. If the prop paymentAmounts is updated the component will get updated by React and so will your computed constant, average.

So, you get no benefit from using useState & useEffect here. Keep it simple with your computed constant!

No, it doesn't. Call instructions push a return address to the stack, jump instructions (including conditional jumps) do not. That is the fundamental difference between calls and jumps.

If you want to know what an instruction does, you should always refer to its description in official documentation, e.g. https://www.felixcloutier.com/x86/ which is an HTML copy of Intel's manuals. The description of jcc (which includes je) makes no mention of pushing a return address, which tells you that it doesn't do it. On the other hand, the description of call explicitly states that the return address is pushed, and explains in detail how it is done:

When executing a near call, the processor pushes the value of the EIP register (which contains the offset of the instruction following the CALL instruction) on the stack (for use later as a return-instruction pointer). The processor then branches to the address in the current code segment specified by the target operand.

Jump instructions are usually used to transfer control within functions, for constructs like loops (while), conditional execution (if), etc. In most such cases you don't ever want to return to the site of the jump, so pushing a return address would be useless and would just require you to waste extra instructions to get rid of it from the stack.

It is for the same reason the anonymous classes require the variables used in their coming out from the scope of themselves must be read-only -> final.

The answer is it depends and it requires several trade-offs to be made for each project

• Performance: RedisJSON uses a tree structure for storing all elements in a document.
  • Comparing to a string: the advantage is that updating sub-elements of a document will be faster than manipulating a string containing a serialised JSON object. But retrieving (reassembling) and writing the entire document will be more expensive compared to Strings. Read more here.
  • Comparing to Hash: when manipulating a flat document (1 level deep), RedisJSON and HSET performance are comparable.
• Maintainability: using several native data types in Redis to represent your object can be really performing, but the code will be more complex to maintain. There can be additional migration/refactoring work when the structure of the document is altered.
• Querying: RediSearch will soon add support for indexing and querying the content RedisJSON documents. This is, of course, if your use case requires secondary indexing and querying documents other than with their key. You can still build your own secondary indexing with Redis data structures, but this is also a trade-off in maintainability

disclaimer: I work for RedisLabs, creator and maintainer of RediSearch and RedisJSON