time-travel | rsync based backup script which only transfers | Continuous Backup library

I would use a combination of attribute = value selectors to target the elements which have the full url in the content attribute

For a table, time-travel, as well as failsafe both, are applicable.

There is no direct connection between time-travel and failsafe, though they are part of the continuous data protection strategy. A few key differences

1. time-travel can be configured, by default 1 day and can range from 0 to 90 days (7 days for the standard edition and up to 90 days for enterprise and above).
2. Failsafe is not configurable and defaults to 7 days.
3. To recover data from failed safe, you need to contact snowflake support.
4. Failsafe is not applicable for transient and temporary tables.
5. Failsafe is outside the time-travel boundary and only needed if any there is a disaster, rest all case can be managed by time-travel.
6. Timetravel & failsafe, both incur a cost.

Refer this link:

You can compute the difference of two versions of the table, but as you guessed it’s expensive to do. it’s also tricky to compute the actual difference when the delta table has changes other than appends.

usually when people ask about this, they’re trying to design their own system that gives them exactly one processing of data from delta to somewhere; spark streaming + Delta source already exists to do this

if you do want to write your own, you can read the transaction log directly (protocol spec is at https://github.com/delta-io/delta/blob/master/PROTOCOL.md) and use the actions in the versions between the two you’re computing to figure out which files have changes to read

Please note that versions of a delta table are cached (persisted by Spark) so comparing different datasets should be fairly cheap.

You may try Time Travel Debugging, which allow for looking back in time what values had variables at each step. No auto-tracing though. TTD is available in:

• Visual Studio 2019 Enterprise as described here
• Oz Debugger like here

They are paid tools. I don't know free ones.

This is a trickiest part of the tutorial. It is correct that jumpTo resets stepNumber of the latest status of Game component. However render method of Game component uses stepNumber as index to retrieve current squares from history. This is very clever indeed. Code excerpt below:

I have known about these monads for well over a decade now, and have only just recently seen a realistic application of them. It's in a bit of an unusual setting. A coworker and I are using functional reactive programming via the 'reflex' library, and are working on a library to help with building terminal-graphics applications. If you're familiar with 'reflex-dom', it's similar in nature, except that our basic monad, rather than putting subsequent widgets one after the other in the DOM, instead just stacks terminal character-cell-based "images" on top of each other, and it's up to the user to carve up the screen sensibly. We wanted to provide something a little nicer than this, which would keep track of remaining screen real-estate to some extent, and let the user place some "tiles" in rows and columns, such that a do-block basically corresponds to either a column or row of tiles on the screen.

In addition to handling the problem of layout, we also want the tiles to be able to manage keyboard focus, allowing the user to press tab to cycle through them, or shift-tab to go in reverse. It was here that the forwards-and-backwards-in-time state monad transformer became quite handy: we can have the current state in either direction be an Event (of an empty tuple). Each tile can send an event to the previous and next widgets (and receive an event from them), notifying widgets when they are receiving keyboard focus and so should stop blocking key presses from reaching their child widgets. So schematically, the tile widget looks something like:

Take a look at this page to find your answer.

https://docs.mongodb.com/manual/reference/method/cursor.forEach/

You line

Is it because you are guaranteed to have the exact same state after running the reducers?

Yes, pure reducers are deterministic, meaning that if they are given the same input, they will always produce the same result output. This property helps with situations like unit testing, because you know if a test passes once, it will always pass.

If so, surely even side-effectful (ie. non-pure) reducers could have this property?

No, impure reducers would rely on both the inputs and on the state of the application. They could behave a given way 1000 times while you're testing, but break when your application happens to be in a particular state that you never thought to test.

Of course, it's perfectly possible to have a gap in your unit testing that misses a corner case. But if the test's results are 100% based on the inputs then you're far more likely to notice those corner cases just by looking at the stated inputs expected by the reducer.

If a function changes the application's state, then running the same function twice, or the same few functions in different orders, may cause completely different behavior. This makes it hard to reason about the correctness of the application because in order to know whether a given line of code is correct, you have to know what happened prior to calling it, possibly in a completely different part of the application.

The setState() function is typically used to update the component state with one or more new state properties. This is the typical way of mutating your state and managing view updates.

From the official docs:

setState() enqueues changes to the component state and tells React that this component and its children need to be re-rendered with the updated state. This is the primary method you use to update the user interface in response to event handlers and server responses.

The forceUpdate() function is just a way to force a re-render of the component and its children in question. It does not mutate the state at all.

You should avoid to use this function, when possible, as it deviates from the React mindset where your state and props are solely responsible for keeping your application logic up-to-date with your view.

From the official docs:

By default, when your component's state or props change, your component will re-render. If your render() method depends on some other data, you can tell React that the component needs re-rendering by calling forceUpdate().

Normally you should try to avoid all uses of forceUpdate() and only read from this.props and this.state in render().

It's important to note that forceUpdate() will skip checking the logic in shouldComponentUpdate() (if you have any), where as setState() does not skip it.

An interesting note here is that the following 2 lines will always yield the same results: