text:
\subsection{Preliminaries}

A distributed stream processing system is a shared-nothing distributed runtime, that can handle a potentially infinite sequence of input items. Each item can be transformed several times before the final result is released from the system. Output elements may depend on multiple input ones. Elements can be processed one-by-one or grouped into small input sets, usually called {\em micro-batches}.

A user specifies required stream processing with a {\em logical graph}. Vertices of this graph represent operations and edges determine the data flow between tasks. A processing system maps the logical graph to a {\em physical} graph that is used to control actual distributed execution. Commonly, each logical operation is mapped to several physical tasks that are deployed to a cluster of computational units connected through a network. Each operation may be {\em stateless} or {\em stateful}. A system is usually responsible for state management in order to prevent inconsistencies.

An input element has {\em entered} if the system is aware of this element since that moment and takes some responsibility for its processing.
This concept can be implemented differently.
For example,
 an  element has been entered when  it  has arrived at {\em Source} vertex in Flink, while
an element enters, when it is read or received by an input agent also called  {\em Source}   in Spark Streaming.

An output element has {\em left} the system if the element has been released to a consumer.
Since that time, the system cannot observe it anymore. This concept can also be implemented differently in various systems. For instance, in Spark Streaming element leaves when it is pushed to output operation, e.g., written to HDFS or file. In Flink, an element is delivered to end-user when it leaves from {\em Sink} vertex.

It is important to note that input and output elements cannot be directly matched due to the possibility of complex transformations within the system.
For instance, a single input element can be transformed into multiple ones.  The resulting elements may be processed in entirely different ways and even influence each other.
In general, it is hard to find out input elements on which an output element depends.

\subsection{Distributed streaming model}

A formalization of streaming consistency guarantees we begin with a regular definition of a stream processing system. In order to be sufficient for the formalization, such a model should cover user-defined transformations, system state, data producers, and data consumers.

Index $\tau\in{\mathbb{N}}$ can be considered as an exact global discrete time. We assume that only one event can happen at any single point in time $\tau$.

\begin{definition}{Stream processing system}
\label{reference_system}
is a tuple of $(\Gamma,D,F)$, where $\Gamma$ is a set of all possible data flow elements, $D\subseteq{2^{\Gamma}\times2^{\Gamma}}$ is a binary relation on its power set. $F$ is a recovery function that restores the working set in case of system failures. Computations within the system are defined by the recurrent rules on the set of input elements $A$, output elements $B$, and the transient working set $W$. On each iteration, one of the following steps is chosen:

\begin{enumerate}
    \item \textbf{Input} $a_\tau\in{\Gamma}$:\\ $A_{\tau+1}=A_\tau \cup \{a_\tau\}, \\ B_{\tau+1}=B_{\tau}, \\ W_{\tau+1}=W_{\tau} \cup \{a_\tau\}.$
    \item \textbf{Output} $b_\tau\in{W_\tau}$:\\ $A_{\tau + 1} = A_{\tau}$, \\ $B_{\tau+1}=B_\tau \cup \{b_\tau\}, \\ W_{\tau+1}=W_{\tau} \setminus \{b_\tau\}.$
    \item \textbf{Transform}\\ $A_{\tau + 1} = A_{\tau}$,\\ $B_{\tau+1}=B_{\tau}$, \\ $W_{\tau+1}=(W_\tau \setminus \chi_\tau) \cup Y_\tau, (\chi_\tau,Y_\tau) \in D$, \\where\\$\chi_\tau \thicksim P(X\mid X \subseteq W_\tau \cup B_\tau , \exists Y : (X,Y) \in D)$, \\ probability distribution of $\chi_\tau$ depends on a system architecture. \label{random_formula}
    \item \textbf{Failure and recover} \\  $A_{\tau + 1} = A_{\tau}$,\\ $B_{\tau+1}=B_{\tau}$, \\ $W_{\tau+1} = F(A_\tau,B_\tau)$
\end{enumerate}

\end{definition}

\begin{table}[!b]
    \caption{Notations used throughout the paper}
    \begin{tabular}{l|p{5cm}}
        \hline
        $\Gamma$ & The set of all possible data flow elements \\
        \hline
        $D\subseteq{2^{\Gamma}\times2^{\Gamma}}$ & Binary relation that captures user-defined operations  \\
        \hline
        $Cl_D$ & Transitive closure of $D$  \\
        \hline
        $Cl^{-1}_D$ & Inversed transitive closure of $D$  \\
        \hline
        $\tau \in \mathbb{N}$ & Exact global discrete time \\
        \hline
        $a_\tau \in \Gamma$ & Input element at the time $\tau$ \\
        \hline
        $A_\tau \subseteq \Gamma$ & All input elements by the time $\tau$ \\
        \hline
        $b_\tau \in 2^{\Gamma}$ & Output element at the time $\tau$ \\
        \hline
        $B_\tau \subseteq 2^{\Gamma}$ & All output elements by the time $\tau$ \\
        \hline
        $W_\tau \subseteq 2^{\Gamma}$ & Working set at the time $\tau$ \\
        \hline
        $F$ & Recovery function \\
        \hline
        $F^{*}$ & Reference recovery function \\
        \hline
        $P(b_{\tau+1}|A_{\tau}, B_\tau, F)$ & Probability of output element \\
        \hline
        $P(b_{\tau+1}|A_{\tau}, B_\tau, F^{*})$ & Probability of output element in a system with a reference recovery function \\
    \end{tabular}
    \label{notations}
\end{table}

Data producers and consumers are modeled using sets $A$ and $B$, respectively. All elements that in the system at the time $\tau$ are also presented in the set $W_\tau$. We assume that operation states are common elements that are presented in $W_\tau$ as well. Binary relation $D$ captures all possible transformations within a physical graph. {\em Input} step indicates that a new streaming element enters the system. This element is also presented in set $A$, because the system may request it for reprocessing. {\em Output step} describes a case, when an element leaves the system, e.g., during delivery of an output element to a data consumer. {\em Transform} step denotes the internal transformation of an element according to user-defined operations. In this model, we do not explicitly introduce computational units and asynchronous network channels. Instead, we simulate possible races and distributed asynchronous processing through the probability of the next transformation inside a data flow. Such probability is modeled using a random variable $\chi_\tau$, which indicates the input of an operation that will be executed next. {\em Failure and recover} step indicates the recovery of the system state based on input and output elements.

We allow using output elements in system transformations because we suppose that {\em snapshots} of operation states taken by real stream processing systems are common output elements. The rationale for this assumption is the following:

\begin{itemize}
    \item Snapshots should be considered as an output as they are usually stored in external systems, (such as in HDFS, Kafka, relational databases)   and are read back during recovery.
    \item Stream processing systems aim at minimizing information which is needed to recover processing, but their optimizations do not directly affect consistency. The notion of $F(A_\tau, B_\tau)$ makes our concept general enough to describe any streaming engine while being independent of a specific implementation of $F$.
\end{itemize}

Let us illustrate the proposed model by an example. Assume that a physical graph consists of a single windowed operation (window = 2) that concatenates strings from multiple asynchronous input channels. This graph is illustrated in Figure~\ref{concat}: $x \in W$ indicates input channels, $y\in W$ denotes output channel, and $ s \in W$ is the state of the operation. Set $\Gamma$ contains all possible characters, and binary relation $D$ contains all possible options for their concatenation. Recovery function $F$ reprocess all input elements since the last snapshot. Table~\ref{concat_example} demonstrates a potential execution of the defined graph with strings $"a","c","b","d","e"$ as input elements. The concatenation operation receives a random element from its input due to asynchronous channels. Wall time is indicated to highlight that races may occur in a data flow. Note that step {\em snapshot} can be considered as an ordinary output step. Red lines emphasize the recovery process after failure.

As one can see, the system reaches precisely the same state after recovery. Eventually, the end-user receives the output element {\em be} that is expected within such execution. Further, we demonstrate that simple reprocessing of missed input elements can cause significant inconsistencies in results.

\begin{figure}[htbp]
  \centering
  \includegraphics[width=0.48\textwidth]{concat}
  \caption{Strings concatenation physical graph}
  \label{concat}
\end{figure}

\begin{table}[htbp]
\begin {center}
\caption{String concatenation data flow}   \tabcolsep2pt
\begin{tabular}{c|l|c|c|c|c|c|c}
wall\\ time & $\tau$& $a\in A$  &$x\in W$& $s\in W$ & $y\in W$ & $b \in B$ & step  \\
\hline
1   &   1   &   a   &   a           &           &       &           &   input \\
1   &   2   &   c   &   a,c         &           &       &           &   input \\
1   &   3   &       &    c          &   [a]     &    a  &           &   transform \\
1   &   4   &       &   c           &   [a]     &       &   a       &   output \\
1   &   5   &       &               &   [a,c]   &   ac  &           &   transform \\
1   &   6   &       &               &   [a,c]   &       &   ac       &   output \\
1   &   7   &       &               &   [a,c]   &       &   [a,c]   &   snapshot \\
2   &   8   &   b    &   b          &   [a,c]   &       &           &   input \\
2   &   9   &   d    &   b,d        &   [a,c]   &       &           &   input \\
2   &   10   &       &   b          &   [c,d]   &  cd   &           &   transform \\
2   &   11   &       &   b          &   [c,d]   &       &      cd     &   output \\
2   &   12   &       &              &   [d,b]    &  db   &           &   transform \\
2   &   13   &       &              &   {\bf [d,b]}    &       &      {\bf db}     &   output \\
\arrayrulecolor{red}\hline
3   &   14   &       &               &   [a,c]         &       &           &   recovery \\
3   &   14   &   b   &   b           &   [a,c]         &       &           &   \\
3   &   14   &   d   &   b,d         &   [a,c]         &       &           &   \\
3   &   14   &       &   b           &   [c,d]         &       &           &   \\
3   &   14   &       &   b           &   [c,d]         &       &           &   \\
3   &   14   &       &               &   [d,b]         &       &           &    \\
3   &   14   &       &               &   {\bf [d,b]}   &       &           &    \\
\arrayrulecolor{red}\hline
4   &   15   &  e    &   e           &   [d,b]   &      &           &   input \\
4   &   16   &       &              &   [b,e]   &   be    &          &   transform \\
4   &   17   &       &              &   [b,e]   &       &   {\bf be}       &   output \\
\end{tabular}
\label{concat_example}
\end {center}
\end{table}

\subsection{Model analysis}

In a classical model proposed by Chandy and Lamport~\cite{Chandy:1985:DSD:214451.214456}, a distributed system is represented as a graph of processes, which can be connected via channels. Each process can own a modifiable internal state, generate {\em events} and send them to other processes through the channels. {\em Global system state} in this model contains processes states and channel states, e.g., elements, which are in-flight at the moment. Distributed asynchronous processing is simulated using permutations of events.

The proposed model is a variation of a classical Chandy-Lamport distributed system model with the following properties and modifications:

\begin{itemize}
    \item Our notion of a streaming system does not provide a concept of {\em operations state} because, as it is shown in~\cite{we2018adbis}, states can be considered as common data items. In this case, a state element is presented in a system until it is transformed into a new state together with new elements. This model allows a binary relation $D$ to capture computations within a graph of processes that is a physical streaming execution graph in our case. Hence, the working set $W_\tau$ is a global state with only channel states in terms of Chandy-Lamport.
    \item Input and output elements $a_\tau$ and $b_\tau$ are special events. This way, {\em storage} and {\em computations} are distinguished. We assume that output elements $B_\tau$ are all data that leaves a system including so-called {\em state snapshots} which are typically used for recovery~\cite{Carbone:2017:SMA:3137765.3137777}. Because of this, we state that $X \subseteq W_\tau \cup B_\tau$ in the transform transition of the working set. In most state-of-the-art stream processing systems, the end-user is external to the system, i.e., a user can observe input and output elements, but not the working set.
    \item Distributed asynchronous computations are modeled through the random choice of an operation that is executed next. In the proposed model, instead of using permutations of data flow elements that fixate an execution route, we suppose that the next transition of the working set is a random variable. The distribution of this variable depends on system architecture.
\end{itemize}

\subsection{Consistency}

The parallel asynchronous nature of distributed stream processing allows us to handle only a {\em probability} of an output element because it can be different from run to run due to element reorderings.

\begin{definition}{Probability of output element}
$P(b_{\tau+1}|A_{\tau}, B_\tau, F)$ is a probability to observe output element $b_{\tau+1}$ considering all previous input and output elements, and recovery function.
\end{definition}

The problem here is that it is hard to define the correct output, because it may significantly vary. Inconsistencies may arise only in case of failure and incorrect recovery. Let us introduce a {\em reference} recovery function that allows us to denote results which are possible to reach without failures.

\begin{definition}{Reference}
$F^{*}$ is a recovery function that restores exactly the same working set as before the failure, $\forall \tau \in \mathbb{N}, F^{*}(A_\tau,B_\tau)=W_\tau$.
\end{definition}

\begin{definition}{Probability of output element with a reference recovery function}
$P(b_{\tau+1}|A_{\tau}, B_\tau, F^{*})$ is a probability to observe output element $b_{\tau+1}$ considering all previous input and output elements, and a reference recovery function.
\end{definition}

Using the notion of a reference recovery function, one can define the correct output.

\begin{definition}{Output element $b_{\tau+1}$ is consistent}
with all previous input and output elements $A_\tau$ and $B_\tau$ if the probability to observe it is non-zero in a system with reference recovery: $P(b_{\tau+1} \mid A_\tau,B_\tau,F^{*})>0$.
\end{definition}

The reference recovery function allows us to express the notion of correct execution in terms of correspondence between input and output elements. In most real cases, input and output elements are the only data that can be observed by the end-user. In real distributed stream processing systems, failures and recoveries can corrupt the output, despite the fact, that in terms of a simple definition of delivery guarantees, all elements are processed exactly-once.

The problem here is that elements can be concatenated in a different order on recovery. Let us demonstrate it by the already mentioned example demonstrated in Figure~\ref{concat} and Table~\ref{concat_example}. During recovery system may reach concatenation state $s=[b,d]$ at $\tau=15$ rather than $s=[d,b]$ due to asynchronous input. In this case, output at $\tau=17$ becomes {\em de} instead of {\em be}. However, {\em de} is inconsistent with the previous output, because element with prefix {\em d} has already been released at $\tau=13$. It is important to note that all input elements within the example are applied to concatenation state {\em  exactly-once}. This simple example demonstrates that informal definition of exactly-once does not guarantee the consistency of output elements.

\subsection{Delivery guarantees}

As we demonstrate further, state-of-the-art stream processing systems prevent inconsistencies illustrated in the example above. However, the informal definition of exactly-once is insufficient to describe the level of data consistency that is provided. Here we introduce regular definitions of delivery guarantees which take this issue into account.

\begin{definition}{System provides for exactly-once}
if it is possible to obtain each output element $b_{\tau+1}$ in a system with a reference recovery fucntion, i.e.,\\
$\forall{\tau \in \mathbb{N}}, b_{\tau+1}\in 2^{\Gamma}: P(b_{\tau+1}|A_{\tau},B_\tau,F)>0 \Rightarrow \\ P(b_{\tau+1}|A_{\tau},B_\tau,F^{*})>0$.
\end{definition}

\begin{definition}{System provides for at-most-once}
if \\
$\exists{A^{0}_{\tau}\subseteq{A_{\tau}}}$ such that \\
$\forall{\tau \in \mathbb{N},{b_{\tau+1}\in 2^{\Gamma}}}: P(b_{\tau+1}|A_{\tau},B_\tau,F)>0 \Rightarrow \\ P(b_{\tau+1}|A^{0}_{\tau},B_\tau,F^{*})>0$.
\end{definition}

\begin{definition}{System provides for at-least-once}
if \\
$\exists{A^{*}_{\tau}\subseteq{2^{A_{\tau}}}}$ such that \\
$\forall{\tau \in \mathbb{N}, {b_{\tau+1} \in 2^{\Gamma}}}: P(b_{\tau+1}|A_{\tau},B_\tau,F)>0 \Rightarrow \\ P(b_{\tau+1}|A^{*}_{\tau},B_\tau,F^{*})>0$.
\end{definition}

Exactly-once states that observed results cannot be distinguished from one of the possible results produced by a system with a reference recovery function. It means that even if data flow contains races and some elements do not commute, output consistency will be preserved. Looking back to the example illustrated in Table~\ref{concat_example}, our formal definition of exactly-once ensures that after recovery system reaches state $[d,b]$, not $[b,d]$, because this state has already influenced output elements.

At-most-once and at-least-once guarantees are the relaxations of exactly-once. The results within these guarantees can be obtained without failures, but with the modification of the input. At-least-once can be reproduced if the input contains duplicated items. At-most-once can be achieved with a reference recovery if some input elements are missed. It is important to note, that regarding at-most-once guarantee we require an input element to be processed atomically with all its derivatives or not processed at all. To the best of our knowledge, none of the stream processing engines supports at-most-once guarantee, so we cannot verify the relevancy of this assumption. It is accessible to provide at-most-once by producing no output at all, but if the output is presented, at-most-once enforcement becomes much more difficult.

In our formal model, the relaxations of exactly-once are defined without diving into recovery mechanisms. Instead, they are described through possible input channel flaws in a system with a reference recovery. This trick allows us to represent invisible system details in terms clear for an external user.

\subsection{Exactly-once and determinism}

Operations that are presented in $D$ can directly affect the complexity of consistency enforcement mechanisms. For example, if all operations are idempotent,  exactly-once can be achieved~\cite{Akidau:2013:MFS:2536222.2536229}. Among common types of operations, non-commutative ones provide significant difficulties in achieving exactly-once.

\begin{definition}{D contains non-commutative operation}
if\\
$\exists (x,y), s_1, s_2 \in \Gamma, s_1 \neq s_2: \\ ((x,y),s_1)\in D, \\ ((y,x),s_1)\notin D, \\ ((y,x),s_2)\in D$.
\end{definition}

The are many non-commutative operations that are commonly used in practice: concatenation, matrix multiplication, cross product, etc. Hence, general-purpose stream processing systems should support them. The problem with such operations we demonstrated above: simple reprocessing of missing elements in case of failure may lead to results inconsistencies.

\begin{definition}{System is deterministic}
if\\
$\forall{\tau\in{\mathbb{N}}, b_{\tau+1}\in{2^{\Gamma}}}:P(b_{\tau+1}|A_{\tau},B_\tau,F^{*})=1$.
\end{definition}

An essential property of a deterministic system is that it preserves the same order of elements before non-commutative operations on each run. We further demonstrate how this property can be used to achieve exactly-once with low performance overhead.

On the other hand, the absence of determinism imposes restrictions on exactly-once implementations. The following theorem denotes the necessary and sufficient conditions for exactly-once in non-deterministic systems with a non-commutative operation in $D$. It demonstrates that if a system is non-deterministic, but supports non-commutative operations, it must save (take a snapshot of) results of non-commutative operations before delivery of output elements that depend on these results.

\begin{figure}[htbp]
  \centering
  \includegraphics[width=0.48\textwidth]{theorem-pic}
  \caption{The scheme of Theorem~\ref{necessary_conditions}}
  \label {theorem-pic}
\end{figure}

\begin{theorem}
\label{necessary_conditions}
If $D$ contains non-commutative transformation and has the following dependencies for some $a_\tau \in \Gamma$:

\begin{enumerate}
  \item[(i)] $x \in Cl_D(a_\tau), y \in Cl_D(a_\tau)$
  \item[(ii)] $((x,y),s)\in D$ through a non-commutative operation
  \item[(iii)] $b_{\tau_1}, b_{\tau_2} \in Cl_D(s), \tau_1 < \tau_2$
\end{enumerate}

\noindent then non-deterministic system supports exactly-once if and only if:

\begin{equation}
\label{theorem_conditions}
  \begin{gathered}
    G = Cl_D(b_{\tau_1}) \cap C_D^{-1}(b_{\tau_2}) \\
    \forall (u, v) \in D, u \in Cl_D(s): v \subset G \Rightarrow u \subset G
  \end{gathered}
\end{equation}

\end{theorem}
\begin{sketch}
$ $\newline

The scheme of the theorem is shown in Figure~\ref{theorem-pic}. The theorem conditions mean that each result of the non-commutative operation must become recoverable before the delivery of output that depends on this result.
$ $\newline

\noindent{\em Necessary condition}\newline

  Assume that conditions~\ref{theorem_conditions} are not satisfied, i.e. $\exists v \subset G, u \not\subset G: (u, v) \in D$, and system fails at time $\tau_1<\tau_f<\tau_2$. Then, to obtain $b_{\tau_2}$ there is a need to recompute $v$, $u$ and therefore $s$. However, due to asynchronous distributed processing and non-commutative transformation, system can reach not exactly $s$ such that $((x,y), s) \in D$, but $s':((y,x),s')\in D$. In this case, after recovery element $b_{\tau_2}$ will be delivered, but it will depend not on $s$, but on $s'$: $b_{\tau_2}\in Cl_D(s')$. This is a contradiction, because $b_\tau$ has been already delivered and $P(b_{\tau_2}\in Cl_D(s')|\{a_\tau\},\{b_{\tau_1} \in Cl_D(s) \})=0$.
$ $\newline

\noindent{\em Sufficient condition}
\newline

Let us assume that a  system fails at time $\tau_f$. If $\tau_f < \tau_1$ or $\tau_f > \tau_2$,  exactly-once is obviously satisfied. Assume that $\tau_1<\tau_f<\tau_2$. In this case, $b_{\tau_1}\in B_{\tau_f}\subset B_{\tau_2}$. Hence, $b_{\tau_2}$ can be restored directly from $b_{\tau_1}$ without reprocessing of s, i.e. $F(a_\tau,b_{\tau_1})=b_{\tau_2}$ and $b_{\tau_1}, b_{\tau_2} \in Cl_D(s)$ after recovery, thus $P(b_{\tau_2}\in Cl_D(s)|\{a_\tau\},\{b_{\tau_1} \in Cl_D(s) \})>0$.
\end{sketch}

We assume   in this  theorem    that input element $a_\tau$ is split into elements $x,y$. The same behavior can be reproduced if two input elements $a_\tau$ and $a_{\tau+1}$ enter a system through asynchronous channels. In general, this behavior is natural for stream processing systems because elements are processed one-by-one without synchronization and order enforcement.

This theorem has direct practical implications for non-deterministic systems:
\begin{itemize}
    \item {\bf Output elements must wait until the snapshot is taken}. If a system aims at providing exactly-once, it must output elements only if there exists a snapshot that contains results of non-commutative operations. The problem here is that a system is usually not aware of user-defined operations and cannot distinguish commutative and non-commutative operations, so it must wait even if all elements commutate.
    \item {\bf Latency is affected by the period of snapshotting}. The consideration above implies that the lower bound of latency in the worst case in non-deterministic systems is the snapshotting period, together with the duration of taking a snapshot. There is a trade-off between latency and the frequency of taking snapshots because too frequent snapshotting can cause high extra load, while rare snapshots lead to high latency.
\end{itemize}

It is important to note that the proposed model is suitable not only for the formal analysis of the properties of exactly-once but for a deeper understanding of the other aspects of stream processing. While these topics are promising as well, they are out of the scope of this paper.

\section {Exactly-once implementations}
\label{fs-eo-impl}

\subsection{MillWheel}

 The $\Gamma$ is all possible streaming {\em records}. Dependency relation $D$ is defined using a graph of user-defined transformations.
 To ensure fault tolerance,   MillWheel employs a {\em strong productions}~\cite{Akidau:2013:MFS:2536222.2536229}   mechanism that stores persistently input and output of operation for each new input item.
 Thus each streaming element is saved before it may influence other elements or operation states.
 Recovery function $F$ resends all saved records in case of failure, and each operation deduplicates input that has been already processed.

The necessary condition of exactly-once from Theorem~\ref{necessary_conditions} claims that each element $s \in \Gamma$ obtained through a non-commutative operation must be persistently saved before any other element $b_{\tau} \in Cl_D(s)$ that depends on $s$ is released. Strong productions mechanism ensures that this condition is satisfied, i.e., if some element $b_\tau$ is released, it is guaranteed that its dependencies were released earlier (saved to persistent storage). The idea of this method is shown in Figure~\ref{millwheel}. It demonstrates that in MillWheel, all elements become recoverable, so there is no need to reprocess them again from an input item in case of failure.

\begin{figure}[htbp]
  \centering
  \includegraphics[width=0.48\textwidth]{millwheel}
  \caption{Strong productions mechanism}
  \label{millwheel}
\end{figure}

Such behavior is also called {\em effective determinism}~\cite{akidau2018streaming} because computations become deterministic until the persistent storage is cleared. Strong productions method guarantees that even if many possible results of a non-commutative operation may be obtained due to races, only one of them is computed and saved. The price for such exactly-once enforcement is an overhead on external writes on each transformation in a physical graph.

\subsection{Spark streaming}

In Spark, the  $\Gamma$   is a set of all possible small collections of input items called  {\em RDD} records that are processed atomically.
Dependency relation on the power set of $\Gamma$ is also defined using a directed acyclic graph of user operations.
Spark inherits main properties of batch processing systems:  each new stage of computations is started only after the previous one is completed and recovery function $F$ starts reprocessing of a micro-batch from the beginning in case of failure.

The condition for exactly-once from Theorem~\ref{necessary_conditions} is satisfied because all elements within the micro-batch are released atomically. Elements from various micro-batches can interact only through persistently stored state.
Output elements that are ready to be delivered to the end-user must wait until the whole micro-batch is completely processed.
Therefore, if two output elements $b_{\tau_1},b_{\tau_2} \in Cl_D(s)$ depend on a single item $s$, it is guaranteed that $\tau_1=\tau_2$. The illustration of this behavior is shown in Figure~\ref{spark_flink}.

\begin{figure}[htbp]
  \centering
  \includegraphics[width=0.48\textwidth]{spark-flink}
  \caption{Micro-batching and transactional approach}
  \label{spark_flink}
\end{figure}

\begin{figure*}[tbp]
  \centering
  \includegraphics[width=0.78\textwidth]{arch.pdf}
  \caption{The overview of an architecture for drifting state implementation}
  \label {arch}
\end{figure*}

\subsection{Flink}

In Flink, the  $\Gamma$ is represented as all {\em StreamRecords}. Relation $D$ is defined in the form of a directed acyclic graph consisting of user operations.
Flink periodically saves information needed for recovery by injecting particular elements called {\em checkpoints} into the input stream.
Intervals  between checkpoints are called {\em epochs}. Checkpoints go through the same network channels as common elements and push all inverted dependencies of inputs through the system.
Each operation prepares data to save independently at the moment of checkpoint arrival. Prepared data is committed to external storage when checkpoint passes through the whole data flow. Output elements are delivered to the end-user only after the commit.
Recovery function $F$ reprocesses last non-complete epochs.

This mechanism ensures that all elements within an epoch are processed atomically and all interactions between elements from different epochs are possible only through persistent state.
Hence, as it is shown in Figure~\ref{spark_flink},
 if two output elements $b_{\tau_1},b_{\tau_2} \in Cl_D(s)$ depend on a single item $s$,
 it is guaranteed that $\tau_1=\tau_2$.
This ensures that the necessary condition of exactly-once from Theorem~\ref{necessary_conditions} is satisfied.
Such a method is quite similar to the micro-batching technique used in Spark.
The differences are: elements are buffered after their processing is done and  multiple epochs can be processed simultaneously.

\section{Exactly-once over determinism}

\label {fs-consistency-section}

In the previous section, we demonstrated how state-of-the-art stream processing systems handle non-deterministic behavior in order to achieve~ exactly-once. All these systems make state recoverable before output elements which depend on this state are released. As we demonstrate further, such behavior can significantly increase the processing latency of individual elements.

The condition from the Theorem~\ref{necessary_conditions} can be relaxed for a deterministic system because determinism guarantees order enforcement before non-commutative operations. If a system is deterministic, it is possible to recompute states of non-commutative operations consistently. Hence, such a system can release an output element before a snapshot is taken because it can reproduce the same state in case of failure. It means that even if elements are divided into the epochs like in Apache Flink, and a snapshot is taken once per epoch, ready-to-release output elements should not wait until the epoch is committed in order to be delivered. The limitation of this approach is that only deterministic operations (e.g. without the usage of random values) are allowed in a data flow.

To combine the determinism with  exactly-once we need to design protocols for recovery function $F$ and saving data needed for correct restoring. In this section, we describe protocols for exactly-once enforcement on top of a lightweight deterministic model for distributed stream processing called {\em drifting state}~\cite{we2018adbis}. This model is implemented in~\FlameStream\ processing system~\cite{we2018beyondmr}.

In~\FlameStream\, computations are deterministic due to a (speculative) maintenance of a pre-defined total order on elements before each order-sensitive operation. The order can be defined using various methods~\cite{we2018seim}, and we assume that $\forall x_1,x_2\in \Gamma, \exists t(x): x_1 < x_2 \Longleftrightarrow t(x_1) < t(x_2)$. In order to achieve exactly-once on top of a deterministic stream processing system we propose the following way:
\begin{itemize}
    \item Periodically save (take a snapshot of) operation states
    \item Consistently restore these states and replay missed input elements in case of failure
    \item Ensure that output elements which have been already released will not be duplicated after recovery and input reprocessing
\end{itemize}

We do not enforce a strict architecture of the system, but assume that there are several functional agents:
\begin{itemize}
    \item Coordinator manages snapshotting and recovery.
    \item Cluster state manager is used to keep service information for recovery.
    \item Persistent storage is needed for reliable storing of state snapshots. In case of failures, the state snapshot is recovered from persistent storage.
    \item Data producer that can replay some set of previous input elements with the same $t(a)$.
    \item Data consumer that is responsible for output elements receiving. The exact requirements for data consumer are detailed further in this section.
    \item Node is an executor of user-defined operations. The computation can be balanced through the distribution of data elements among nodes. Each Node has a {\em barrier} that delivers output elements to the end-user.
\end{itemize}

The implementation of this architecture in~\FlameStream\ processing engine is demonstrated in Figure~\ref{arch}. Apache ZooKeeper is used for cluster state management. As persistent storage, one can use a distributed file system or database (e.g., HDFS, S3, MongoDB, GFS, HBase, etc.). Data producers may vary as well: the role of $t(a)$ can be played by any monotonic sequence, e.g., offsets in Kafka.

\subsection{Snapshotting}

\subsubsection{Operation states}

In order to periodically save operation states, there is a need to determine which input elements affect them.
 We have to trace reversed dependencies: for each state element $s$ we desire to determine such input elements $\{a_i\}$ that $\forall i, s \in Cl_D^{-1}(a_i)$. Otherwise, it may be unclear, which input elements must be reprocessed during recovery. In Apache Flink, it is implemented through specific streaming elements which play the role of notifications that a determined set of input elements have been processed. In~\FlameStream\ this mechanism is implemented using a modification of {\em Acker} agent from Apache Storm~\cite{apache:storm}.

Assuming that the mechanism for detection of which input elements influence states is implemented, the protocol of state snapshotting for {\em Coordinator} and {\em nodes} is the following:

\begin{itemize}
    \item Coordinator decides that snapshot should be taken and enables a mechanism to detect which input elements have been processed since the previous snapshot.
    \item On the notification, nodes asynchronously make operation states recoverable and send to Coordinator the acceptance message.
    \item When the Coordinator receives all acceptance messages, it saves the information about which input elements belong to this snapshot and other service information about the snapshot. In general, it is sufficient to save only $t(a)$ of the last input element that affects the snapshot.
\end{itemize}

It is worth to note that the proposed protocol is similar to the transactional (variation of 2PC) state snapshotting protocol used in Flink~\cite{Carbone:2017:SMA:3137765.3137777}. The critical difference is that in our method, output releasing agents (barriers) do not take part in a distributed transaction, because in a deterministic system there is no need to wait until the snapshot is taken in order to release output elements consistently. The scheme of the protocol used in Apache Flink is shown in Figure~\ref{protocol_flink}. As it is demonstrated, output elements delivery (stage 4) is allowed only after commit (stage 3). Modified state snapshotting protocol for a deterministic system is demonstrated in Figure~\ref{protocol_fs}. One can note that elements delivery is independent of the snapshotting protocol. This difference determines the significant latency decrease that is demonstrated further in experiments.

\begin{figure}[htbp]
  \centering
  \includegraphics[width=0.42\textwidth]{protocol-flink}
  \caption{State snapshotting protocol in Apache Flink}
  \label{protocol_flink}
\end{figure}

\begin{figure}[htbp]
  \centering
  \includegraphics[width=0.42\textwidth]{protocol-fs}
  \caption{State snapshotting protocol in a deterministic system}
  \label{protocol_fs}
\end{figure}

\subsubsection{Last output element}

In order to preserve the deterministic outcome, the Barrier must release output items with monotonically increasing $t(x)$. Hence, the Barrier can filter out any items with $t(x)$ less than or equal to the $t(x)$ of the last released item $t_{last}$ in order to preserve exactly-once after recovery. To implement this mechanism, there is a need to deliver output items and update $t_{last}$ atomically. To solve this problem, we require the following output protocol between a {\em barrier} and a {\em data consumer}:

\begin{itemize}
    \item On each output delivery, Barrier sends a bundle to the data consumer. This bundle contains an output item and $t_{last}$. The Consumer must acknowledge that it received the bundle.
    \item Barrier does not send new output bundle until the previous one is not acknowledged.
    \item Consumer must return last received bundle on Barrier's request.
\end{itemize}

This protocol guarantees that $t_{last}$ and released items are always consistent with each other. It implies that the Barrier can request the last released bundle and fetch $t_{last}$ after recovery to avoid duplicates, which can be generated during input elements reprocessing.

Thus, on the one hand, we delegate the part of the basic functionality to data consumers. On the other hand, the requirement for a data consumer is not so strong and can be naturally satisfied by real-world consumers (HDFS, Kafka, databases, etc.).

\subsection{Recovery}

Typically, distributed systems take into consideration the following types of failures:
\begin{itemize}
    \item Packet loss
    \item Node failure
    \item Network partitioning
\end{itemize}

Network partitioning is the particular case of failure because in this case, computations cannot be restarted. We believe that in this case, stream processing does not make sense. To the best of our knowledge, there are no open-source stream processing systems that tolerate network partitioning.

Failure detection can be implemented in different ways~\cite{hayashibara2002failure}, which are out of the scope of this paper. In~\FlameStream\ it is implemented using {\em Acker}~\cite{we2018adbis}. In the case of packet loss or node failure, a failure detector mechanism can enforce the Coordinator to begin computations restart from the last successful snapshot. Restart protocol includes the following steps:

\begin{itemize}
    \item Coordinator broadcasts a notification to begin the recovery process.
    \item Operations receive these notifications and fetch their states from state storage. After that, they send an acknowledgment that they are ready for Processing to the Coordinator.
    \item Barriers request the last released bundle from data consumers and send acknowledgments that they are ready for Processing to the Coordinator.
    \item When the Coordinator receives all acknowledgments from groupings and barriers, it requests data producer to replay starting from the $t(a)$ of the last snapshot.
\end{itemize}

The proposed protocol guarantees the following properties that allow preserving~ exactly-once:

\begin{itemize}
    \item Processing does not restart until all operations obtain consistent states. The consistency of these states is guaranteed by the state snapshotting protocol. Therefore, the elements are not lost.
    \item Duplicates are not produced because, at the moment when Processing is restarted, it is ensured that Barrier has obtained the last released $t(x)$ and can filter out extra items.
\end{itemize}

\section {Experiments}

\label {fs-experiments-seciton}

\subsection{Setup}
A series of experiments were performed in order to analyze the overall performance of the proposed approach. For experiments, we use an open-source implementation of the drifting state model called~\FlameStream. \FlameStream\ is a distributed stream processing engine implemented in Java using Akka framework. \FlameStream\ can be deployed on a hardware cluster of computational units that we call nodes. We assume that each node is connected through a network with all other nodes.

We used a problem of incremental inverted index maintenance over a stream of text items.
Building inverted index is implemented as a MapReduce transformation in a streaming manner. The scheme is shown in Figure~\ref{index}:

\begin{itemize}
    \item Map phase includes conversion of input documents into the key-value pairs {\it (word; word positions within the page)}
    \item Reduce phase consists of combining word positions for the corresponding word into the single index structure
\end{itemize}

The Reduce phase produces the change records of the inverted index structure, to make this algorithm suitable for stream processing systems. It implies that each input page triggers the output of the corresponding change records of the full index. In \FlameStream\ this algorithm is implemented as the typical conversion of MapReduce transformation, which is shown in~\cite{we2018seim}.

\begin{figure}[htbp]
  \centering
  \includegraphics[width=0.50\textwidth]{index}
  \caption{The inverted index pipeline}
  \label {index}
\end{figure}

We choose the problem  of  an inverted index maintenance  because it satisfies the following properties:

\begin{itemize}
    \item Operation that generates change records is non-commutative
    \item The computational workflow    contains network shuffle that can violate the ordering constraints
    \item Consistency guarantees are strongly required because the inconsistent index does not make sense for many applications
    \item The workload is unbalanced due to Zipf's law
\end{itemize}

Notably, building an inverted index in a streaming manner can be the halfway task between the generation of documents and consuming index updates by search infrastructure. In the real world, this scenario can be found in freshness-aware systems, e.g., news processing engines.

By the notion of {\it latency} we assume the time between two events:

\begin{enumerate}
    \item Input page is taken into the stream
    \item All the change records for the page leave the stream
\end{enumerate}

Our experiments were performed on the cluster of 10 Amazon EC2 micro instances with 1GB RAM and 1 core CPU. We used Wikipedia articles as a dataset. Documents per second input rate is 50 because higher rates lead to enabling of backpressure mechanisms in an industrial system that we compare with. RocksDB~\cite{rocksdb} is used as a storage for the state. The role of data producer and data consumer is played by a custom server application that sends and receives data through socket and measures the latency.

\subsection{Overhead and recovery}
The performance of the proposed deterministic model within the same stream processing task is deeply analyzed in~\cite{we2018seim}. In this paper, we aim to evaluate the overhead on providing consistency guarantees and the time needed for the full recovery.

Figures~\ref{comparison50}, ~\ref{comparison500}, and ~\ref{comparison1000} show the latencies of \FlameStream\ within distinct times between checkpoints. As expected, the overhead on exactly-once enforcement is low (less than 10 ms), and it does not depend on the time between checkpoints. Slight overhead can be explained by the fact that asynchronous state snapshotting is executed on single-core nodes. The time between checkpoints does not influence latency because output elements delivery and state snapshotting mechanisms are independent in our model.

The system behavior in case of failures and recoveries with 1000 ms between checkpoints is demonstrated in Figure~\ref{recovery}. It is shown that the system can perform recovery processes in an adequate time. Existing latency spikes are caused by the replay process, JVM restart, etc.

\begin{figure}[htbp]
  \centering
  \includegraphics[width=0.48\textwidth]{blink-2}
  \caption{The latencies of \FlameStream\ during three artificially reproduced failures and recoveries with 1000 ms between checkpoints}
  \label {recovery}
\end{figure}

\subsection{Comparison with an industrial system}
One of the most important goals of the experiments is the performance comparison with an industrial solution regarding latency. Apache Flink has been chosen for evaluation because it is a state-of-the-art stream processing system that provides similar functionality and achieves low latency in     q             the real-world scenarios~\cite{S7530084}.

For Apache Flink, the algorithm for building the inverted index is relies on the usage of {\it FlatMapFunction} for map step and stateful {\it RichMapFunction} for reduce step and for producing the change records. The network buffer timeout is set to 0 to minimize latency. Custom {\it TwoPhaseCommitSinkFunction} that buffers output items in memory until a transaction is committed is used for experiments that require exactly-once semantics.

{\it FsStateBackend} with the local file system is used for storing the state, because {\it RocksDBStateBackend} requires saving state to RocksDB on each update that leads to additional overhead. {\it FsStateBackend} stores state on the disk only on checkpoints and do not provide an additional overhead against RocksDB storage in \FlameStream, so it is fairer to use it rather than {\it RocksDBStateBackend} for comparison purposes.

In this paper, we compare $50^{th}$, $75^{th}$, $95^{th}$, and $99^{th}$ percentile of distributions, which clearly represent the performance from the perspective of the users' experience.

\begin{figure}[htbp]
  \centering
  \includegraphics[width=.48\textwidth]{comparison50}
  \caption{\FlameStream\ and Flink latencies with 50ms between checkpoints}
  \label{comparison50}
\end{figure}

\begin{figure}[htbp]
  \centering
  \includegraphics[width=.48\textwidth]{comparison500}
  \caption{\FlameStream\ and Flink latencies with 500ms between checkpoints}
  \label{comparison500}
\end{figure}

Figures~\ref{comparison50}, ~\ref{comparison500}, and ~\ref{comparison1000} demonstrate      the comparison of latencies between \FlameStream\ and Flink within distinct times between checkpoints, and different guarantees on data. Without guarantees, the latencies of \FlameStream\ and Flink do not significantly differ. However, for exactly-once, Flink's latency is dramatically higher, and it directly depends on the time between checkpoints. Nevertheless, such behavior is expected, because Flink needs to take state snapshot and release output items within a single transaction to ensure that all states of non-commutative operations are persistently saved. There are no hints implemented in Flink which could mark an operation as commutative, hence it waits until states of all operations are stored before output delivery.
On the other hand, the property of determinism allows \FlameStream\ to avoid synchronization state snapshotting and output delivery. This fact makes it possible to achieve exactly-once with low overhead.

\begin{figure}[htbp]
  \centering
  \includegraphics[width=.48\textwidth]{comparison1000}
  \caption{\FlameStream\ and Flink latencies with 1000ms between checkpoints}
  \label{comparison1000}
\end{figure}

\section {Related work}

\label {fs-related-seciton}

Techniques for providing exactly-once~\cite{Carbone:2017:SMA:3137765.3137777, Akidau:2013:MFS:2536222.2536229, Zaharia:2012:DSE:2342763.2342773} are discussed   in details in sections~\ref{fs-intro-seciton} and~\ref{fs-eo-impl}. Many prior works in the field of stream processing do not consider exactly-once maintenance.
For instance, Aurora~\cite{Abadi:2003:ANM:950481.950485} and Borealis~\cite{abadi2005design} do not provide any guarantees on data at all. Some other systems provide only partial consistency. Apache Storm~\cite{apache:storm} supports message tracking mechanism that prevents the loss of data.
However, exactly-once semantics is not provided, because duplicates are still possible. Twitter Heron, that was presented as the next generation of Apache Storm~\cite{Kulkarni:2015:THS:2723372.2742788}, does not provide for exactly-once as well.
Samza~\cite{Noghabi:2017:SSS:3137765.3137770} also implements fairly similar to Storm model and has the same consistency guarantees.

Prior works on stream processing formalization concentrate on operations specification rather than delivery guarantees. Logical foundation for specifying streaming computations is discussed in~\cite{alur2018interfaces}. Declarative algebraic notations for the streaming queries are introduced in~\cite{halle2014formalization}. Another direction in streaming formalization is designing frameworks to define operations semantics~\cite{beck2018lars}.

\section {Conclusion}

\label {fs-conclusion-seciton}

We introduced a formal, conceptual framework for modeling consistency properties for any stream processing system. We demonstrated how the behavior of state-of-the-art research and industrial systems could be described in terms of the proposed framework. It was shown that the property of determinism is tightly connected with the concept of of exactly-once. We proved that non-deterministic systems must persistently save a state of non-commutative operations before output delivery in order to achieve exactly-once. Most of the state-of-the-art stream processing systems use one of the following approaches to overcome this problem:

\begin{itemize}
    \item Inherit exactly-once from batch processing using small-sized batches (micro-batching)
    \item Apply distributed transaction control protocols which guarantee that states are saved before delivery of elements affected by these states
    \item Write results of an operation to external storage on each input element
\end{itemize}

All these methods experience difficulties with working under low-latency requirements (less than a second). In the first case, latency cannot be lower than the batching period, in the second case, the distributed two-phase commit may result in a significant increase of latency, while in the third case latency is bounded below by the duration of external writes.

Using our formal inference, we designed mechanisms for achieving exactly-once on top of {\em drifting state} technique introduced in our previous work~\cite{we2018adbis}. Drifting state provides inexpensive determinism due to optimistic nature and low overhead on a single buffer per any stateful data flow. Because of the determinism, the protocols provide the following features:

\begin{itemize}
    \item Elements are processed in a pure streaming manner without input buffering
    \item The processes of business-logic computations, state snapshotting and delivery of output items work asynchronously and independently
    \item Exactly-once is preserved
\end{itemize}

We implemented the prototype of the proposed technique to examine its performance. Our experiments demonstrated that the introduced protocols for fault tolerance are scalable and provide remarkably low overhead within different computational layouts. Furthermore, the comparison with the industrial stream processing solution indicated that our prototype could provide significantly lower latency under exactly-once requirement.

\balance

\bibliographystyle{IEEEtran}

redpajama_set_name: RedPajamaArXiv


Services provided by MarketInsightsReports (An Ameliorate Solutions Group Company) to you are subject to the following terms and conditions. If you purchase any service at MarketInsightsReports.com, you accept these conditions thus please read them carefully. These Terms and Conditions are subject to each and every transaction you make, so it is your responsibility to check the Terms and Conditions before placing an order.
Any confidential information received in the reports is provided by the publisher thus safe keeping of the information is subject to the publisher and not MarketInsightsReports. MarketInsightsReports makes no representations or warranties of any kind express or implied, as to the operation of this site or the information, content, materials, or products included on this site. You expressly agree that your use of this site is at your sole risk. MarketInsightsReports does not warrant that product descriptions or other content of this site is accurate, complete, reliable, current, or error-free.
As a distributor of content published and supplied by third parties MarketInsightsReports has no editorial control over said content. All information concerning the Market Reports included on our website are provided to us by our publisher partners, which are globally recognizable agencies. MarketInsightsReports is not responsible for preparing or producing the reports but due to our experience in marketing field, we act as reselling agents helping to promote and sell the reports of our publisher partners.


From back in August.. my my time has flown. The wedding is coming up in only a few short weeks! Jimi & Teresa travelled to Bali whilst Dan and I were there in August and we spent a couple of days shooting, eating, shooting and eating. It was awesome, seeing so many of the sights with them.. incorporating them into the local landscape and having a jolly old time. I cant wait to go back to Bali and shoot some more, personally and professionally (especially since I know so many fantastic spots now). There will be more of these two included in my upcoming film post from the trip, but for now.. here is Jimi & Teresa.
Check out the first Portrait Session with Jimi and Teresa here.
If you like what you see, why not contact me to discuss your own portrait session, pre-wedding session or wedding.
These Bali shots are awesome – is this at Bedugal? I love those evening shots.
Great work man! These look awesome!


How have ecosystems changed over the last few decades and how will they continue to change in a future warming world, and how well can we capture these changes from satellite measurements?
How interconnected are deep and surface communities, do they have differing levels of vulnerability, and how are they changing in relation to each other?
What are the regional variations in vulnerability of the marine ecosystems?
How can we best determine and quantify ecological vulnerability metrics using a combination of ocean color imagery and a numerical model?
Characterize spatial and temporal variability of satellite-estimated optical properties and satellite-derived products including backscattering, absorption coefficients, Chl, particle size-spectrum, phytoplankton functional type and size.
Test the algorithms underpinning the satellite-derived products using the "synthetic data" of the ocean model, where both radiative fluxes and properties of the water column are known.
Qualitatively and quantitatively evaluate the performance of the global simulations of ocean plankton and optical properties using the remote sensing reflectance and other diagnostic products from remote sensing.
Use the ocean simulations and simpler theoretical explorations to interpret the physical-biological mechanisms underpinning regional, seasonal and inter-annual changes in the character of plankton populations.
Examine the implications of the observed and simulated ecosystem variability for biogeochemical fluxes, including carbon cycling and air-sea exchange.
A detailed, mechanistic understanding of the uptake of carbon by the ocean is required to monitor changes in the ocean carbon sink, and to predict its future change. The sinking of biogenic particles from the surface ocean and their remineralization at depth constitutes the "biological pump" portion of ocean carbon sink and is determined, in large part, by the phytoplankton community size structure of the surface ocean. Previous studies suggest that satellite-retrieved chlorophyll concentration and primary production are not enough to predict changes in the removal of organic material from surface waters and its fate at depth, yet these have been the only satellite-derived variables available to us until very recently. This project aims to make additional progress by taking advantage of recent satellite-derived retrievals of phytoplankton size distribution (percent microplankton, Sfm) that have been shown to have high fidelity for the global ocean (Mouw and Yoder, 2010).
Numerical models of the global ocean ecosystems have typically had only a fixed number of phytoplankton species and a few pathways for production of particulate detritus that then sinks and remineralizes at fixed rates. A novel self-organizing ecosystem model (Follows et al. 2007), the "Darwin model", has many tens to hundreds of phytoplankton species and so can capture more accurately the evolving distribution of the phytoplankton community. This model will be an ideal testbed for assessing the importance of phytoplankton community size structure to the biological pump.
Do satellite retrievals of the phytoplankton size structure improve empirical algorithms for the export of biogenic particles from the surface ocean and their remineralization at depth?
How does variability in surface ocean phytoplankton size structure impact the biological pump of carbon to the deep ocean?
The nature and extent of changing sea ice over the Bering Sea shelf and the timing of its retreat have a profound impact on the timing and nature of the spring phytoplankton bloom. However, there is little knowledge of community compositional variability of the phytoplankton blooms and how the zooplankton community may respond or be impacted by such changes.
The overarching goal of this study is to understand the response of phytoplankton and zooplankton communities to changing ice dynamics in the Bering Sea. This project (1) integrates ship measurements of phytoplankton species composition, their size structure and productivity to understand the potential consequences on zooplankton populations measured from moored acoustical observations, (2) integrates ship-based observations of size structure and photo-physiological properties of phytoplankton with optical measurements to refine satellite algorithms for the retrieval of phytoplankton size composition, chlorophyll concentration, and primary production and (3) utilizes in situ observations and satellite observations of ocean color and of sea-ice conditions to improve modeled physical, biogeochemical and ecosystem dynamics.
What are the dominant physical and chemical ice-mediated controls on phytoplankton community structure and size fractionated productivity; how are these controls changing with decreasing sea ice extent and concentration?
How do zooplankton size and community structure vary with sea ice mediated changes in bloom timing?
Is there a clear relationship between phytoplankton bloom dynamics and community composition, zooplankton biomass and community structure and sea ice dynamics, how have these changed over our data record and how may they change in the future?


text:
US-China co-operation, talks boost stocks
Global shares have rallied as investors cheer signs of improving China-American relations and look towards more governments gradually reopening their economies.
The positive mood stands in sharp contrast to the economic data. US unemployment numbers due later on Friday are expected to be the worst in a lifetime as the coronavirus pandemic ravages economies.
Top US and Chinese trade representatives discussed their Phase One trade deal on Friday, with China saying they agreed to improve the atmosphere for its implementation and the United States saying both sides expected obligations to be met.
Asian markets, which had opened higher after gains on Wall Street, were lifted by news of a phone call between US and China trade representatives.
This calmed investors' fears about renewed trade tensions after US President Donald Trump and other top officials blamed China for hundreds of thousands of coronavirus deaths and threatened punitive action, including possible tariffs and shifting supply chains away from China.
"The threat of a breakdown in negotiations for now at least has been averted, though of course, the president continues to persist with some of his comments regarding the COVID outbreak but at least, from the trade side, it looks as though the participants involved have dialled down the temperature a little bit," said Jeremy Stretch, head of G10 FX strategy at CIBC Capital Markets.
Improving sentiment also put European futures comfortably in the black, with the pan-European Stoxx 600 up 0.6 per cent at 339.86 points, Germany's DAX up 0.75 per cent at 10,840 and France's CAC 40 0.6 per cent higher at 4526.
US stock futures for the S&P 500 were up 0.92 per cent to 2906.
The MSCI world equity index, which tracks shares in 49 countries, was half a per cent higher, while MSCI's main European Index was up 0.64 per cent.
The Euro STOXX 600 was 0.6 per cent higher, helped by the construction and materials sector.
Oil prices climbed as countries including Australia moved ahead with plans to relax economic and social lockdowns put in place to halt the pandemic, kindling market hopes for a boost in demand for crude and its products.
Brent crude was up 77 cents, or 2.6%, at $30.23 a barrel, while U.S. oil gained $1.06, or 4.5%, to $24.61 a barrel.
Both contracts are heading for a second week of gains after the lows of April.
Core European bond yields were little changed, and the spread between German and Italian 10-year government bonds narrowed by six basis points.
Unemployment data due later in the day is expected to show a historic hit to the US labour market.
Forecasters expect the US economy likely lost a staggering 22 million jobs in April, in what would be the steepest plunge in payrolls since the Great Depression and the starkest sign yet of how the virus pandemic is battering the world's top economy.
"The situation on the US labour market is a disaster - that is no secret," wrote Commerzbank strategist Thu Lan Nguyen in a note to clients.
"And today, everyone's attention is going to focus on the labour market report for April to find out just how bad the disaster is."
The dollar slipped against a basket of six major currencies in early trading as investors defied the broader sense of doom. By early European trading, the dollar was edging up again, suggesting the optimism would not endure.
A public holiday in Britain means liquidity will be thin as London markets are closed.
Gold hovered near a two-week high, hit in the previous session, as investors awaited the US jobs report, with spot gold holding just below the highest since April 27.
ASX gains as virus lockdowns set to ease
JC Penney to file for bankruptcy: sources

redpajama_set_name: RedPajamaCommonCrawl


text:
Les éditions des Chavonnes
Les Grecs
Les Chrétiens
Les anglo-saxons
Politique Energétique
Laicité
Zoroastrisme
Science de la vie
Origine de la vie
A brief history of Mesopotamia
5 janvier 2017 leseditionsdeschavonnes In english Laisser un commentaire
According to the course of Professor Kenneth W.HARL
Africa has given birth to humanity. But it's Mesopotamia who entered in history. It is indeed in Mesopotamia that appeared writing, livestock, agriculture, the first planned cities and their administration, the first monarchies, the first dynasties, the first temples and the first wars too. Before the Islamic State has all broken, it appeared useful to small-COMBES father to leave with this modest article, some traces of what is considered the ancestor of all civilizations, our mother the Mesopotamia.
A summary of the history of Mesopotamia
Etymologically, Mesopotamia means between the two rivers, namely, the Euphrates and the Tigris, which puts us now southern Iraq, along the Persian Gulf. It is here that humanity emerged from the Neolithic to make history.
To begin, a few historical markers
The first traces unearthed by archaeologists date back to 10,000 BC. Syria in particular, the first masonry evidence has been discovered. Breeding appears 1,000 years later in Iraq, and agriculture and the domestication of sheep and goats (in Iran). The ceramic appears to 7500 BC in Iran, followed by the loom in Anatolia (Turkey). Wheat and barley are grown at the same time in Iraq and Palestine and Anatolia high pig.
Mesopotamia map
Birth of civilization in Sumer
Human civilization developed along three major river together: along the Nile; in the Indus Valley; but, above all, between the Tigris and Euphrates, in what is commonly called the « fertile crescent ».
The first villages and cities early Neolithic (9000 BC)
The oldest traces of villages in Mesopotamia dating back to 6500 years BC (well before the Egyptian pyramids or the modest town of the Indus). The site Jericho , in the West Bank today, is even older: it would have been occupied by the first sedentary since 9000 BC.
clay tablet
The villages of Sumer were built by the first farmers who came here to enjoy the fertile silt. An estimated 20,000 the number of inhabitants in Uruk (or Uruk) . It was at that time the most densely populated region of the globe. Cities are created around a temple, sometimes built on top of the ziggurats (the stepped pyramids). In the Bible, the description of the Tower of Babel was probably inspired by the first pyramids.
A theocracy is taking place, along with a clergy, with the summit, a King (representative of God on earth of the city), the middle nobility, priests, warriors, scribes and, at the bottom , craftsmen.
Birth of writing: the story begins in Sumer (3500 BC)
The writing appears around 3500 BC and takes the form of wedges (cuneiform) embedded in clay tablets. Originally mainly accountants, small texts cover to small all fields of administration, especially during the period called » Uruk » (city-state appeared around 3200 BC).
Writing allows the consolidation of the state, more and more centralized, orders reaching more easily to the governors of the most remote countries. His teaching is for the elite (the scribes), for he who has mastered the art of writing has the power. Democratization will therefore few millennia …
Sumer important neighboring regions (Indus or Egypt) commodities and slaves. It exports its know-how, including the art of writing. Further north, the region of Akkad, populated by Semitic peoples, also adopts the Sumerian writing. Essentially originally pictograms, it quickly acquires the phonetic principle (a drawing = one sound). The Phoenicians even simplify writing by introducing the alphabet (limited to consonants), itself adopted by the Greeks (who added the vowels) and then the Romans, to us, the heirs of the Sumerian …
Birth of mathematics
It seems that the Sumerians have acquired profound knowledge in mathematics, as the Pythagorean theorem, the extraction of cube roots, the sexagesimal system (which is still used).
other innovations
Agriculture, terracotta bricks, irrigation, textile wheel: all these important inventions in the history of mankind originated in Sumer.
A force to grow, the Sumerian city-states eventually touch. Uruk, Ur, Elam are among the most important. They gradually come into contact with civilizations to the north, different in language (Semitic), but who have incorporated the Sumerian innovations, including its administrative science. The largest of the northern cities Akkad will finally be a first territorial empire by absorbing its southern neighbors.
The Old Testament is entirely Sumer
Sumer is located at the mouth of the Euphrates and Tigris, twin rivers that flow into the Persian Gulf. The Old Testament gives birth to humanity Sumer . It is from there, south of present Iraq that left Abraham , the patriarch common to the three great monotheistic religions, around 3000 BC, leaving his hometown of Ur to reach the Promised Land ( Canaan : the current Israel).
Abraham , his two son, the father of the people:
Hebrew (by Isaac, his legitimate son by his wife Sarai);
and Arabic (with Ishmael , the son of his servant Hagar).
It is established that the writers of the Old Testament were largely inspired epics left by the Sumerians on clay tablets: the story of Noah and the flood, for example, is inspired by the epic of Gilgamesh , the great Sumerian king of Uruk , the goddess Ishtar (recycled by the Greeks in the guise of Aphrodite and the Romans, those of Venus) was in love. The Epic of Gilgamesh (Bilbamesh in Sumerian) tells the story of a king who defied the gods. The latter sent on earth his alter ego: Enkidu. The confrontation of the two demigods ended in a draw. They became friends, fusional friends will overcome Humbaba , guardian of the forest of conifers where the gods live. Humbaba's death will be avenged by the gods who will perish Enkidu. Gilgamesh never be consoled for the death of Enkidu willed by the gods. he spent the rest of his life searching in vain the secret of « immortality with Untanatispi, the alter ego of Noah, the man that the gods had spared during the episode of the flood.
Akkad (2400 BC)
Despite their geographical proximity to the Sumerians, Akkadians do not speak the same language: they are part of the family of Semitic peoples (originally came from the Arabian Peninsula).
Akkad has not been discovered by archeology and its exact location is questionable.
Dynastic succession, each ruling over city-states gradually merged by a charismatic king Sargon of Akkad (2400 BC).
The story of his birth recalls the story of Moses , collected by the daughter of the Pharaoh of the Nile and raised as a king.
» I was born in Azupiranu on the banks of the Euphrates. My mother, the high priestess bore me in secret. She put me in a reed basket and left me drift on the river. The river carried me, even among Aqqi, the drawer of water, which took me with her bucket. He raised me as his son, taught me his gardener business. The goddess Ishtar fell in love with me made me king. I régnai for fifty-six years. «
Sargon created the first empire in history by taking control of the Sumerian cities and directing these armies north and west, taking in particular the city of Assur and Mari ..
The time of the invasions
The Amorites (2100 BC)
Hammurabi code
The area is then broken up with the arrival of Amorites (those coming from the west), often mentioned in the Bible, sharing the various kingdoms in Mesopotamia, including the eternal Babylon (they are the founders). During the reign of Hammurabi (author of the code bearing his name, considered one of the first legal texts), Babylon will absorb its competitors, before sinking in turn, bending under the blows of the new power: the Hittites.
The Hammurabi code
It regulates all human relationships, such as inheritance, contracts, divorce, ownership of slaves. The law of retaliation is one of the major principles.
The major Mesopotamian peoples
The Hitti your (2000-1700 BC.)
They just HATTI Ankara present), the main city of Anatolia (Turkey) around 2000 BC. Their warfare is reinforced by a major innovation: the introduction on the battlefield of light wagon drawn by two horses and carrying three men.
Around 1600 BC, they take Syria and Babylon in 1595 BC. Five centuries will then succeed under the rule of the Kassites (dynasty founded by a Hittite sovereign reigning over Babylon).
They eventually incorporate the 1200 BC. Sumerian pantheon.
Their progress was stopped in Egypt, at the Battle of Kadesh (1200 BC), where they face the pharaoh Ramses II. The battle ended in a draw and the first peace treaty in history.
Arameans (1200 BC)
This period ends with the arrival of a new people: the Aramaeans, Semitic people, who came from the town of Aram, that it is not known place. There seems to be an alliance of tribes that occupied territories in northern Syria and emigrated to the east and southeast to conquer Mesopotamia . The Arameans bequeath their language in the region (that Christ used to preach), which is the language of commerce, but also their alphabet which negates the cuneiform writing.
They were the first to domesticate the camel (contrary to what tells the Old Testament , which provides the company of Abraham this animal 2000 years too early)
Neighboring Peoples
Sumer around and influenced by this great civilization, develop several great nations that interact, in particular through trade.
They are known as the people of the sea. They trade with other peoples of the Mediterranean to North Africa or Spain.
We owe them our alphabet. The Phoenician Alphabet, which he is the heir, has significantly reduced the number of signs necessary for the expression of any idea.
the Hebrews
Their story begins around 1200 BC. No archaeological evidence attests to civilization before that date. In particular, intensive excavations in the Sinai desert have never possible to find traces of the Exodus (escape of the Hebrews from Egypt), despite the presence of nearly 600,000 men for 40 years, no burial, no pottery, nothing. It is the same of the alleged exodus of Abraham from east to west to Canaan .
The contribution of Hebrews is religious: they invent monotheism and, with it, intolerance. Monotheism is not attached to a city, as in Sumer, but a people and ensures its cohesion. Deportation (586 BC) in Babylon will thus not mean assimilation. The Hebrews keep their identity by writing their history around a unifying God: the Old Testament . The term « Jew » is given to the Hebrews by the Sumerian people.
The Mycenaean civilization
It grows especially in Crete from 1650 to 1100 BC. It covers mainland Greece and the shores of the Aegean Sea.
Egyptians
Protected by the Sinai desert to the east, the Egyptians are sheltered land invasions. The reunification of the southern kingdoms (Sudan) and north (Nile Delta) is born an empire. Akhenaten, the heretic pharaoh, re-invent, on the banks of the Nile, monotheism.
The decline of empires of the Bronze Age
All hitherto described Empires disappear with the end of the Bronze Age (1200 BC). The origin of this carnage is likely to seek the sudden hypertrophy side of the bureaucracy involved in managing such a state and associated costs: short, ceremonies, palaces, wars, mercenary armies generating more and more taxes and as many revolts. Will disappear including the Hittite and Mycenaean civilization.
The Assyrians (900 BC)
Around 900 BC, Mesopotamia still changes hands. The Assyrians (who came from the city of Asur (north of Sumer) and worshiping the deity of the same name) founded the first true empire of the Middle East that will run until the seventh century BC.
The city of Nimrud destroyed by the Islamic state is a legacy of the Assyrian period.
Installed on the heights of the Euphrates, Assyrians, known for their brutality, control the iron mines, commercial ports and fertile land. Their mastery of the cavalry gives them a significant advantage on the battlefield. They absorb some of the Arameans they settle in Syria. The rulers show the name of Sargon (Lord of the world).
Babylon but resists time the invader. But Sargon II finally destroyed. Around 600 BC, a Chaldean king of Babylon eventually crush the Assyrian power. The Assyrians will occupy a time the Egyptian delta.
The Assyrians in the Bible
Assyria shall submit the Kingdom of Israel in 722 BC. Salamassar, Assyrian king, moved to Samaria settlers who, mixing with the local population, will become the Samaritans. The Kingdom of Jerusalem, away from trade routes, is a spare time.
The Babylonians (600 BC)
Hanging Gardens of Babylon
In 900 BC the Chaldeans (nomadic desert people) settled in Babylon. Around 600 BC, the new masters are Babylonians , led the most emblematic king named after Nebuchadnezzar II (originally the Hanging Gardens of Babylon and the Ishtar Gate).
The Babylonians in the Bible
Nebuchadnezzar conquered the Kingdom of Jerusalem, destroyed the Temple of Solomon, the people subjected Hebrew and deported to Babylon. The cohesion of the exiles is maintained, particularly through spiritual guides like Ezekiel. Daniel even became an important advisor of the king of Babylon. Balthazar succeeds Nebuchadnezzar. Daniel interprets a prophecy: the end of the kingdom of Babylon. Darius the Mede (Persia) takes the city that night and put the Babylonian king to death.
The Persians (550 BC)
The Persians (from Iran) are Babylon. Cyrus II (dynasty of Achaemenids ) is their king. He has already conquered the Medes (also Iranian people) and Lydians (now western Turkey).
The Persians in the Bible
In 536 BC, Cyrus king of Persia, promulgated an edict:
the Lord has placed in my hands all the kingdoms of the earth. He entrusted the mission to build a temple in Jerusalem. If any of you who belong to his people, the LORD his God be with him to let him go.
Cyrus allowed the Jews to return home.
In his attempt to conquer the world, it fails to meet the Greeks Marathon (480 BC). Ataxercès his son will fail in the same way, stopped despite its thousands of troops to Thermopilae by the 200 Spartans of Leonidas. It will lose its fleet at Salamis cast by the Athenian fleet.
Greeks (330 BC) the Romans , to the Muslims (632 AD)
The Persians take their territory until the arrival of the Greeks in 330 BC by Alexander the Great. It scans the great Empire and became the greatest conqueror of all time before dying in Persepolis general leaving his tear for the management of the empire.
The conquests of Alexander the Great
The Parthian (150 BC) from Iran, they succeed, then the Romans (110 BC). The Umayyad Muslims (630 AD) invade the entire Middle East. Their power is only thwarted by the Crusaders on the one hand and the other Byzantium, whose empire was founded by the Emperor Constantine in the fourth century and destroyed by Muslims in 1453.
The Ottoman Empire (from the sixteenth to the twentieth century)
After the fall of Constantinople in 1453, the land is Muslim, until the end of the Ottoman Empire in 1920. Any reference to « Mesopotamia » disappears shelves of history.
French and British mandates (1920)
Sykes-Picot 1916
Not until the end of the Second World War, the agreements Sykes-Picot in 1916 and the Treaties of Versailles (1919) Sevre (1920) and San Remo for the term is used again.
Mesopotamia passes to the east, under British mandate and west, under French mandate. Iran, Iraq and Syria become so states (of monarchies).
British and French occupation permit relative development of the Middle East, but ultimately leads to a rejection of Western society.
After the nationalist parenthesis scope by General Gamal Abdel Nasser in Egypt or the FLN in Algeria, the military dictatorships are taking place in several countries (Assad in Syria, Mubarak in Egypt, Ben Ali in Tunisia, Sadam Hussein in Iraq …) . In 1979, the Iranian monarchy was overthrown by a Shi'ite Islamic revolution.
The world loses his head (2013-2015)
The world is losing the head. Following the Arab Spring that toppled dictators in place, contradictory forces vying for power, the Democrats on one side and religious fundamentalists on the other.
DAECH attempts to recreate the missing Sunni caliphate. Abu Bakr Al Baghdadi was inducted new caliph.
Following reports of the hottest news, reported here as part of the chronicle of the war against DAECH.
Article précédent : I read to you A line in the sand (a line in the sand) James BARR
Article suivant : 1916 agreements SYKES-PICOT
Brève histoire des mathématiques
Les lecteurs ont aimé
Brève histoire du syndicalisme
Brève histoire des Beatles
Brève histoire de France
jpbouton@wanadoo.fr
Déjeuner : 11h - 14h
Dîner : Lun-Jeu 17h - 23h, Ven-Sam 17h - 1h
WordPress.com. Thème : Tortuga par ThemeZee.


What do you do for work and how do you feel about it?
We are the owners of WAAM Industries. It is extremely satisfying to see a project that started with $500 turn into what our brand has become today.
WAAM Industries creates functional objects built for everyday life. Our product line mainly consists of design replicas. A few examples include waxed canvas lunch bags, market totes, wooden milk crates, wine racks, and lunch trays.
Traveling is our biggest source of inspiration. We love to travel by car because it enables us to stop at those cute towns you'd never see otherwise and find inspiration in many parts of the country and the world.
Biggest takeaway from attending MCAD?
Well, we found each other! But other than that, just the openness of the creative community that surrounds MCAD. We are constantly pushing new boundaries and exploring new materials, and we always feel supported.
Any advice for prospective art and design students?
Keep an open mind, and learn how to work in as many different mediums as possible.


Hopi candles are interesting in that they are perceived to pull out ear wax and clear your ears miraculously. However there are many reasons why this isn't the case.
Colin Eaton the lead audiologist at the Honiton hearing centre based in Devon explains in this video what his thoughts are and his experiences with the Hopi candles.
Watch the video to learn that Hopi candles do not work and the reasons why.
If you are suffering from ear wax issues and need ear wax removal we offer a safe and easy ear wax removal service. Microsuction is now the gold standard of ear wax removal or if you prefer we can still offer the more traditional water irrigation (ear syringing). Either one is safer and easier than using the myth of Hopi candles and has a visible result along side better hearing afterwards.
To see how we conduct ear wax removal in our Devon centre please watch our video here.
Hello there it's Colin Eaton the audiologist at the Honiton hearing.
I would just like to talk to you about ear candles or Hopi ear candles as they are trade marked, or we like to call them in our industry Hopeless ear candles, which kind of leads me into why I don't think they are a particularly good idea.
It's a question I am often asked, do they actually work?
And to be honest I have seen people that have come in that have had the procedure done, and shown the wax residue in the candle when it's cut open, but they still have wax in their ears.
There are several YouTube videos debunking these things so I advise you to go and have a quick look at some of those there quite interesting.
I'm not sure that I would actually recommend someone to go have a naked flame lit above their ear allowing hot burning wax dropping down towards their face and towards the ear drums, and I have seen evidence myself of damage to the ear canals following the use of these blasted things.
Would I have my wax removed in a safe hygienic environment who was trained to remove it properly? Using techniques that are laid down in procedures manuals? Yes I would, so why not come and visit us at the Honiton hearing centre and we will do the job properly for you.


Course finder Find undergraduate and postgraduate courses leading to clinical careers in health. Most of the courses lead to eligibility to apply for statutory professional registration. how to become a police officer in nsw without pr Apply for Dental nurse jobs in Northern Ireland. Explore 585.000+ new and current Job vacancies. Competitive salary. Full-time, temporary, and part-time jobs. Fast & Free. Top employers in Northern Ireland. Dental nurse jobs is easy to find. Start your new career right now!
The National Certificate in Dental Nursing is a qualifying exam which can be taken at the end of a one year part-time training programme at various further education institutes in Northern Ireland. Contact the institutions directly for entry requirements and details on how to apply.
A new dental surgery in the Ballybofey/Stranorlar area requires a Dental Nurse/Receptionist. The position is part-time to full-time. Experience or qualifications will… The position is part-time to full-time.
Dental Nurse Dental Nurse - Cranmore Excellence in Dentistry Part Time - 24 hrs per week - 8.15am - 5.15pm Here at Bupa Dental Care our people are at the heart of everything we do, because we care.


A primary concern for most business owners is how to get the most bang for your buck. When you're purchasing expensive technology, this becomes an even more valid point of consideration.
Buying computers is one of the larger investments you have to make in order to effectively run a business. To avoid surprise crashes and loss of data, it's not recommended to hold onto a frequently used computer for more than four to five years. However, there are things you can do to help prolong its life span and enable it to perform better over time, saving you money in the long run.
Dust, dirt, food and other particles tend to accumulate in the crevices of keyboards, mice and monitors. If not removed, these particles can scratch hardware components and eventually build up enough to cause overheating, shortening the life of your computer. To avoid this, make sure to dust and clean your computer and its accessories on a regular basis. Compressed air is a great way to get small particles out of keyboards and tight cracks. Read Cleaning Your Desktop PC for more detailed information on how to clean a desktop, some of which can also be applied to notebooks.
PCs and liquids do not go together well. Never drink or rest water, coffee, soda or anythingliquid near a desktop or notebook. A spill could mean you'll be buying a new one much sooner than you had planned. For a little extra insurance and protection, HP offers optional HP Accidental Damage Protection Care Packs.
This tip applies mostly to notebooks. The nice thing about them is that they're portable. On business trips, it can be tempting to set them down on a hotel pillow or bed while you're casually answering emails or doing research. But soft, padded surfaces do not allow airflow into the ventilation holes underneath the notebook, which leads to overheating. To limit this risk, make sure you always rest your notebook on a cool, solid surface, allowing air to travel underneath it.
Viruses could be the biggest threat to the health of a notebook or desktop. One of the very first things you should do when you buy a new computer is install anti-virus software. Some popular, effective applications include Microsoft Security Essentials and McAfee. Make sure you also take advantage of HP Protect Tools, a suite of security tools available on many HP PCs that lets you manage security for all of your business desktops and notebooks from one central point.
Painfully slow processing is a sign that your computer may be starting to fade on you. Add extra RAM (random access memory) to relieve the strain of an overloaded machine. Once it stops relying on hard disk memory, your computer's performance will become exponentially faster. Check out HP's EasyBundle for an easy way to upgrade your notebook's hard drive.
All of the programs that you don't currently use on your computer are taking up valuable space. Getting rid of them will improve performance and save memory. Most PCs have a "disk cleanup" function that will delete "unseen" files and empty caches. You can also go through your files manually and remove anything you haven't been accessing.
There are many things to consider when purchasing a computer. If you're looking for a desktop or notebook that can stand the test of time and endure harsh environmental conditions, an HP Elite PC may be your answer. All Elite products must endure 115,000 hours of durability testing to prove they'll be able to give you many years of reliable service.
Unfortunately, no matter how well you take care of it, the reality is that no computer can live forever. To decrease your risk of a catastrophic crash, make sure you don't wait too long to buy a replacement. After several years, most computers start to display glitches and show signs that they could be struggling. To be on the safe side, you should plan on replacing your desktops and notebooks about every four years.


Updated as on September 6, 2018: IPU Common Entrance 2019 (GGSIPU CET) - Guru Gobind Singh Indraprastha University will announce GGSIPU CET Exam date soon to admit students in offered courses. GGSIPU 2019 entrance to be conducted by the only University or affiliated agencies. So, we recommend to the all admission seekers to submit application form through online methods or as university has instructed.
GGSIPU 2018 is an Independent entrance of IPU which is conducted once in a year by the University, only qualified students shall be allowed to get B.Tech admission, BCA Admission and other undergraduate / graduate / post graduate level course in IPU affiliated colleges. But there is need to check carefully entrance details which are grouped by the CET unique code for the specific programme/course. The University reserves the rights to add or remove any programme from the list of programmes grouped together for the purpose of admissions along-with it, also reserves the right to cancel any IPU Common Entrance Test.
If it comes to eligibility or who is eligible to appear the GGSIPU 2019 Exam then as per the Univ. norms that Only Indian / Overseas Citizens of India / Nepal citizens candidates are eligible to appear the entrance exam / admission, we advise to read terms and conditions of the university at official website.
Note: While submitting application form, all the applicants must fill correct details which will help for further process, creating any ambiguity might affect application process. Below, Check group wise entrance test exam details given of GGSIPU 2019 (IP University).
Give 1 minute for better help.
As above we have informed that Only CET qualified applicants shall be considered for admission, through the University counselling.
Only CET qualified applicants shall be considered for admission, through the University counselling subject to fulfillment of eligibility and admission criteria.


text:
Rob Dirksen: Resilience
CD - Rob Dirksen is both a double bassist with the Concertgebouw Orchestra and a composer. With Resilience, he answered the Concertgebouw Chamber Orchestra's call for a new work for a live-streamed concert when the Netherlands was in lockdown in 2021.
Save story as favorite
cover: Royal Concertgebouw Orchestra image: Koninklijk Concertgebouworkest
Dirksen composed a compelling work reflecting on this period marked by the pandemic and centring on the theme of 'resilience' in the most general sense of the word.
'As I was writing the first bars of the work, the term "resilience" kept coming to mind,' wrote the composer in notes to the work. 'That's because the music seemed to possess a naturally upward force. Resilience can manifest itself in various ways – not just as nerve or will, but also as a natural, innate quality; that which is light will find its way upward. Since the work was written during lockdown as a result of the pandemic, the topic is very fitting. Because of the worrying situation we find ourselves in, I like to think of resilience in this way.
'The work begins with a statement of resilience, a melody that has an exuberant quality to it and sounds like a philosophical assertion. Resilience then reflects the despair we can feel when forced to face the paradox and absurdity of life.
The pressure builds, and then the music erupts into an exuberant dance of energy. Just as the music seems to switch to an even faster and lighter dance, the motion stops, and we're swept away into a hushed, solemn phrase, as if the music wants to say, "It's not all that simple."
Then, when the opening melody returns, the setting is more subjective, more personal. The music then totally descends back to where there is little left to hope for, and the solo violin depicts the protagonist in his despair. Just at that moment, a new way forward is found, and the piece ends in an energetic, optimistic apotheosis.'