investigations | Indicators from Amnesty International 's investigations | Cybersecurity library

There's an issue on the repo about adding space between 2 paragraphs.

The author suggests using:

Let me take these questions one by one:

We see in the last sentence that it says that isDirty is required. But this does not seem right to me! Its type is never -> So it should never be required, shouldn't it?

There is nothing unique about the never type in terms of how it interacts with optional object properties. You can think of never as the same as any other type (string, number, etc.). The difference is that unlike these other types, there are no values that are assignable to never. You might say that a variable of type never can "never" be assigned a valid value.

But to my surprise the error remains! Doesn't the ? in e.g. a?: string equal a: string | undefined?

No. Consider the difference between the two objects: {} and {a: undefined}. In one case the key is missing, completely. In the other it exists and has the value undefined. The former object is assignable to {a?: string} but not to {a: string | undefined}.

This leads to:

why the question mark ? is necessary here in the first place and isDirty: never; is basically impossible.

Like in the above example, if you do not include the ? on the key name, then the key is required in the type. The key simply has to be present. But the type of that key's value is never. Because of that, there are no valid values you could assign to that key.

So in short, it is indeed impossible without a question mark, as it is a contradiction of requirements: that key must exist, but no value is valid for it.

Finally:

why ? behaves differently when it's used together with never.

This is merely a consequence of the usual properties of never combined with the usual behavior of ?. There is nothing special about the interaction of these two particular features.

Using the example of {isDirty?: never}, this means that one of the following must be true:

• The object does not include the isDirty key.
• The object does include the isDirty key and it has a value of type never.

Since the second of those two cases is impossible (by the above arguments), that leaves only the first case: an object matching this type must not contain the isDirty key.

Run the filenames through find.exe and omit those that contain -.jpg. The /V switch tells find.exe to omit lines where the string is found. Using findstr.exe uses a regex which can ensure that it is only found at the end of the filename. As always, use FIND /? and FINDSTR /? to read all about it.

Did you start out with the official Dockerfile (kubernetes/dockerfiles/spark/bindings/python/Dockerfile) as described in the Docker images section of the documentation? You also need to specify an upload location on a Hadoop-compatible filesystem and make sure that the specified Ivy home and cache directories have the correct permissions, as described in the Dependency Management section.

Example from the docs:

We've finally understood the mechanism that leads to the issue.

A -> Traefik -> B

1. B returns a list of objects with a ZonedDateTime field ("validFrom":"2021-12-24 23:59:57+01:00") and the header Transfer-Encoding: chunked.
2. Traefik replaces the Transfer-Encoding: chunked with a Content-Length, computed from the body of the request.
3. A receives the response, deserializes the objects, then reserializes them but in the UTC timezone ("validFrom":"2021-12-24 22:59:57Z"), but it reuses the Content-Length from Traefik without recalculating it.

As a consequence, the body from is shorter than the announced Content-Length (each ZonedDateTime takes five bytes less when A sends it than when Traefik computes the content length).

The client however has been announced a Content-Length and is waiting for the missing bytes.

The solution we have in mind right now is to tell Feign and its calling controller that it returns a ResponseEntity instead of a ResponseEntity>.

Pros:

• B's response is returned as-is, so no more problem due to a varying content length.
• A does not spend CPU-time deserializing then immediately reserializing the response.

Cons:

• The OpenApi doc of A won't show the type of return (unless the Open API annotation allow to specify the return model). That's what I'll test later today.

Hand building the Avro object each time seems a bit of a code smell to me.

Can you create a predefined message -> avro serializer and use that to feed the queue?

Or, just for testing, create one avro object outside the loop and feed that one object into the queue many times. That way you can see if it is the building or the queuing which is the bottleneck.

More general advice:

Maybe attach a profiler and see if you are making an excessive amount of object allocations. Which is particularly bad if they are getting promoted to higher generations.

See if they are your objects or Chronicle Queue ones.

Is your code maxing out your ram or cpu (or network)?

It should improve a bit when you avoid the conversion to string with .toString(2). Also the repeated i*8+l can be avoided by using a separate counter variable:

From reading the sourcecode on https://github.com/garabik/grc/blob/master/grcat (lines 157-165)

You can see grc dosen't consider lines that start with # or \n to start new rules only lines with other non letter characters, and if you look at other examples they separate their rules with =======

This is why only your last rule ever applied since they weren't separated properly they were overwriting each other

It should work when separated like this

Have you tried passing GRAVITY.START as a parameter to drawer.close(int gravity), like this: