intervene | middle proxy for development , enabling mocking | REST library

Thanks to Sam Deane’s Localization package provided exactly what I was after (and I believe does essentially what Larme suggested in the comment above).

What you are experiencing is called "collapsing margins". Example: If there's an h2 as the first child element inside a div, and the div has no margins, the top margin of the h2 will "go outside the div" at the top - h1, h2 etc. tags have a default margins in practically all browsers (which is a browser setting). To prevent that, you can define all margins for according elements as zero, like I did below with

You can configure the SeekToCurrentErrorHandler with an infinite BackOff:

The correct formula that defines an ultra-dynamic-range for replacing the 'OFFSET' formula:

=OFFSET($A$79,$B$5+1,COLUMN()-1,$B$6,1)

Is:

=INDEX($A:$XX,ROW($A$79)+$B$5+1,COLUMN()):INDEX($A:$XX,ROW($A$79)+$B$7,COLUMN())

• Where in B7 is the number of the last row of the pivot. (=Something like B5+B6 plus/minus 1 or 2 - test it for your case)

If you Define a Name of a Dynamic Range with this ultra-dynamic formula, it will adapt to give you different ranges depending on the location of the cell where you copied it to!! It will always give you the same parallel range in your column and will produce different results in different columns! I tested it and it works perfectly, plus it made my calculations lightning faster since INDEX is non-volatile (as opposed to OFFSET).

One more tip for the example above: I also tried nested range names and they work! For example I Defined the Range for ColPopulation as:

=(ColUppers,ColDowners)

Note that this is an ultra-dynamic-nested-range-name! Of course, it can work only for simple functions (such as =MAX(ColPopulation)) and will not work in functions such as SUMPRODUCT that need contiguous ranges. Still, it is a very useful thing to know that you can Define Ranges by adding other range names with commas!

Great help from all involved! Thanks a lot!

You'll need to use a "real" downing provider like Split Brain Resolver. This lets the cluster safely down nodes that are unreachable. (As opposed to the auto downing, which downs them without consideration of it is safe or not.)

There's a separate question of why DC/OS is killing the nodes so quickly they don't get the chance to properly shut down. But I don't know DC/OS well enough to say why that could be. And, regardless, a downing provider is essential for clustered environments so you will want to get that in place anyway.

Edited due to your comments about SBR:

• First I want to be clear, the marathan-api is almost certainly irrelevant here. marathon-api is how nodes discover other nodes in DC/OS. The problems you are having are with fundamental cluster problems, namely unreachable nodes. A cluster with unreachable nodes is going to act the same way, regardless of where it is running and how the nodes are discovered.
• Fundamentally my best guess is that you are having problems getting clean shutdowns. If SBR is downing your entire cluster it's because it is getting to a point where there are more unreachable nodes than live clusters.

As an example, what might be happening:

• You have 4 live nodes and want to upgrade.
• DC/OS kills the first node. For some unknown reason you aren't getting a clean shutdown so the node is marked as unreachable. (Essentially the cluster, because it wasn't a clean shutdown doesn't node if the node still exists but is unresponsive and/or behind a partition.) There are 3 live nodes and one unreachable.
• DC/OS starts the second node. Perhaps it takes a while to boot your application. So you have 3 live nodes, one unreachable node, and 1 unready node.
• DC/OS kills another node. So you have 2 live nodes, 2 unreachable nodes, and 1 unready node. At this point SBR can no longer guarantee that you haven't had a network partition because you don't have majority. At this point, in order to prevent corruption, it must stop the cluster.

So, I would recommend the following:

• I don't know the details of DC/OS well enough but you probably need to slow down your rolling upgrades. In K8S I'd use something like MinReadySeconds.
• You may want to consider a fifth node. Odd numbers are better because it makes majority easier to determine.
• If you continue to have problems you'll need to provide more logs from the SBR decision.

SBR is the answer here. I realize that you aren't having real network partitions, but the fact that you are having unreachable nodes means that the Akka Cluster is unable to tell if there are network partitions or not and that's the root cause of the problem.

There's a component of the CPU called the Memory Management Unit. This is responsible for translating virtual addresses to physical addresses when a memory access instruction is executed.

If the virtual address is not currently mapped into RAM, it triggers an interrupt. This suspends the process and tells the OS that it needs to bring the appropriate memory into RAM. The address that it was trying to access is stored in a register, so the OS knows what to page in.

If you are going to change the Figure then you must create a new canvas so you will have to destroy the previous one:

As a general rule, I would advise against sleeping on a thread. First, we do not have preemptive cancelation. Second, it’s an inefficient use of resources, tying up that thread unnecessarily.

If you want to do something after a certain period of time, you have a few options:

1. You can create a DispatchWorkItem, dispatch it with asyncAfter, and then cancel if you don’t want that to happen.

2. Even easier, just schedule a Timer and then invalidate it if you want to stop it.

If you have some cancelable tasks that you want to perform every x seconds, a single repeating Timer is probably easiest, as you can invalidate it and it stops the whole repeating series in one step. (It also avoids timer coalescing problems.)

You said:

what I am trying to achieve is - having a presentation that runs with predetermined time between slides, but if user wants to go back (or forward); it should cut straight away to previous slide and continue in the same manner of predetermined pauses.

I would suggest a repeating Timer to advance to the next slide. If the user manually changes to another slide, invalidate the old timer and create a new repeating Timer.

What you are looking for is likely a Transform stream, something implemented by the native 'stream' library included with Node.js. I don't know that there is an async compatible version yet, but there is most definitely a callback based one. You need to inherit from the native Transform stream and implement your function.

Here's the boilerplate I like to use: