protect | Robust Threshold Cryptography | Cryptography library

The long execution time comes from the fact that each child of a Parent registers a listener with the disabled and treeVisible properties of that Parent. The way JavaFX is currently implemented, these listeners are stored in an array (i.e. a list structure). Adding the listeners is relatively low cost because the new listener is simply inserted at the end of the array, with an occasional resize of the array. However, when you remove a child from its Parent and the listeners are removed, the array needs to be linearly searched so that the correct listener is found and removed. This happens for each removed child individually.

So, when you clear the children list of the Group you are triggering 1,000,000 linear searches for both properties, resulting in a total of 2,000,000 linear searches. And to make things worse, the listener to be removed is either--depending on the order the children are removed--always at the end of the array, in which case there's 2,000,000 worst case linear searches, or always at the start of the array, in which case there's 2,000,000 best case linear searches, but where each individual removal results in all remaining elements having to be shifted over by one.

There are at least two solutions/workarounds:

1. Don't display 1,000,000 nodes. If you can, try to only display nodes for the data that can actually be seen by the user. For example, the virtualized controls such as ListView and TableView only display about 1-20 cells at any given time.

2. Don't clear the children of the Group. Instead, just replace the old Group with a new Group. If needed, you can prepare the new Group in a background thread.

   Doing it that way, it took 3.5 seconds on my computer to create another Group with 1,000,000 children and then replace the old Group with the new Group. However, there was still a bit of a lag spike due to all the new nodes that needed to be rendered at once.

   If you don't need to populate the new Group then you don't even need a thread. In that case, the swap took about 0.27 seconds on my computer.

The key is to keep a reference to the Task, and if found, await its value.

Perhaps:

Note the meaning of private from the language spec §6.6.1, emphasis mine:

Otherwise, the member or constructor is declared private. Access is permitted only when the access occurs from within the body of the top level class or interface that encloses the declaration of the member or constructor.

The extends clause is not part of the class body. The syntax for a class declaration looks like this (Classes):

Your title says you are using Java 9. With Activiti 6 you will have to use JDK 1.8 (Java 8).

When exactly does segmentation fault happen (=when is SIGSEGV sent)?

When you attempt to access memory you don’t have access to, such as accessing an array out of bounds or dereferencing an invalid pointer. The signal SIGSEGV is standardized but different OS might implement it differently. "Segmentation fault" is mainly a term used in *nix systems, Windows calls it "access violation".

Why is the process in undefined behavior state after that point?

Because one or several of the variables in the program didn’t behave as expected. Let’s say you have some array that is supposed to store a number of values, but you didn’t allocate enough room for all them. So only those you allocated room for get written correctly, and the rest written out of bounds of the array can hold any values. How exactly is the OS to know how critical those out of bounds values are for your application to function? It knows nothing of their purpose.

Furthermore, writing outside allowed memory can often corrupt other unrelated variables, which is obviously dangerous and can cause any random behavior. Such bugs are often hard to track down. Stack overflows for example are such segmentation faults prone to overwrite adjacent variables, unless the error was caught by protection mechanisms.

If we look at the behavior of "bare metal" microcontroller systems without any OS and no virtual memory features, just raw physical memory - they will just silently do exactly as told - for example, overwriting unrelated variables and keep on going. Which in turn could cause disastrous behavior in case the application is mission-critical.

Why is it not recoverable?

Because the OS doesn’t know what your program is supposed to be doing.

Though in the "bare metal" scenario above, the system might be smart enough to place itself in a safe mode and keep going. Critical applications such as automotive and med-tech aren’t allowed to just stop or reset, as that in itself might be dangerous. They will rather try to "limp home" with limited functionality.

Why does this solution avoid that unrecoverable state? Does it even?

That solution is just ignoring the error and keeps on going. It doesn’t fix the problem that caused it. It’s a very dirty patch and setjmp/longjmp in general are very dangerous functions that should be avoided for any purpose.

We have to realize that a segmentation fault is a symptom of a bug, not the cause.

Redis Server does not use Java and is therefore not impacted by this vulnerability.

See more here: https://redis.com/security/notice-apache-log4j2-cve-2021-44228/

I looked at the Android rules and regulations page

According to Google documents, from Android 8 onwards, all applications that do not have a Google-approved signature will be removed from the background after a few minutes.

But the solutions:

1. The first solution is to run the application in debug mode
2. The second solution is to assign a signature to the application and send it to Google for approval

recommend:

1. The third solution is to remove the google play service application from the emulator or android phone

If a function only depends on other pure functions, then it is also pure. Since getPhoneNumberRules() just returns a fixed array, it's pure, so rules() is also pure.

But messages() calls getPhoneNumberMessage(), which calls the __() function that can return a different localized message if the location state changes, so it's not pure.

You are right that such access is unsafe and Swift 5.5 today does not prevent this, unless you pass the -warn-concurrency flag explicitly.

Please refer to the Staging in Sendable checking proposal (and forums post which discuss the rollout plan of the checking feature).

You can also read about the general plan with regards to concurrency safety between now in Swift 5.5 and Swift 6 in the roadmap update here: Concurrency in Swift 5 and 6.