improb | A Python module for working with imprecise probabilities | Data Manipulation library

There is no specific character encoding used by Git's refs. The format is specified in the git check-ref-format manual page, and it allows a variety of byte values, including values which are not value UTF-8, such as 0xFE and 0xFF.

However, having said that, it is customary to use UTF-8 for ref names, and when ref files are written into the file system on Windows, they will be converted into UTF-16 because Windows can't handle anything else in its file system. The contents of the files, however, remains something containing arbitrary bytes, which, again, are customarily (but need not be) UTF-8.

I work at ScyllaDB - Scylla is a Cassandra compatible database.

There is indeed a limitation in Cassandra paging - https://issues.apache.org/jira/browse/CASSANDRA-14683 and it is not yet fixed.

What you can try and do is use the last token returned and continue paging from that state

As per the comments the issue is that you are were attempting to connect to a gRPC-Web server using a gRPC client. gRPC and gRPC-Web are different wire protocols (gRPC-Web was created because web browser APIs don't provide sufficient control over HTTP/2 requests to implement gRPC). This blog post provides a good overview.

Because you are building a web-app you will need to use gRPC-Web; if you also wish to connect to your server using a go client then the preferred option is to use gRPC (the server can both simultaneously). Another option that could work would be to use a gRPC-Web client but I've not tried this (it will be less efficient).

The 'official' way of running gRPC-Web is via an envoy plugin but as you are writing this in Go improbable-eng/grpc-web provides another, simpler, option which you are already utilising (they also have a proxy but that makes deployment more complex).

Your server needs to be altered to run both gRPC and gRPC-Web. The simplest option is to run these on different ports (it may be possible to use a mux to detect the content-type but this is not something I've tried; it does work well if you want to serve html/js and gRPC-Web on a single port).

The approach I'd take to run both servers follows (please treat this as incomplete pseudo code, I have pulled bits from a few of my applications but have not compiled/tested etc; feel free to update when you discover issues!):

Here is what I got from Datastax support:

Definitely a possible situation to consider. Cassandra/Astra handles this scenario with the following precedence rules so that results to the client are always consistent:

Timestamps are compared and latest timestamp always wins If data being read has the same timestamp, deletes have priority over inserts/updates In the event there is still a tie to break, Cassandra/Astra chooses the value for the column that is lexically larger While these are certainly a bit arbitrary, Cassandra/Astra cannot know which value is supposed to take priority, and these rules do function to always give the exact same results to all clients when a tie happens.

When a CL=QUORUM READ happens in a 3 node cluster, and the 2 nodes in the READ report different data with the same timestamp, what will the READ decide is the actual record? Or will it error?

Cassandra/Astra would handle this for you behind the scenes while traversing the read path. If there is a discrepancy between the data being returned by the two replicas, the data would be compared and synced amongst those two nodes involved in the read prior to sending the data back to the client.

So with regards to your diagram, with W1 and W2 both taking place at t = 1, the data coming back to the client would be data = 2 because 2 > 1. In addition, Node 1 would now have the missing data = 2 at t = 1 record. Node 2 would still only have data = 1 at t = 1 because it was not involved in that read.

There is a way of locking a table so as to be the sole user of that table.

There includes READ locks and WRITE locks but in this situation a WRITE lock would probably be the solution.

A WRITE lock has the following features:

1. The only session that holds the lock of a table can read and write data from the table.
2. Other sessions cannot read data from and write data to the table until the WRITE lock is released.

To lock a table in mysql, simply use:

LOCK TABLE table_name WRITE;

If needed for more than one table, simply add them with a comma:

Thanks to @cs95 for help in figuring this out. When we sort values, NaNs are put at the end of sorting group by default, and if the incomplete record has a duplicate with an existing value instead of this NaN, it will end up right on top of NaN. That means we can fill this NaN with that value by using ffill() method. So we're forward filling missing data with data from the rows that are closest to them, so we can then make a more accurate determination of whether that row is a duplicate.

The code I ended up using (adjusted to this reproducible example) looks like this:

There is no guarantee of uniqueness for server timestamps. That said, I imagine it's highly unlikely to get a duplicate, since they are measured to nanosecond precision.

You have different types

You may be interested in the geometric distribution, which counts the number of failures before the first success (some works say it counts that number plus the first success instead). As an example, the probability of getting no failures in a row is 1/2, one failure in a row is 1/4, two in a row is 1/8, three in a row is 1/16, and so on. If we take a zero-bit to mean failure and a one-bit to mean success, that means that with more zero-bits, it becomes less probable for that many zero-bits to be generated at random. As an example of an "improbable event", you can treat 30 or more zero-bits in a row as improbable.

Mersenne Twister and pseudorandom number generators (PRNGs) in general have cycles. The size of this cycle affects how many zero-bits the PRNG can generate in a row. For example, Mersenne Twister has a cycle of 2^19937 - 1 numbers, so that in theory, it can cycle through all states except for the all-zeros state. Thus, it can generate no more than 19937 * 2 zero-bits in a row. (This is if we treat Mersenne Twister as outputting individual bits, rather than 32 bits, at a time.)

This is in contrast to nondeterministic random number generators (RNGs), which don't have cycles but still generate random-behaving numbers. If the numbers it generates are independent, uniform, and random bits, then there is no telling how many zero-bits the RNG can randomly generate at most. One example of an RNG that uses nondeterminism is found in Python's secrets module, specifically secrets.randbelow(). (In practice, this module is likely to use a PRNG, but may gather "entropy" from nondeterministic sources from time to time, so that in practice the module's RNG is nondeterministic.)