Serializability | Determines whether a schedule

Looking at the implementation for Stream#toList, I just noticed how overcomplicated and suboptimal it seemed.

Like mentioned in the javadoc just above, this default implementation is not used by most Stream implementation, however, it could have been otherwise in my opinion.

As the heading mentions, the ArrayList and its iterator not working. Not able to figure why. The ArrayList should expect Employees and it is getting it. Then why the iterator is not giving proper objects?Any help?

Code:

I've been reading about the read-only lock-free transactions as implemented in Google Spanner and CockroachDB. Both claim to be implemented in a lock-free manner by making use of system clocks. Before getting to the question, here is my understanding (please skip the following section if you are aware of the machineries in both systems or just in CockroachDB):

• Spanner's approach is simpler -- before committing a write transaction, Spanner picks the max timestamp across all involved shards as the commit timestamp, adds a wait, called commit wait, to for the max clock error before returning from it's write transaction. This means that all causally dependent transactions (both reads and writes) will have a timestamp value higher than the commit timestamp of the previous write. For read transactions, we pick the latest timestamp on the serving node. For example, if there was a write committed at timestamp 5, and the max clock error was 2, future writes and reads-only transactions will at least have a timestamp of 7.
• CockroachDB on the other hand, does something more complicated. On writes, it picks the highest timestamp among all the involved shards, but does not wait. On reads, it assigns a preliminary read timestamp as the current timestamp on the serving node, then proceeds optimistically by reading across all shards and restarting the read transaction if any key on any shard reports a write timestamp that might imply uncertainty about whether the write causally preceeded the read transaction. It assumes that keys with write timestamps less than the timestamp for the read transaction either appeared before the read transaction or were concurrent with it. The uncertainty machinery kicks in on timestamps higher than the read transaction timestamp. For example, if there was a write committed at timestamp 8, and a read transaction was assigned timestamp 7, we are unsure about whether that write came before the read or after, so we restart the read transaction with a read timestamp of 8.

Relevant sources - https://www.cockroachlabs.com/blog/living-without-atomic-clocks/ and https://static.googleusercontent.com/media/research.google.com/en//archive/spanner-osdi2012.pdf

Given this implementation does CockroachDB guarantee that the following two transactions will not see a violation of serializability?

1. A user blocks another user, then posts a message that they don't want the blocked user to see as one write transaction.
2. The blocked user loads their friends list and their posts as one read transaction.

As an example, consider that the friends list and posts lived on different shards. And the following ordering happens (assuming a max clock error of 2)

1. The initial posts and friends list was committed at timestamp 5.
2. A read transaction starts at timestamp 7, it reads the friends list, which it sees as being committed at timestamp 5.
3. Then the write transaction for blocking the friend and making a post gets committed at 6.
4. The read transaction reads the posts, which it sees as being committed at timestamp 6.

Now, the transactions violate serializability becasue the read transaction saw an old write and a newer write in the same transaction.

What am I missing?

I am trying to implement a class that enables the user to manipulate N input Streams without having constraints on Types of input Streams.

For starter, I wanted to transform all input DataStreams into keyedStreams. So, I mapped the input dataStream into a Tuple and after that, I applied KeyBy to convert it into keystream.

I always get a problem of serialization, I tried to follow this guide https://ci.apache.org/projects/flink/flink-docs-stable/dev/java_lambdas.html and it didn't work.

What I do like to know is :

1. What is Serialization/Deserialization in Java ? and what is used for.
2. What are the problems that I can counter in Flink with Serialization
3. What is the problem in my code( you may find below the code and the error message)

Thank you very much.

Main Class:

I am having an issue like

Cannot add property X, object is not extensible

after updating my angular project to angular 9 with Ngrx update as well. When I rollback Ngrxversion to 8 it's working fine. But I need to update that as well to v9 with angular 9 updates. This has happened when I add this as datasource.data in the material table with additional attribute. I think that additional attribute alteration is a reason for that. But I create new array from what we got and tried out like below by using slice.