progress | React Progress Bar | User Interface library

What is happening in your code:

You have an object coord. You are pushing its reference to the array, in each iteration. All your array elements point to coord. You are changing the properties of the object coord again in turn changing your array elements.

This is exactly the reason why coroutines were invented and how they differ from threaded concurrency. Coroutines don't block, but suspend (well, they can do both). And "suspend" isn't just another name for "block". When they suspend (e.g. by invoking join()), they effectively free the thread that runs them, so it can do something else somewhere else. And yes, it sounds like something that is technically impossible, because we are in the middle of executing the code of some function and we have to wait there, but well... welcome to coroutines :-)

You can think of it as the function is being cut into two parts: before join() and after it. First part schedules the background operation and immediately returns. When background operation finishes, it schedules the second part on the main thread. This is not how coroutines works internally (functions aren't really cut, they create continuations), but this is how you can easily imagine them working if you are familiar with executors or event loops.

delay() is also a suspending function, so it frees the thread running it and schedules execution of the code below it after a specified duration.

While editing my initial question to add more context as Jay proposed I think it found the issue.

What probably happens? The view where the crash is, contains a table view. Each cell will be configured before being presented. I use a flag which holds the information, if the amount of weight for this cell (it is a strength workout app) has been initially set or is a change. When prepareForReuse is being called, this flag has not been reset. And that now means scrolling through the table view triggers a DB write for each reused cell, that leads to unnecessary writes to the db. Unnecessary, because the exact same number is already saved in the db.

My speculation: Scrolling fast could maybe lead to a race condition (I have read something about that issue with realm) and that maybe causes this weird crash, because there are multiple single writes initiated in a short time.

Solution: I now reset the flag on prepareForReuse to its initial value to prevent this misbehaviour.

The crash only happens when the cell is set up and the described behaviour happens. Therefor I'm quite confident I fixed the issue finally. Let's see. -- I was not able to reproduce the issue, but it also only happens pretty rare.

Updating the progress bar element in the host application does indeed take up time and resources during execution - but even if you suppressed the progress bar, writing to the progress stream is still pretty slow!

As iRon suggests, the solution is to call Write-Progress less often:

The issue is because using position: fixed takes the element out of the document flow. As such it has no reference to its parent for CSS to be able to calculate inherited dimensions.

In this case you can create the behaviour you require by manually calculating the percentage width as an explicit pixel value using the width of .container.

Also note that the if condition around the moveTrackingBar() function definition is redundant and can be removed.

fromCallable doesn't shield you from blocking computation inside the Callable, which your example demonstrates.

The primary mean of cancellation in Reactive Streams is the cancel() signal propagated from downstream via the Subscription.

Even with that, the fundamental requirement of avoiding blocking code inside reactive code still holds, because if the operators are simple enough (ie. synchronous), a blocking step could even prevent the propagation of the cancel() signal...

A way to adapt non-reactive code while still getting notified about cancellation is Mono.create: it exposes a MonoSink (via a Consumer) which can be used to push elements to downstream, and at the same time it has a onCancel handler.

You would need to rewrite your code to eg. check an AtomicBoolean on each iteration of the loop, and have that AtomicBoolean flipped in the sink's onCancel handler:

Try running these 2 scripts in two different tabs with app.snowflake.com:

Script 1:

AsyncPostBackTrigger only sets controls that are outside of the panel.

Controls on the page outside of an update panel can refresh an UpdatePanel control by defining them as triggers. Triggers are defined by using the AsyncPostBackTrigger element.

Controls that postback will always postback. I think the ChildrenAsTriggers="false" won't stop the postbacks - it will just stop the content from updating.