jp | An accurate , forgiving and fast JSON reformatter | JSON Processing library

I think that happens because of Mac, i tried on both operating systems, and its the same for me.

Maybe try style="background-color:#fff", maybe that helps, but idk more than that sorry.

Maybe this link helps you, good luck :)

That happens, because you're trying to update state asynchronously, and the update could happen when the component is unmounted.

You can keep a ref that will check if the component is mounted or not like in the code below.

Because I can't see the implementation of the AxiosGetData, you can just check is that ref is true, when you will consume the promise from the axios.

I found an extremely hacky solution that seems to work. However, it seems absurd that there's no way to simply set the locale of a label, so if anyone finds something I missed, please post an answer.

The trick relies on the fact that the Hiragino font displays kanji using Japanese encoding rather than Chinese encoding by default. However, the font looks like shit for English text, so I have to search every string in every label for Japanese substrings and manually change the font using NSMutableAttributedString. The font is also completely broken so I had to find another workaround to fix that.

are you sure that you have created the variables for the translation?

record_path is the path to the record, so you should specify the full path

This was actually an issue because python wasn't installed and J.DepP's makefile didn't return a fail for a critical dependency.

Install python, run make clean && ./configure and the issue with disappear.

I figured it out. You better not hold anything in your mouth, because this is hilarious!

Basically being all out of options, I locked on to the last discernible difference between this deployment and the ones that worked: The filesize of the jar being deployed. The one that failed was by far the smallest. So I bloated it up by some 60% to make it comparable to everything else... and that fixed it!

This sounds preposterous. Here's my hypothesis on what's going on: If the upload takes too little time, the lambda somehow needs longer to change its state. I'm not sure why that would be, you'd expect the state to change when things are done, not to take longer if things are done faster, right? Maybe there's a minimum time for the state to remain? I wouldn't know. There's one thing to support this hypothesis, though: The deployment from my local computer always worked. That upload would naturally take longer than jenkins needs from inside the aws vpc. So this hypothesis, as ludicrous as it sounds, fits all the facts that I have on hand.

Maybe somebody with a better understanding of the lambda-internal mechanisms can add a comment to this explaining how this can happen...

X9.63 KDF is a key derivation function, described e.g. here and here. scrypt and PBKDF2 are also KDFs, but different ones, so of course the expected result cannot be reproduced with them.

So you need a NodeJS library that supports X.963 KDF. If you can't find one, you could also implement your own.

X9.63 KDF expects a shared secret and a shared info and determines a keysize large key as follows:

• Create a 4 byte counter c_i which is incremented starting with 0x0000001.
• Concatenate the data conc_i = shared secret | c_i | shared info
• Hash the result hash_i = hash(conc_i)
• Concatenate the hashes hash₁ | hash₂ | ... until an output of length keysize has been generated.

More formally, including various checks, the algorithm is described in the links above. The Python code posted later in the question also implements this logic.

One possible NodeJS implementation (omitting the checks from the specification) is:

MoveMask just extracts the high bit of each element into an integer bitmap. You have 3 element-size options: movmskpd (64-bit), movmskps (32-bit), and pmovmskb (8-bit).

This works well with SIMD compares, which produce an output that has all-zero when the predicate is false, all-one bits in elements where the predicate is true. All-ones is a bit-pattern for -QNaN if interpreted as an IEEE-FP floating-point value, but normally you don't do that. Instead movemask, or AND, (or AND / ANDN / OR or _mm_blend_pd) or things like that with a compare result.

movemask(v) != 0, movemask(v) == 0x3, or movemask(v) == 0 is how you check conditions like at least one element in a compare matched, or all matched, or none matched, respectively, where v is the result of _mm_cmpeq_pd or whatever. (Or just to extract signs directly without a compare).

For other element sizes, 0xf or 0xffff to match all four or all 16 bits. Or for AVX 256-bit vectors, twice as many bits, up to filling a whole 32-bit integer with vpmovmskb eax, ymm0.

What you're doing is really weird, using a 0.0 / NaN compare result as the input to another compare with vcmpeqpd xmm1, xmm1, xmm2 / vcmpeqpd xmm1, xmm1, xmm0. For the 2nd comparison, that can only be true for elements that are == 0.0 (i.e. +-0.0), because x == NaN is false for every x.

If the second vector is a constant zero (let zeroTest = Sse2.CompareEqual (comparison, zeroVector), that's pointless, you're just inverting the compare result which you could have done by checking a different integer condition or against a different constant, not doing runtime comparisons. (0.0 == 0.0 is true, producing an all-ones output, 0.0 == -NaN is false, producing an all-zero output.)

To learn more about intrinsics and SIMD, see for example Agner Fog's optimization guide; his asm guide has a chapter on SIMD. Also, his VectorClass library for C++ has some useful wrappers, and for learning purposes seeing how those wrapper functions implement some basic things could be useful.

To learn what things actually do, see Intel's intrinsics guide. You can search by asm instruction or C++ intrinsic name.

I think MS has docs for their C# System.Runtime.Intrinsics.X86, and I assume F# uses the same intrinsics, but I don't use either language myself.

Related re: comparisons:

• Check that at least 1 element is true in each of multiple vectors of compare results - horizontal OR then AND

• Get the last line separator - pcmpeqb -> pmovmskb -> bsr to find the position of the last match element in a vector of compare results. Bit-scan reverse on the compare mask. Often you want to scan forward to find the first match (or invert and find first mismatch, like for memcmp). e.g. Compare 16 byte strings with SSE
  Or popcount them if you're counting occurrences by matching against a loop-invariant vector of a broadcasted character: How can I count the occurrence of a byte in array using SIMD? - instead of movemask, use the compare result as integer 0 / -1. SIMD subtract from a vector accumulator in the inner loop, then horizontal sum of integer elements in an outer loop.

• SIMD instructions for floating point equality comparison (with NaN == NaN) - useful exercise in understanding how NaNs work.