An Introduction to Linear Algebra for Quantum Computing
from matplotlib import pyplot as plt
import numpy as np
from qiskit import *
from qiskit.visualization import plot_bloch_vector
Introduction
Linear algebra is the language of quantum computing. For this reason, it is crucial to develop a good understanding of the basic mathematical concepts that are built upon in order to arrive at many of the amazing and interesting constructions seen in quantum computation! The goal of this section of the textbook is to start at the absolute basics of linear algebra: vectors and vector spaces, and build a foundation that the reader can then leverage in their study of quantum computing.
Vectors and Vector Spaces
We will start our investigation into introductory linear algebra by first discussing one of the most important mathematical quantities in quantum computation, the vector!
Formally, a vector $|v\rangle$ is defined as elements of a set known as a vector space. A more intutive and geometric definition as that a vector "is a mathematical quantity with both direction and magnitude". For instance, consider a vector with $x$ and $y$ components of the form $\begin{pmatrix} 3 \\ 5 \end{pmatrix}$. This vector can be visualized as an arrow pointing in the direction of $3$ unit down the $x$ axis and $5$ units up the $y$ axis:
plt.figure()
ax = plt.gca()
ax.quiver([3], [5], angles='xy', scale_units='xy', scale=1)
ax.set_xlim([-1, 10])
ax.set_ylim([-1, 10])
plt.draw()
plt.show()
Note that "tail" of the vector doesn't have to be positioned at the origin, all that matters is that it is pointing in the correct direction.
Now, let's talk about a concrete example of vectors in quantum computing. Oftentimes, in quantum computing, we deal with state vectors, which are simply vectors, no different than the one just presented that point to a specific point in space that corresponds to a particular quantum state. Oftentimes, this is visualized using a Bloch sphere. For instance, a vector, representing the state of a quantum system could look something like this arrow, enclosed inside the Bloch sphere, which is the so-called "state" space of all possible points to which our state vectors can "point":
plot_bloch_vector([1, 0, 0])
Hopefully this help to illuminate how vectors can be used to store information about quantum states. This particular state corresponds to an even superposition between $|0\rangle$ and $|1\rangle$ (you can see that the arrow is halfway between $|0\rangle$ at the top and $|1\rangle$ at the bottom of the sphere!). Our vectors are allowed to rotate anywhere on the surface of the sphere, and each of these points represents a different quantum state!
Now that we have talked about vectors a bit more intuitively, in the context of quantum computing, we can go back to our more formal definition of a vector, which is that a vector is an element of a vector space. From this, it follows that we must define a vector space. A vector space $V$ over a field F is a set of objects (vectors), where two conditions hold. Firstly, vector addition of two vectors $|a\rangle, \ |b\rangle \ \in \ V$ will yield a third vector $|a\rangle \ + \ |b\rangle \ = \ |c\rangle$, also contained in $V$. The second condition is that scalar multiplication between some $|a\rangle \ \in \ V$ and some $n \ \in \ F$, denoted by $n|a\rangle$ is also contained within $V$.
We will now clarify this previous definition by working through a basic example. Let us demonstrate that the set $\mathbb{R}^2$ over the field $\mathbb{R}$ is a vector space. We assert that
$$\begin{pmatrix} x_1 \\ y_1 \end{pmatrix} \ + \ \begin{pmatrix} x_1 \\ y_1 \end{pmatrix} \ = \ \begin{pmatrix} x_1 \ + \ x_2 \\ y_1 \ + \ y_2 \end{pmatrix}$$
is contained within $\mathbb{R}^2$. Well, this is evidently the case, as the sum of two real numbers is a real number, making both components of the newly-formed vector real numbers, and in turn making the vector be contained in $\mathbb{R}^2$ by definition. We also assert that:
$$n |v\rangle \ = \ \begin{pmatrix} nx \\ ny \end{pmatrix} \ \in \ V \ \ \ \ \forall n \ \in \ \mathbb{R}$$
This is true as well, as the product of a real number and a real number is in turn a real number, making the entires of the new vector real, and thus proving this statement.
Matrices and Matrix Operations
Now that we have introduced vectors, we can turn our attention to another fundamental concept: a matrix. The best way to think of matrices from a quantum computational/quantum mechanical perspective is the fact that matrices are mathematical objects that transform vectors to other vectors:
$$|v\rangle \ \rightarrow \ |v'\rangle \ = \ M |v\rangle$$
Generally, matrices are written as "arrays" of numbers, looking something like this:
$$M \ = \ \begin{pmatrix} 1 & -2 & 3 \\ 1 & 5i & 0 \\ 1 \ + \ i & 7 & -4 \end{pmatrix}$$
We can actually "apply" a matrix to a vector by performing matrix multiplication. In general, matrix multiplication between two matrices involves taking the first row of the first matrix, and multiplying each element by its "partner" in the first column of the second matrix (the first number of the row is multiplied by the first number of the column, second number of the row and second number of column, etc.) These new numbers are then added up, and we have the first element of the first row of the new matrix! To fill in the rest of the first row, we repeat this process for the second, third, etc. columns of the second matrix. Then we take the second row of the first matrix, and repeat the process for each column of the second matrix, getting the second row. We perform this process until was have used all rows of the first matrix. The resulting matrix is our new matrix! That may have been confusing, so here is an example:
$$\begin{pmatrix} 2 & 0 \\ 5 & -1 \end{pmatrix} \begin{pmatrix} -3 & 1 \\ 2 & 1 \end{pmatrix} \ = \ \begin{pmatrix} (2)(-3) + (0)(2) & (2)(1) \ + \ (0)(1) \\ (5)(-3) + (-1)(2) & (5)(1) \ + \ (-1)(1) \end{pmatrix} \ = \ \begin{pmatrix} -6 & 2 \\ -17 & 4 \end{pmatrix}$$
As you can see, we simply used the previously outlined process to arrive at the final matrix! Going back to "applying" matrices to vectors, all we have to realize is that a vector is simply a matrix with $1$ column, so matrix multiplication behaves the exact same way! As we previously discussed, in quantum computing we have some quantum state vector that we are manipulating in order to perform quantum computation. Well, as you can probably guess, the way that we represent the manipulation of that vector mathematically is through the application of matrices. We manipulate qubits in our quantum computer by applying sequences of quantum gates. As it turns out, we can express each of these quantum gates as a different matrix that can be "applied" to a start vectors, thus changing the state. For instance, one of the most commonly seen quantum gates in the Pauli-X gate, which is represented by the follwing matrix:
$$\sigma_x \ = \ \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix}$$
This gate acts kind of similarly to the classical NOT logic gate. It maps the computational basis state $|0\rangle$ to $|1\rangle$ and $|1\rangle$ to $|0\rangle$ (it "flips" the state).
Within quantum computation, we often deal with two very important types of matrices: Hermitian and Unitary matrices. The former is more important in the study of quantum mechanics, but is still definitely worth talking about in a study of quantum computation. The latter is of unparalleled importance in both quantum mechanics and quantum computation, if there is one concept that the reader should take away from this entire linear algebra section, it should be the idea of a unitary matrix.
Firstly, a Hermitian matrix is simply a matrix that is equal to its conjugate transpose (denoted with a $\dagger$ symbol). This essentially means taking a matrix, flipping the sign in its imaginary components, and then reflecting the entries of the matrix across its main diagonal (the diagonal that goes from the top left corner to the bottom right corner). For instance, a matrix that we commonly use in quantum computation, the Pauli-Y matrix is Hermitian:
$$\sigma_y \ = \ \begin{pmatrix} 0 & -i \\ i & 0 \end{pmatrix} \ \Rightarrow \ \sigma_y^{\dagger} \ = \ \begin{pmatrix} 0 & -(i) \\ -(-i) & 0 \end{pmatrix} \ = \ \begin{pmatrix} 0 & -i \\ i & 0 \end{pmatrix} \ = \ \sigma_y$$
Notice how we switched the places of the $i$ and the $-i$ (as we are reflecting across the main diagonal, the zeroes remain unchanged), and then flip the sign. A unitary matrix is very similar. Specifically, a unitary matrix is a matrix such that the inverse matrix is equal to the conjugate transpose of the original matrix.
Let's go on a quick tangent and talk a bit about what the inverse matrix is.  The identity matrix is just a matrix that has zeroes everywhere, except along the main diagonal (top left to bottom right), which is all ones. The reason why it is called the identity matrix is because it acts trivially on any other matrix (it has no effect). If you don't believe me, check it in a couple cases and convince yourself!
I don't want to go too deep into the inverse matrix, and frankly, when matrices get larger than $2 \ \times \ 2$, calculating the inverse becomes a huge pain and is left to computers for the most part. For a $2 \ \times \ 2$ matrix, the inverse is defined as:
$$A \ = \ \begin{pmatrix} a & b \\ c & d \end{pmatrix} \ \Rightarrow \ A^{-1} \ = \ \frac{1}{\text{det} \ A} \begin{pmatrix} d & -b \\ -c & a \end{pmatrix}$$
Where $\text{det} \ A$ is the determinant of the matrix. Calculating the matrix for anything larger than $2 \ \times \ 2$ is really annoying, so I won't go into it. In the $2 \ \times \ 2$ case, $\text{det} \ A \ = \ ad \ - \ bc$.
To be completely honest, the calculating of inverse matrices is rarely important in quantum computing. Since most of the matrices we deal with are unitary, we already know that the inverse if simply given by taking the conjugate transpose, so we don't have to go through this annoying process of rigorously calculating the inverse.
Anyways, going back to to unitary matrices, we can now look at a basic example. As it turns out, the Pauli-Y matrix, in addition to being Hermitian, is also unitary (it is equal to its conjugate transpose, which is also equal to its inverse, therefore, the Pauli-Y matrix is its own inverse, that's pretty cool!). We can verify that this matrix is in fact unitary:
$$\sigma_y \ = \ \begin{pmatrix} 0 & -i \\ i & 0 \end{pmatrix} \ \ \ \ \ \sigma_y^{\dagger} \ = \ \begin{pmatrix} 0 & -i \\ i & 0 \end{pmatrix} \ \Rightarrow \ \sigma_y^{\dagger} \sigma_y \ = \ \begin{pmatrix} (0)(0) + (-i)(i) & (0)(-i) \ + \ (-i)(0) \\ (i)(0) \ + \ (0)(i) & (i)(-i) \ + \ (0)(0) \end{pmatrix} \ = \ \begin{pmatrix} 1 & 0 \\ 0 & 1 \end{pmatrix} \ = \ \mathbb{I}$$
The reason why unitary matrices are so important in the context of quantum computation will become more apparent in the section on Hilbert spaces, but the basic idea is that evolution of a quantum state by application of a unitary matrix "preserve" the quantum state in a sense (we will discuss this more rigorously in the Hilbert spaces section, and even more so in the quantum mechanics subtopic of the textbook).
Spanning Sets, Linear Dependence and Bases
We are now in a position to discuss the construction of vector spaces. Consider some vector space $V$. We say that some set of vectors $S$ spans a subspace $V_S \ \subset \ V$ (subset closed under vector space operations) of the vector space if we can write any vector in the subspace as a linear combination of vectors contained within the spanning set.
A linear combination of some collection vectors $|v_1\rangle, \ ..., \ |v_n\rangle$ in some vector space over a field $F$ is defined as an arbitrary sum of these vectors (which of course will be another vector, which we will call $|v\rangle$!):
$$|v\rangle \ = \ f_1 |v_1\rangle \ + \ f_2 |v_2\rangle \ + \ ... \ + \ f_n |v_n\rangle \ = \ \displaystyle\sum_{i} \ f_i |v_i\rangle$$
Where each $f_i$ is some element of $F$. Now, if we have a set of vectors that spans a space, we are simply saying that any other vector in the vector space can be written as a linear combination of these vectors.
Now, we are in a position to define a basis, which is a specific case of a spanning set, but first, we must talk about linear dependence. This is a fairly straightforward idea as well.  This is equivalent to the more intuitive statement that "the set of vectors can be expressed as linear combinations of each other". This can be proven fairly simply. Let us have the set $\{|v_1\rangle, \ ..., \ |v_n\rangle \}$ along with the corresponding coefficients $\{|b_1\rangle, \ ..., \ |b_n\rangle \}$, such that the linear combination is equal to $0$.  If this is not the case, $|v_a\rangle$ has been written as a linear combination of non-zero vectors, as was shown above. To prove the converse, we assume that there exists some vector $|v_a\rangle$ in the subspace $|v_1\rangle, ..., \ |v_n\rangle$ that can be written as a linear combination of other vectors in the subspace. This means that:
$$|v_a\rangle \ = \ \displaystyle\sum_{s} b_s |v_s\rangle$$
Where $s$ is an index that runs over a subset of the subspace. It follows that:
$$|v_a\rangle \ - \ \displaystyle\sum_{s} b_s |v_s\rangle \ = \ |v_a\rangle \ - \ (|v_{s_1}\rangle \ + \ ... \ + \ |v_{s_r}\rangle) \ = \ 0$$
For all vectors in the subspace that are not included in the subset indexed by $s$, we set their coefficients, indexed by $q$ equal to $0$. Thus,
$$|v_a\rangle \ - \ (|v_{s_1}\rangle \ + \ ... \ + \ |v_{s_r}\rangle) \ + \ (0)(|v_{q_1}\rangle \ + \ ... \ + \ |v_{q_t}\rangle) \ = \ 0$$
Which is a linear combination of all elements in the subspace $|v_1\rangle, \ ..., \ |v_n\rangle$ which is equal to $0$, thus completing the proof that the two definitions of linear dependence imply each other.
Let's now consider a basic example. For instance, consider the set of two vectors in $\mathbb{R}^2$, consisting of $|a\rangle \ = \ \begin{pmatrix} 1 \\ 0 \end{pmatrix}$ and $|b\rangle \ = \ \begin{pmatrix} 2 \\ 0 \end{pmatrix}$. Well, for example, if we choose the field over our vector space to be $\mathbb{R}$, then we can create a linear combination of these vectors that equates to $0$. For example:
$$2|a\rangle \ - \ |b\rangle \ = \ 0$$
A set of vectors is said to be linearly independent if a linear combination of vectors is $0$ only if every coefficient is equal to $0$.
The notion of a basis is simply a linearly independent spanning set. In this sense, the basis of a vector space is the minimal possible set that spans the entire space. We call the size of the basis set the dimension of the vector space.
The reason why bases and spanning sets are so important is becasue they allow us to "shrink down" vector spaces and express them in terms of only a few vectors rather than a ton! Oftentimes, we can come to certain conclusions about our basis set that we can generalize to the entire vector space, simply because we know every vector in the space is just a linear combination of the basis vectors. Consider in quantum computation, how one of the bases that we often deal with is $|0\rangle, \ |1\rangle$. We can write any other qubit state as a linear combination of these basis vectors. For instance, the linear combination
$$\frac{|0\rangle \ + \ |1\rangle}{\sqrt{2}}$$
represents a superposition between the $|0\rangle$ and $|1\rangle$ basis state, with equal probability of measuring the state to be in either one of the basis vector states (this is kind of intuitive, as the "weight" or the "amount of each basis vector" in the linear combination is equal, both being scaled by $1/\sqrt{2}$.
Hilbert Spaces, Orthonormality, and the Inner Product
Hilbert Spaces are one of the most important mathematical constructs in quantum mechanics and quantum computation. Less rigorously, a Hilbert space can be thought of as the space state in which all quantum state vectors "live". The main fact that differentiates a Hilbert space from any random vector space is that a Hilbert space is equipped with an inner product, which is an operation that can be performed between two vectors, returning a scalar.
In the context of quantum mechanics and quantum computation, the inner product between two state vectors returns a scalar quantity representing the amount to which the first vector lies along the second vector. From this, the probabilities of measurement in different quantum states, among other things can be calculated (this will be discussed more in the quantum mechanics subtopic).
For two vectors $|a\rangle$ and $|b\rangle$ in a Hilbert space, we denote the inner product as $\langle a | b \rangle$, where $\langle a |$ is equal to the conjugate transpose of $|a\rangle$, denoted $|a\rangle^{\dagger}$. Thus, the inner product between two vectors of the Hilbert space looks something like:
$$\langle a | b \rangle \ = \ \begin{pmatrix} a_1^{*} & a_2^{*} & ... & a_n^{*} \end{pmatrix} \begin{pmatrix} b_1 \\ b_2 \\ . \\ . \\ . \\ b_n \end{pmatrix} \ = \ a_1^{*} b_1 \ + \ a_2^{*} b_2 \ + \ ... \ + \ a_n^{*} b_n$$
Where $*$ denotes the complex conjugate of the vector.
One of the most important conditions for a Hilbert space representing a quantum system is that the inner product of a vector with itself is equal to one: $\langle \psi | \psi \rangle \ = \ 1$. This is the so-called normalization condition, and essentially just states that the length of the vector squared (each componenet of the vector is squared and summed together, by defintion of the inner product) must be equal to one. The physical significance of this is that the length of a vector in a particular direction is representative of the "probability ampltide" of the quantum system with regards to being measured in that particular state. Obviously, the probability of the quantum system being measured in the state that it is actually in must be $1$, after all, the sum of the probabilities of finding the quantum system in any particular state has to equal one (I mean, it has to be in some state!).
Let's consider the Bloch sphere:
plot_bloch_vector([0, 0, 0])
The surface of this sphere, along with the inner product between qubit state vectors, is a valid Hilbert space! In addition to this, it can be seen that the normalization condition holds true, as the radius of the Bloch sphere is $1$, therefore the length squared of each vector must also be equal to one!
The last thing that is worth noting about Hilbert spaces and the inner product is their relationship to unitary matrices. The reason why unitary matrices are so important in quantum computation is because they preserve the inner product, meaning that no matter how you transform a vector under a sequence of unitary matrices, the normalization condition still holds true. This can be demonstrated in the following short proof:
$$\langle \psi | \psi \rangle \ = \ 1 \ \Rightarrow \ |\psi\rangle \ \rightarrow \ U |\psi\rangle \ = \ |\psi'\rangle \ \Rightarrow \ \langle \psi' | \psi' \rangle \ = \ (U |\psi\rangle)^{\dagger} U|\psi\rangle \ = \ \langle \psi | U^{\dagger} U |\psi\rangle \ = \ \langle \psi | \psi \rangle \ = \ 1$$
This essentially means that unitary evolution sends quantum states to other valid quantum states. for a single qubit Hilbert space, represented by the Bloch sphere, unitary transformations correspond to rotations of state vectors to different points on the sphere, not changing the length of the state vector in any way.
Eigenvectors and Eigenvalues
Consider the relationship of the form:
$$A |v\rangle \ = \ \lambda |v\rangle$$Where $A$ is a matrix, and $\lambda$ is some number. If we are given some matrix $A$, and need to find the vectors $|v\rangle$ and numbers $\lambda$ that satisfy this relationship, we call these vectors eigenvectors and their corresponding number multipliers eigenvalues. Eigenvectors and eigenvalues have very important physical significance in the context of quantum mechanics, and therefore quantum computation. Given some $A$, we exploit an interesting trick in order to find the set of eigenvectors and corresponding eigenvalues.  This is an extraneous solution (we don't allow eigenvectors to be the null vector, or else any eigenvalue/matrix combination would satisfy the eigenvector-eigenvalue relationship). Thus, in order to find the allowed eigenvectors and eigenvalues, we have to assume that the matrix $(A \ - \ \lambda \mathbb{I})$ is non-invertible. Recall from earlier that the inverse of a matrix is of the form:
$$M^{-1} \ = \ \frac{1}{\text{det} (M)} \ F(M)$$
Where $F(M)$ is some new matrix (don't worry about what that matrix actually is, it doesn't matter in this context) that depends on $M$. The part of this equation we are interested in is the inverse of the determinant. If the determinant of the matrix $M$ is $0$, it follows that the inverse is undefined, and thus so is the inverse, making the matrix $M$ non-invertible! Thus, we require that:
$$\text{det} (A \ - \ \lambda \mathbb{I}) \ = \ 0$$
From this, we can determine $\lambda$, then we plug each value of lambda back into the original equation to get the eigenvalues! Let's do an example, and find the eigenvectors/eigenvalues of the Pauli-Z matrix, $\sigma_z$. We start with:
$$\text{det} (\sigma_z \ - \ \lambda \mathbb{I}) \ = \ \text{det} \begin{pmatrix} 1 \ - \ \lambda & 0 \\ 0 & -1 \ - \ \lambda \end{pmatrix} \ = \ (-1 \ - \ \lambda)(1 \ - \ \lambda) \ = \ 1 \ - \ \lambda^2 \ = \ 0 \ \Rightarrow \ \lambda \ = \ \pm 1$$
The equation, in terms of lambda that is obtained when solving the determinant is called the characteristic polynomial. We can then plug each of these values back into the original equation. We'll start with $\lambda \ = \ 1$:
$$\begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix} |v\rangle \ = \ |v\rangle \ \Rightarrow \ \begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix} \begin{pmatrix} a \\ b \end{pmatrix} \ = \ \begin{pmatrix} a \\ b \end{pmatrix} \ \Rightarrow \begin{pmatrix} a \\ -b \end{pmatrix} \ = \ \begin{pmatrix} a \\ b \end{pmatrix}$$
So this means that $a$ can be any number and $b$ is $0$. Thus, the vector $\begin{pmatrix} 1 \\ 0 \end{pmatrix}$ forms a basis for all vectors that satisfy our relationship, and is thus the eigenvector that corresponds to the eigenvalue of $1$! We do the same thing for $\lambda \ = \ -1$:
$$\begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix} |v\rangle \ = \ -|v\rangle \ \Rightarrow \ \begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix} \begin{pmatrix} a \\ b \end{pmatrix} \ = \ \begin{pmatrix} -a \\ -b \end{pmatrix} \ \Rightarrow \begin{pmatrix} a \\ -b \end{pmatrix} \ = \ \begin{pmatrix} -a \\ -b \end{pmatrix}$$
This time, $b$ can be any number and $a$ is $0$, thus our basis vector (and thus our eigenvector corresponding to $-1$) is $\begin{pmatrix} 0 \\ 1 \end{pmatrix}$. Notice how the eigenvectors of the Pauli-Z matrix are the quantum computational basis states $|0\rangle$ and $|1\rangle$! This is no coincidence! For instance, when we measure a qubit in the $Z$-basis, we are referring to performing a measurement that collapses the qubit's state into one of the eigenvectors of the Z matrix, either $|0\rangle$ or $|1\rangle$!
Matrix Exponentials
The notion of a matrix exponential is a very specific idea, but one that is so important that it warrants its own section in this part of the textbook. Oftentimes in quantum computing (and when I say oftentimes, I mean all the time, especially during the creation of variational or parametrized quantum circuits), we will see unitary transformations in the form:
$$U \ = \ e^{i\gamma H}$$
Where $H$ is some Hermitian matrix and $\gamma$ is some real number. It is fairly simple to prove that all matrices of this form are unitary.   Well, this actually becomes much more apparent when we expand our exponential function as a Taylor series. If you recall from calculus, a Taylor series is essentially a way to write any function as an infinite-degree polynomial. I won't go too far into this idea, but the main idea is that we choose the terms of the polynomial and centre it at some point $x_0$ lying on the function we are trying to transform into the polynomial, such that the zeroth, first, second, third, etc. derivative at this point is the same for both the original function and the polynomial. Thus, we write our Taylor series in the form:
$$g(x) \ = \ \displaystyle\sum_{n \ = \ 0}^{\infty} \ f^{(n)}(x_0) \ \frac{(x \ - \ x_0)^n}{n!}$$
Where $g(x)$ is the polynomial, $f(x)$ is the original function, $f^(n)$ is the $n$-th derivative of $f$, and $x_0$ is the point at which we centre the function.  Since the derivative of $e^x$ is simply $e^x$, and evidently, $e^0 \ = \ 1$, we get:
$$g(x) \ = \ \displaystyle\sum_{n \ = \ 0}^{\infty} \ \frac{x^n}{n!} \ = \ e^x$$
And so for some matrix, $i \gamma H$, we get:
$$e^{i \gamma H} \ = \ \displaystyle\sum_{n \ = \ 0}^{\infty} \ \frac{(i \gamma H)^n}{n!}$$
This makes much more sense, the exponential of a matrix is a matrix. It is an infinite sum of powers of matrices, which looks kind of intimidating, but at least we have concluded that the matrix exponential is in fact a matrix! We are now in a position to demonstrate a very important fact, if we have some matrix $B$ such that $B^2 \ = \ \mathbb{I}$ (this is called an involutory matrix), then:
$$e^{i \gamma B} \ = \ \cos(\gamma) \mathbb{I} \ + \ i \sin(\gamma) B$$
We start with the Maclauren series:
$$e^{i \gamma B} \ = \ \displaystyle\sum_{n \ = \ 0}^{\infty} \ \frac{(i \gamma B)^n}{n!}$$
Notice that we can split the summation into an imaginary part and a real part, based on whether $n$ is even or odd in each term of the sum:
$$\displaystyle\sum_{n \ = \ 0}^{\infty} \ \frac{(i \gamma B)^n}{n!} \ = \ \displaystyle\sum_{n \ = \ 0}^{\infty} \ \frac{(-1)^n \gamma^{2n} B^{2n}}{(2n)!} \ + \ i \displaystyle\sum_{n \ = \ 0}^{\infty} \frac{(-1)^n \gamma^{2n + 1} B^{2n + 1}}{(2n + 1)!}$$
Now, let us find the Maclaurin series for both $\sin x$ and $\cos x$.    This fact is super useful in quantum computation! Consider the Pauli matrices:
$$\sigma_x \ = \ \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix}$$
$$\sigma_y \ = \ \begin{pmatrix} 0 & i \\ -i & 0 \end{pmatrix}$$
$$\sigma_z \ = \ \begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}$$
These matrices are incredibly important to quantum computation, they are some of the most fundamental "quantum gates" used to manipulate qubits. As it turns out, these operations are not only unitary, they are also Hermitian and Involutory. This means that a matrix of the form $e^{i \gamma \sigma_k} \ k \ \in \ \{x, \ y, \ z\}$ is not only a valid unitary matrix that can act upon a quantum state vector (a qubit), but it can be expressed using the sine-cosine relationship that we just proved! This is fact very powerful, and is seen throughout quantum computational theory, as gates of this type are used all the time (as you will see in future sections of this textbook)!
Before we end this section, there is one other useful fact about matrix exponentials that is worth discussing: if we have some matrix $M$, with eigenvectors $|v\rangle$ and corresponding eigenvalues $v$, then:
$$e^{M} |v\rangle \ = \ e^v |v\rangle$$
This one is much more straightforward to prove:
$$e^M |v\rangle \ = \ \displaystyle\sum_{n \ = \ 0}^{\infty} \ \frac{B^n |v\rangle}{n!} \ = \ \displaystyle\sum_{n \ = \ 0}^{\infty} \ \frac{v^n |v\rangle}{n!} \ = \ e^v |v\rangle$$
This fact is super useful as well. Often when creating quantum circuits that simulate a certain Hamiltonian (especially for variational circuits), gates of the form $e^{i \gamma \sigma_z}$ will be used. Well, since $|0\rangle$ and $|1\rangle$ are eigenvalues of $\sigma_z$, we can easily determine mathematically that $e^{i \gamma \sigma_z}$ will add a phase of $e^{i \gamma}$ to $|0\rangle$ and will add a phase of $e^{-i\gamma}$ to $|1\rangle$. This then allows us to construct this gate in terms of $CNOT$ and phase/rotation gates fairly easily, as we know mathematically the outcome of the gate on each of the computational basis states.
This fact doesn't only apply to exponentials of the $\sigma_z$ gate. For example, we can determine the outcome of a gate of the form $e^{i \gamma \sigma_x}$ on the eigenvectors of $\sigma_x$, $(|0\rangle \ + \ |1\rangle)/\sqrt{2}$ and $(|0\rangle \ - \ |1\rangle)/\sqrt{2}$. The same applies for exponentials of the $\sigma_y$ matrix.


sat on Apple’s board of directors for three whole years, from 2006 to 2009. But it’s no wonder he left in 2009: by entering the smartphone market with its Android mobile OS (and its own app store!), Google had become a direct competitor of Apple. This confict of interest was as good a reason for him to leave, as Steve Jobs’ shrinking tolerance for what he felt was a plain and simple betrayal.
Finally, an old debate about Steve’s personality has also re-emerged in 2010: has he changed? Although some of his traits, such as his propensity to take the spotlight then and again to unveil insanely great products to the world, have not changed... People have noticed two minor evolutions in his public persona.
The first is his increasing habit of communicating by writing emails to customers.


Notes: {{siteCondition.notes}}
{{getWaterColors(siteCondition.waterConditions.waterColor)}} water color
No oil sheen
Oil sheen present
No garbage present
No CSO pipes
No unmarked or other outfall pipes
Garbage present:
{{getGarbageExtent(siteCondition.waterConditions.garbage.hardPlastic)}} amount of hard plastic
{{getGarbageExtent(siteCondition.waterConditions.garbage.softPlastic)}} amount of soft plastic
{{getGarbageExtent(siteCondition.waterConditions.garbage.metal)}} amount of metal
{{getGarbageExtent(siteCondition.waterConditions.garbage.paper)}} amount of paper
{{getGarbageExtent(siteCondition.waterConditions.garbage.glass)}} amount of glass
{{getGarbageExtent(siteCondition.waterConditions.garbage.organic)}} amount of organic
{{getGarbageExtent(siteCondition.waterConditions.garbage.other.extent)}} amount of
{{siteCondition.waterConditions.garbage.other.description}}
CSO pipes present.
Amount of flow through CSO pipes: {{getWaterFlows(siteCondition.waterConditions.markedCombinedSewerOverflowPipes.howMuchFlowThrough)}}
Unmarked or other outfall pipes present.
Amount of flow through other pipes:
{{getWaterFlows(siteCondition.waterConditions.unmarkedOutfallPipes.howMuchFlowThrough)}}
{{siteCondition.waterConditions.unmarkedOutfallPipes.approximateDiameterCM}}cm approximate diameter
No garbage present
Garbage present:
{{getGarbageExtent(siteCondition.landConditions.garbage.hardPlastic)}} amount of hard plastic
{{getGarbageExtent(siteCondition.landConditions.garbage.softPlastic)}} amount of soft plastic
{{getGarbageExtent(siteCondition.landConditions.garbage.metal)}} amount of metal
{{getGarbageExtent(siteCondition.landConditions.garbage.paper)}} amount of paper
{{getGarbageExtent(siteCondition.landConditions.garbage.glass)}} amount of glass
{{getGarbageExtent(siteCondition.landConditions.garbage.organic)}} amount of organic
{{getGarbageExtent(siteCondition.landConditions.garbage.other.extent)}} amount of
{{siteCondition.landConditions.garbage.other.description}}


Pig Cookbook
Overview
This document provides hints and tips for pig users.
Performance Enhancers
The following are a list of tips that people have discovered for making their pig queries run faster. Please feel free to add any tips you have.
Use Latest Code
The latest code has been merged into trunk on 1/12/09. It is significantly faster than the currently released code in Pig 0.1.1. We are planning to release Pig 0.2.0 that incorporates new changes shortly. Here is the performance comparison:
|
Query Type |
Pig 1.4 (s) |
Pig 2.0 (s) |
Improvement (times) |
|
GENERATE with Arithmetic operations |
837 |
345 |
2.4x |
|
DISTINCT with 1 key |
186 |
129 |
1.4x |
|
DISTINCT with 2 key s |
436 |
184 |
2.4x |
|
GROUP |
534 |
404 |
1.3x |
|
GROUP ALL |
3594 |
394 |
9x |
|
JOIN |
15376 |
12783 |
1.2 |
|
ORDER BY 1 key |
640 |
316 |
2x |
|
ORDER BY 2 keys |
767 |
472 |
1.6 x |
Use Types
If types are not specified in the load statement, Pig assumes the type of =double= for numeric computations. A lot of the time, your data would be much smaller, maybe, integer or long. Specifying the real type will help with speed of arithmetic computation. It has an additional advantage of early error detection.
--Query 1 A = load 'myfile' as (t, u, v); B = foreach A generate t + u; --Query 2 A = load 'myfile' as (t: int, u: int, v); B = foreach A generate t + u;
The second query will run more efficiently than the first. In some of our queries with see 2x speedup.
Project Early and Often
Pig does not (yet) determine when a field is no longer needed and drop the field from the row. For example, say you have a query like:
A = load 'myfile' as (t, u, v); B = load 'myotherfile' as (x, y, z); C = join A by t, B by x; D = group C by u; E = foreach D generate group, COUNT($1);
There is no need for v, y, or z to participate in this query. And there is no need to carry both t and x past the join, just one will suffice. Changing the above query to
A = load 'myfile' as (t, u, v); A1 = foreach A generate t, u; B = load 'myotherfile' as (x, y, z); B1 = foreach B generate x; C = join A1 by t, B1 by x; C1 = foreach C generate t, u; D = group C1 by u; E = foreach D generate group, COUNT($1);
will greatly reduce the amount of data being carried through the map and reduce phases by pig. Depending on your data, this can produce significant time savings. In queries similar to the example given we have seen total time drop by 50%.
Filter Early and Often
As with early projection, in most cases it is beneficial to apply filters as early as possible to reduce the amount of data flowing through the pipeline.
-- Query 1 A = load 'myfile' as (t, u, v); B = load 'myotherfile' as (x, y, z); C = filter A by t == 1; D = join C by t, B by x; E = group D by u; F = foreach E generate group, COUNT($1); -- Query 2 A = load 'myfile' as (t, u, v); B = load 'myotherfile' as (x, y, z); C = join A by t, B by x; D = group C by u; E = foreach D generate group, COUNT($1); F = filter E by C.t == 1;
The first query is clearly more efficient than the second one because it reduces the amount of data going into the join.
One case where pushing filters up might not be a good idea is if the cost of applying filter is very high and only a small amount of data is filtered out.
Reduce Your Operator Pipeline
For clarity of your script, you might choose to split your projects into several steps for instance:
A = load 'data' as (in: map[]); -- get key out of the map B = foreach A generate in#k1 as k1, in#k2 as k2; -- concatenate the keys C = foreach B generate CONCAT(k1, k2); .......
While the example above is easier to read, you might want to consider combining the two foreach statements to improve your query performance:
A = load 'data' as (in: map[]); -- concatenate the keys from the map B = foreach A generate CONCAT(in#k1, in#k2); ....
The same goes for filters.
Make your UDFs Algebraic
Queries that can take advantage of the combiner generally ran much faster (sometimes several times faster) than the versions that don't. The latest code significantly improves combiner usage; however, you need to make sure you do your part. If you have a UDF that works on grouped data and is, by nature, algebraic (meaning their computation can be decomposed into multiple steps) make sure you implement it as such. For details on how to write algebraic UDFs, see UDF Manual.
A = load 'data' as (x, y, z) B = group A by x; C = foreach B generate group, MyUDF(A); ....
If MyUDF is algebraic, the query will use combiner and run much faster. You can run explain command on your query to make sure that combiner is used.

With the introduction of nulls, join and cogroup semantics were altered to work with nulls. The semantic for cogrouping with nulls is that nulls from a given input are grouped together, but nulls across inputs are not grouped together. This preserves the semantics of grouping (nulls are collected together from a single input to be passed to aggregate functions like COUNT) and the semantics of join (nulls are not joined across inputs). Since flattening an empty bag results in an empty row, in a standard join the rows with a null key will always be dropped. The join:
A = load 'myfile' as (t, u, v); B = load 'myotherfile' as (x, y, z); C = join A by t, B by x;
is rewritten by pig to
A = load 'myfile' as (t, u, v); B = load 'myotherfile' as (x, y, z); C1 = cogroup A by t INNER, B by x INNER; C = foreach C1 generate flatten(A), flatten(B);
Since the nulls from A and B won't be collected together, when the nulls are flattened we're guaranteed to have an empty bag, which will result in no output. So the null keys will be dropped. But they will not be dropped until the last possible moment. If the query is rewritten to
A = load 'myfile' as (t, u, v); B = load 'myotherfile' as (x, y, z); A1 = filter A by t is not null; B1 = filter B by x is not null; C = join A1 by t, B1 by x;
then the nulls will be dropped before the join. Since all null keys go to a single reducer, if your key is null even a small percentage of the time the gain can be significant. In one test where the key was null 7% of the time and the data was spread across 200 reducers, we saw a about a 10x speed up in the query by adding the early filters.
Take Advantage of Join Optimization
The optimization insures that the last table in the join is not brought into memory but stream through instead. The optimization reduces the amount of memory used which means you can avoid spilling the data and also should be able to scale your query to larger data volumes.
To take advantage of this optimization, make sure that the table with the largest number of tuples per key is the last table in your query.
small = load 'small_file' as (t, u, v); large = load 'large_file' as (x, y, z); C = join small by t, large by x;
In some of our tests we saw 10x performance improvement as the result of this optimization.
Use Fragment Replicate Join
This type of join works well if one of tables is small enough to fit into main memory. In this case, Pig can perform a very efficient join since, in hadoop world, it can be done completely on the map side.
tiny = load 'small_file' as (t, u, v); large = load 'large_file' as (x, y, z); C = join large by x, tiny by t using "replicated";
Note that the large table must come first followed by one or more small tables. All small tables together must fit into main memory.
This feature is new and experimental. It is experimental because we don't have a strong sense of how small the small table must be to fit into memory. In our tests with a simple query that involved just join a table of up to 100M can be used if the process overall gets 1 GB of memory. If the table does not fit into memory, the process would fail and generate an error.
Use PARALLEL Keyword
PARALLEL controls the number of reducers invoked by Hadoop. The default out of the box is 1 which, in most cases, is not what you want. I reasonable heuristic to use is something like
<num machines> * <num reduce slots per machine> * 0.9
The keyword makes sense on any operator that starts a reduce phase. This includes GROUP, COGROUP, JOIN, DISTINCT, LIMIT, ORDER BY.
Example:
A = load 'myfile' as (t, u, v); B = group A by t PARALLEL 18; .....
Use LIMIT
A lot of the times, you are not interested in the entire output but either a sample or top results. In those cases, using LIMIT can yeild a much better performance as we push the limit as high as possible to minimize the amount of data travelling through the pipeline.
Sample:
A = load 'myfile' as (t, u, v); B = limit A 500;
Top results:
A = load 'myfile' as (t, u, v); B = order A by t; C = limit B 500;
Prefer DISTINCT over GROUP BY - GENERATE
When it comes to extracting the unique values from a column in a relation, one of two approaches can be used:
Example Using GROUP BY - GENERATE
A = load 'myfile' as (t, u, v); B = foreach A generate u; C = group B by u; D = foreach C generate group as uniquekey; dump D;
Example Using DISTINCT
A = load 'myfile' as (t, u, v); B = foreach A generate u; C = distinct B; dump C;
In pig 0.1.x, DISTINCT is just GROUP BY/PROJECT under the hood. In pig 0.2.0 it is not, and it is much faster and more efficient (depending on your key cardinality, up to 20x faster in pig team's tests). Therefore, the use of DISTINCT is recommended over GROUP BY - GENERATE.


- setActionIconId(int) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator
-
Set the action icon for either (left/right) swipe directions
- setActionIconTint(int) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator.Builder
-
Set the tint color for either (left/right) action icons
- setActionIconTint(int) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator
-
Set the tint color for either (left/right) action icons
- setBackgroundColor(int) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator
-
Set the background color for either (left/right) swipe directions
- setIconHorizontalMargin(int) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator.Builder
-
- setIconHorizontalMargin(int, int) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator.Builder
-
Set the horizontal margin of the icon in the given unit (default is 16dp)
- setIconHorizontalMargin(int) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator
-
- setIconHorizontalMargin(int, int) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator
-
Set the horizontal margin of the icon in the given unit (default is 16dp)
- setSwipeLeftActionIconId(int) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator
-
Set the action icon for left swipe direction
- setSwipeLeftActionIconTint(int) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator.Builder
-
Set the tint color for action icon shown while swiping left
- setSwipeLeftActionIconTint(int) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator
-
Set the tint color for action icon drawn while swiping left
- setSwipeLeftBackgroundColor(int) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator
-
Set the background color for left swipe direction
- setSwipeLeftLabel(String) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator
-
Set the label shown when swiping left
- setSwipeLeftLabelColor(int) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator.Builder
-
Set the color of the label to be shown while swiping left
- setSwipeLeftLabelTextSize(int, float) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator.Builder
-
Set the size of the label to be shown while swiping left
- setSwipeLeftLabelTypeface(Typeface) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator.Builder
-
Set the Typeface of the label to be shown while swiping left
- setSwipeLeftTextColor(int) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator
-
Set the color of the text shown when swiping left
- setSwipeLeftTextSize(int, float) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator
-
Set the size of the text shown when swiping left
- setSwipeLeftTypeface(Typeface) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator
-
Set the Typeface of the text shown when swiping left
- setSwipeRightActionIconId(int) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator
-
Set the action icon for right swipe direction
- setSwipeRightActionIconTint(int) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator.Builder
-
Set the tint color for action icon shown while swiping right
- setSwipeRightActionIconTint(int) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator
-
Set the tint color for action icon drawn while swiping right
- setSwipeRightBackgroundColor(int) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator
-
Set the background color for right swipe direction
- setSwipeRightLabel(String) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator
-
Set the label shown when swiping right
- setSwipeRightLabelColor(int) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator.Builder
-
Set the color of the label to be shown while swiping right
- setSwipeRightLabelTextSize(int, float) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator.Builder
-
Set the size of the label to be shown while swiping right
- setSwipeRightLabelTypeface(Typeface) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator.Builder
-
Set the Typeface of the label to be shown while swiping right
- setSwipeRightTextColor(int) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator
-
Set the color of the text shown when swiping right
- setSwipeRightTextSize(int, float) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator
-
Set the size of the text shown when swiping right
- setSwipeRightTypeface(Typeface) - Method in class it.xabaras.android.recyclerview.swipedecorator.RecyclerViewSwipeDecorator
-
Set the Typeface of the text shown when swiping right


The open challenge on multilingual question answering over linked data provides a benchmark for comparing different approaches and systems that mediate between a user, expressing his or her information need in natural language, and semantic data.
Given a RDF dataset and a natural language question or set of keywords in one of six languages (English, Spanish, German, Italian, French, Dutch), either return the correct answers, or a SPARQL query that retrieves these answers.
Full description: qald3_openchallenge.pdf (Last updated: March 25, 2013)
We do not maintain a SPARQL endpoint once the challenge is finished. Please load the data into a local triple store.
The training data comprises 100 natural language questions for English DBpedia and MusicBrainz each,
annotated with keywords as well as corresponding SPARQL queries and the answers that these queries retrieve.
The questions are of different complexity and are available in six languages:
English, Spanish, German, Italian, French, and Dutch.
The test data consists of similar questions and keywords, without annotations, for which answers or SPARQL queries have to be submitted.
Here you can check the gold standard (i.e. with annotations, SPARQL queries and answers):
For both training and test phase, results can be uploaded with the following evaluation form:
Evaluation results: qald3_results.pdf


Inital pass at visualizing snow data (2006-2014) from
NOAA
.
Next Steps
Convert to daily values
Add slider for moving through values
Add second frame to allow comparison across years/months
Add some summary chart statistics
Convert csv files into aggregated JSON


# Release Orchestration
### for Fun and Profit
A brief intro to Vamp's current capabilities.
Note:
Here is speaker notes
## The story
- A basic web-service is built, tested, and deployed to users.
- The service is one of many dozens or hundreds of microservices working in cooperation (think netflix)
- A single team owns only a handful of services.
(Modern teams using cloud native architecture on k8s platform)
![netflix UI mocked up wiot potential service boundaries](assets/netflix.png)
--
## Traditional CCI Story
- Developer commits code
- Fix breaking change in unit - fast feedback, optmizations
- Concurrent packaging of docker while IT tests run
- Deploy versioned image to docker hub
- Apply deployment to K8s cluster.
![circleci workflow with build, package, apply workflow](assets/cci_workflow.png)
--
### But ah Snap!
The service selector in the manifest was bogus, and our beautiful little container is shutoff from the world.
Users are getting angry error pages!
![githubs 503 unicorn](assets/gh_angry.png)
--
### Adding Release Monitoring
- Release agent detects deployment by CCI, Argo, or sun gods (by matching labels [app, version])
- Release agent monitors metrics from prometheus based on defined metric queries
- At end of policy time-limit determine if thresholds were met and moves forward, or fails deployment
- Webhook is fired with details
- Admins get paged and fix stuff.
![alerts and metrics image](assets/alerts.png)
--
### Adding Traffic Shaping
- Release agent also applies new ingress policy controlling traffic (10% canacy, 90% stable)
- Vamp agent monitors metrics from prometheus based on defined metric queries
- At end of policy Vamp determines if thresholds were met and increases rollout, or fails the `release`
- Webhook is fired with details
![alerts and metrics image](assets/canary.png)
--
### So What?
- If the application restarts too much OR
- Does not respond in time OR
- Throws too many errors while it does OR
- X OR X OR x
Then reset ingress to "Stable" version, and fire webhooks
- operators don't get pages
- only a few customers ever notice
- dev team can keep iterating
--
## Webhooks, WHY DO WE NEED EM?
- Vamp handles ingress & scale based on policies that shape ingress,
- but leaves the deployment itself out there (unrouted)
- Webhooks on Success to:
- approve CCI apporval job
- trigger parametized pipeline
- On failure:
- call CCI to cleanup bad deployment.
--
## Recap
- Traditional approach was "hope our non-prod testing was adequate"
- A _passing_ pipeline in CircleCI is not the same as a _healthy_ application in the wild
- Invalid config, inadequate scale, integration issues, etc.
- Modern approach "Ensure our non-prod testing was adequate"
- We separate `deploy/publish` from `release`
- We can incrementally expose or rollback new versions
--
![tired, wired, inspired meme with CI,CD and RO](assets/releasethinking.jpeg)
# Vamp Deep Dive
Walkthrough the Vamp agent, applications, policies, etc
--
## Vamp Release agent
Firstly, there is not direct trigger or API call to vamp.
With the Vamp release agent we essentially hand ingress control to Vamp. The cluster installed binary communicates with Vamp Cloud to shape traffic based on detected deployments.
![visual of vamp agent on network](assets/vampoverview.png)
--
## Vamp - Application
An *Application* represents the tuple of (Cluster, Namespace, Ingress)
You may think of Application as more of a Platform - it is not a specific web-service, UI, or function, but rather everything available behind a single domain.
[BlueSKyGreenBuild App in Vamp](https://vamp.cloud/6/application/211/0)
--
## Vamp - Services
A *Service* reprsents an individual web service or application running as a deployment, responsing on a specific path, and many may live in an Application
https://vamp.cloud/6/application/211/0/services
--
## Vamp - Policies & Metrics
Metrics are queries against prometheus essnetially.
Policies are which metrics (beyond required health & availability) are used over a fixed time or request volume to assess validity of change.
- 90% of responses < 500ms
- 1,000 requests/min of traffic
- No more than 2 restarts
https://vamp.cloud/6/policy/66/steps
# Cool Let's Play
https://app.circleci.com/pipelines/github/eddiewebb/demo-blueskygreenbuilds?branch=main


- BlobBase - Class in org.blobbase
-
Create an abstract storage mechanism used for mapping keys to binary large
objects (BLOB) stored on the file system.
- BlobBase(File) - Constructor for class org.blobbase.BlobBase
-
- BlobBase(File, int) - Constructor for class org.blobbase.BlobBase
-
Create a FileMap database at location with initial directory capacity.
- BlobBaseInputStream - Class in org.blobbase.io
-
A convenience class for obtaining an InputStream in BlobBase.
- BlobBaseInputStream(BlobBase, Object) - Constructor for class org.blobbase.io.BlobBaseInputStream
-
- BlobBaseOutputStream - Class in org.blobbase.io
-
A convenience class for obtaining an OutputStream to BlobBase.
- BlobBaseOutputStream(BlobBase, Object) - Constructor for class org.blobbase.io.BlobBaseOutputStream
-
Constructs a BlobBaseOutputStream OutputStream
- BlobFile - Class in org.blobbase
-
A wrapper for the standard Java File class that overrides certain methods that would
might cause database problems if they we 'accidentally' invoked and are thus prohibited.
- BlobFileIterator - Class in org.blobbase
-
A lazily populated iterator for listing files in database.
- BlobFileIterator(File) - Constructor for class org.blobbase.BlobFileIterator
-
- byteToHex(byte[]) - Static method in class org.blobbase.utils.HexUtils
-
Format a buffer into a string of hex digits.


Exercise 0
Exercise 1
Exercise 2
Exercise 3
Exercise 4
Exercise 5
Exercise 6
Exercise 7
Exercise 8
Exercise 9
Exercise 10


Gateway
BOT
17-May-19 01:54 PM
[dscrd-hush] <ComputerGenie - ChickenPool> any ideas on how to solve topia coin claims?
imo, the "solution" is: "Do nothing"
At what point do you "make folks whole" after their own 3rd party transactions went sour and not sacrifice immutability?
[dscrd-hush] <Pepin the Healer> uh
[dscrd-hush] <Kryptonite> @dukeleto I have a multi-coin tip bot, it's quite new. We can list cheaper than DiscordTips. Let me know if interested!
[dscrd-hush] <dukeleto> @Kryptonite sure, dm me some more info
[dscrd-hush] <Kryptonite> will do
[dscrd-hush] <ComputerGenie - ChickenPool> Each owner transfers the coin to the next by digitally signing a hash of the previous transaction and the public key of the next owner...
After you send coins to an address you don't own the keys to, they aren't your coins anymore.
(edited)
[dscrd-hush] <dukeleto> Just to be clear, Hush sidestepped this whole "immutability" argument already, or maybe "stepped in it and kept going" is a better analogy
[dscrd-hush] <dukeleto> We airdropped funds to a new, upgraded, more secure + faster chain. In that process, we DID NOT airdrop the Cryptopia attacker funds. By mining a new mainnet and airdropping funds to it, immutability of the original v2 chain was "preserved" on that chain, but we made an entire new chain and deprecated the old. This was the best option we had
[dscrd-hush] <dukeleto> by many measures, it was the only option we had
[dscrd-hush] <dukeleto> If you think Hush v2 is better, go join the people mining it
[dscrd-hush] <dukeleto> This is a decentralized world
[dscrd-hush] <ComputerGenie - ChickenPool> I have issues with that, the same as I did ETH, but I wasn't part of that convo
[dscrd-hush] <dukeleto> In the current situation, chain immutability issues are behind us
[dscrd-hush] <ComputerGenie - ChickenPool> This is a decentralized world
You kinda can't make that claim when you pick and choose who has the right to possess what, imo
[dscrd-hush] <dukeleto> What we are talking about now, is how to fairly redistribute the topia funds, knowing that we can't even get close to "perfectly fair", just "fair enough"
[dscrd-hush] <dukeleto> @ComputerGenie - ChickenPool well, if this was ZEC, I would have turned off your nodes forcibly, and forced you to choose
[dscrd-hush] <dukeleto> I didn't choose
[dscrd-hush] <dukeleto> By choosing v2 or v3, YOU make the choice
[dscrd-hush] <ComputerGenie - ChickenPool> how to fairly redistribute the topia funds
"fairly", they belong to topia
[dscrd-hush] <dukeleto> no
[dscrd-hush] <dukeleto> fairly, they belong to the attacker
[dscrd-hush] <dukeleto> Topia HAS NO FUNDS. Not on v2, not on v3
[dscrd-hush] <dukeleto> say it with me
[dscrd-hush] <dukeleto> topia has nothing
[dscrd-hush] <ComputerGenie - ChickenPool> By choosing v2 or v3, YOU make the choice
Again, kinda only half true when v2 isn't supported by any dev(s)
[dscrd-hush] <dukeleto> @ComputerGenie - ChickenPool nobody said you get supported software forever for free, nowhere does it say that
[dscrd-hush] <dukeleto> you get to keep the pieces when it breaks
[dscrd-hush] <ComputerGenie - ChickenPool> LOL
[dscrd-hush] <dukeleto> and read the source
[dscrd-hush] <dukeleto> so yes, one option is to make the original attacker whole, another is to give it all back to cryptopia so they can dump on us, or another is to spread it around the current active Hush community
[dscrd-hush] <dukeleto> i know which option CG doesn't like
[dscrd-hush] <dukeleto> these are all hard questions, and CG is bringing up very valid points
[dscrd-hush] <dukeleto> I don't argue that.
[dscrd-hush] <dukeleto> But I am in the position of doing what is best for Hush, not what is best in some theoretic sense in a theoretical situation on a theoretical coin
[dscrd-hush] <ComputerGenie - ChickenPool> my point is that the "official" (in as much as that ever exists) chain/params/client is centralized to some extent
that becomes more true when the decision is actively made to pick and choose who gets what (even further if that choice is "forced" by devs only supporting a singular option)


dispGol
Lightweight Spaceship Animation
Requires recent version of Firefox or Safari, or Internet Explorer 9. If the animation doesn't display try with one of those browsers.
Requires recent version of Firefox or Safari, or Internet Explorer 9. If the animation doesn't display try with one of those browsers.
background image courtesy of Free Web Backgrounds


Morgan O'Leary Technical Blogs
When initally trying to figure out spacing on a HTML, it can be difficult to decipher what you need to use. The best thing for me so far is to keep this image in mind.
Padding is the space between your content and the border. Padding is applied inside the element (this whole box you are trying to create) you are creating and affects how far away your content is from the border. Padding will affect the height and width of that element.
Here's what the element looks with 20px of padding.
And here's what the element looks like with 50px of padding.
As you can see the area around the content grows, but the content itself stays in place and although the entire object is bigger the border doesn't increase. It's like actually adding padding.
Border is the area directly surrounding the padding. It frames this area with either a solid or dashed line. Here's a visual of a dashed vs. solid border.
Margin is the area outside of you element. It's the area between your element the edges of your browser and the border. The margin affects how the elements on your page are placed and how far away they are from one another. The margin is also transparent. Here are some dramatic visuals so you can get an idea of what happens when you play with margins.
As you can see the spacing between the elements completely changes.


Over 800 Nigerian developers and designers are in Devcenter Square. Square is our community platform for Nigerian devs to interact, share ideas and build open source projects together.
Wondering if you'll fit in? Square has several channels. We've got Machine Learning, UI/UX, Android, Devops, you name it!
Starting this week, we will highlight tools, products and applications that members of Square create in a special "From Square" section. If you're not a member of Square, please stop dulling yourself. Signup Here.


Hello and welcome to my page! My name is Trystan, I am 20 years old and I was born and raised in South East Idaho. I was a student athlete growing up and I am still crazy into sports, however I've fell more in love with cars the older I've got. I love being in the outdoors and spending time with my family and friends. I've recently moved to Albuquerque New Mexico in pursuit to become a Web Developer, to do so I have invested hundreds of hours learning to code through Deep Dive Coding. After all of the hard work the goal is starting to pay off! Thank you for visiting my site and hopefully we can create something great together! :)
The first major project I started was the Capstone. This was a group effort, our class was split into teams of 3 and we each came up with website ideas. Ours is a website built by and for developers that want to find jobs in the ABQ area. You can make a profile, post jobs, save jobs, as well as view the pool of developers on the site.
See the codeMy second major project was this website you're on right now. This was my first attempt at a static brochure type site. In the code I include, if you click on documentation and look at the wire frames that is what the site was drew up as and has since evolved to this.
See the code


Visualize SBML model with cytoscape.js
Supported files: SBML Visualisation by Cytoscape.js Based on the Stylesheets from Cola.js/Cytoscape.js demo


Class RouteeHttpConfig
Class RouteeHttpConfig Http Configuration Class
public
|
#
__construct( string $url = null, string $method =
Default Constructor |
public
null|string
|
|
public
string
|
|
public
string
|
|
public
array
|
|
public
string|null
|
|
public
|
|
public
|
|
public
|
|
public
|
|
public
array
|
|
public
|
|
public
|
|
public
|
|
public
|
#
setSSLCert( $certPath, null $passPhrase = null )
Set ssl parameters for certificate based client authentication |
public
|
|
public
|
|
public
|
|
public
|
|
public
boolean
|
|
public
integer
|
|
public
|
|
public
array
|
#
getHttpConstantsFromConfigs( array $configs, $prefix )
Retrieves an array of constant key, and value based on Prefix |
string |
HEADER_SEPARATOR
|
#
';'
|
string |
HTTP_GET
|
#
'GET'
|
string |
HTTP_POST
|
#
'POST'
|
public static
array
|
$defaultCurlOptions
Some default options for curl These are typically overridden by RouteeConnectionManager |
#
array(
CURLOPT_SSLVERSION => 6,
CURLOPT_CONNECTTIMEOUT => 60,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_TIMEOUT => 60, // maximum number of seconds to allow cURL functions to execute
CURLOPT_USERAGENT => 'Routee-PHP-SDK',
CURLOPT_HTTPHEADER => array(),
CURLOPT_SSL_VERIFYHOST => 2,
CURLOPT_SSL_VERIFYPEER => 0,
CURLOPT_SSL_CIPHER_LIST => 'TLSv1'
//Allowing TLSv1 cipher list.
//Adding it like this for backward compatibility with older versions of curl
)
|


This is a library to simulate and correct images for Processing Org
You can find the full source for the library here
Start with importing the library to your code
import colorblindness.colorblindness;
import processing.glu.*;
import processing.glu.tessellator.*;
The "colorblindness.simulate() takes 4 parameters 1) Type of colorblindness 2) Absolute address of input file 3) Absolute Address of output file 4) Simulate or Correct the image
colorblindness.simulate(int type, string inputAddress, string outputAddress, boolean correct);
//For example, the following line simulates the image at /Desktop/input.jpg
//as per protanopia and stores the output at /Desktop/output.jpg
colorblindness.simulate(1,"/Desktop/input.jpg","/Desktop/output.jpg",false);
Options for type - 1 -> Protanopia 2 -> Deutranopia 3 -> Tritanopia
There are two possible function calls for this
colorblindness.rgbContrast(string inputFile, string outputFile, float factor);
//The factor range from 0 to 1
colorblindness.rgbContrast(string inputFile, string outputFile);
When no factor is defined, the library uses predetermined optimum factor of 0.28


Hexrays Functions¶
Hexrays function are implemented in Bip by the class HxCFunc
.
They represent a C function as decompiled by hexrays and are the main
interface for using the features from hexrays in C.
There are two ways to get a HxCFunc
object using the Bip
API, the first one is by using the hxcfunc()
property method from a BipFunction
, this property returns
the equivalent HxCFunc
for
the BipFunction
. The second way is to use the class method
from_addr()
which take an address in argument and try
to create the corresponding HxCFunc
. Both of those
methods may fail if Hexrays is not able to decompile the function or if the
address given is not part of a function, in that case an exception
BipDecompileError
is raised by Bip.
The HxCFunc
allows to recuperate the C string
of the decompiled function (cstr()
), to get the
“normal” BipFunction
(bfunc()
)
and provide to two main features: local variables (lvar) and AST nodes.
Local variables (lvar) are represented by HxLvar
objects
and are accessible through several methods. The simplest way is to use the
lvars()
property which return an array of the
variable. As those variables also include the arguments of the functions the
args()
property allows to get only the
HxLvar
which are arguments.
The AST nodes of the HxCFunc
can be accessed in
different ways. Bip provides CNode
classes
(CNode
is the parent class for all nodes) which
represents a node of the AST, those are already a second level of abstraction
on top of the hexrays AST node. There are three main ways to access
the CNode
for a particular function:
- by accessing the
root_node()
of the AST and then making the visit or the treatment as the user which; - by using visitors already implemented:
visit_cnode()
orvisit_cnode_filterlist()
and providing a callback, those visitors use a Deep-First Search (DFS) algorithm; - by using helper methods
get_cnode_filter()
orget_cnode_filter_type()
which provide list of the resulting nodes, those helpers are based on the visitors.
It is also possible to use the visitor on the first level of abstraction
on top of the hexrays node, those methods start with the prefix
hx_visit_
.
HxCFunc API¶
-
class
bip.hexrays.
HxCFunc
(cfunc)¶ Python object for representing a C function as decompile by hexrays. This is an abstraction on top of the
ida_hexrays.cfuncptr_t
andcfunc_t
object.Warning
Decompiling again the function in hexrays (meaning hitting F5 again) will create a new
cfunc_t
object. AnHxCFunc
python object (or the correspondingcfunc_t
object from IDA) and the others associated objects (such as theHxLvar
for example) will not be the same anymore. This can create problems when using the scripting and the interactive view at the same time. Basically you will want to regenerate this object for the function each time you make F5 again in the GUI, this can be done using theHxCFunc.from_addr()
class method.-
__init__
(cfunc)¶ Constructor for a
HxCFunc
object.Parameters: cfunc – A cfunc_t
pointer from IDA object such as return byida_hexrays.decompile
.
-
ea
¶ Property which return the start address of this function.
Return int: The start address of this function
-
cstr
¶ Property which return the C code corresponding to the decompilation of this function.
Return str: The string corresponding to the decompilation of this function.
-
bfunc
¶ Property which return the
BipFunction
associated with this cfunc.Returns: The BipFunction
associated with this object.
-
invalidate_cache
(close_window=False)¶ Allows to invalidate the cache for this hexray function. This will remove information associated with this function, forcing IDA to regenerate the view for the function next time it will be open.
Warning
This function may generate the same problem as decompiling again the function, this has not been tested. See
HxCFunc
warning for more information about this potential problem.Parameters: close_window – If true the window(s) showing the disassembled function will be closed. False by default.
-
add_cmt
(ea, value, itp=None)¶ Allow to add a comment in the hexrays interface view. If a comment at the same position (ea and itp) exist it will be overwritten.
Parameters: - ea (int) – The address at which add the comment. All ea address in the function will not be valid, only the one used for items in the ctree seems to be.
- value (str) – The comment value.
- itp (int) – The position at which add the comment.
See
item_tree_position
in IDA, by default (None) at the semi-colon
-
get_cmt
(ea, itp=None)¶ Allow to get a comment in the hexrays interface view.
Parameters: - ea (int) – The address at which is the comment.
- itp (int) – The position at which the comment is.
See
item_tree_position
in IDA, by default (None) at the semi-colon.
Returns: None if no comment at that position, the comment as a string if there is any
-
lvar_at
(idx)¶ Return the local variable corresponding to an index.
This equivalent to using
lvars()
with access in an index but should be faster.Returns: A HxLvar
object.
-
lvars
¶ Return a list of
HxLvar
object representing the local variables of this function. This function will return the argument as well as the local variable of the function.Returns: A list of HxLvar
.
-
lvars_iter
()¶ Return an iterator of
HxLvar
object representing the local variables of this function. This is similar tolvars()
but with an iterator instead of a list.Returns: An interator of HxLvar
.
-
lvar_by_name
(name)¶ Return a lvar with a particular name in this function.
Parameters: name (str) – The name of the lvar to search for. Returns: A HxLvar
object or None if the lvar was not found.
-
args
¶ Return a list of
HxLvar
object representing the argument of this functions.Todo
test
Returns: A list of HxLvar
.
-
root_node
¶ Property which return the
CNode
object which is the root element for this function. ThisCNode
will allow to visit the AST of the function. In practice it should always be of classCNodeStmtBlock
.Returns: The root object for this function which inherit from CNode
.
-
visit_cnode
(callback)¶ Method which allow to visit all
CNode
elements of this function starting from the root object. This is implemented using a DFS algorithm. This does not use the hexrays visitor. For more information about the implementation seevisit_dfs_cnode()
(this method is just a wrapper onvisit_cnode()
).Parameters: callback – A callable which will be called on all CNode
in the function decompiled by hexrays. The call should take only one argument which correspond to theCNode
currently visited. If this callback return False the visit is stoped, all other result is ignored.
-
visit_cnode_filterlist
(callback, filter_list)¶ Method which allow to visit
CNode
elements which are present in a list. This is implemented using a DFS algorithm. This does not use the hexrays visitor. For more information about the implementation seevisit_dfs_cnode_filterlist()
(this method is just a wrapper onvisit_cnode_filterlist()
).Parameters: - callback – A callable which will be called on all
CNode
in the function decompiled by hexrays. The call should take only one argument which correspond to theCNode
currently visited. If this callback return False the visit is stoped, all other result is ignored. - filter_list – A list of class which inherit from
CNode
. The callback will be called only for the node from a class in this list.
- callback – A callable which will be called on all
-
get_cnode_filter
(cb_filter)¶ Method which return a list of
CNode
for which a filter return true. Internally this use thevisit_cnode()
method which visit all nodes of the function, this is just a wrapper.Parameters: cb_filter – A callable which take a CNode
in parameter and return a boolean. This callback will be called on all node of the function and all node for which it returns true will be added in a list which will be returned by this function.Returns: A list of CNode
which have match the filter. This list is order in which the node have been visited (seevisit_cnode()
for more information).
-
get_cnode_filter_type
(type_filter)¶ Method which return a list of
CNode
of a particular type(s). Internally this use thevisit_cnode()
method which visit all nodes of the function, this is just a wrapper.Parameters: type_filter – The type(s) of CNode
to get. OnlyCNode
matching the isinstance of this type will be returned. This can be a type, a class or a tuple (or list) of class and type.Returns: A list of CNode
which have match the type. This list is order in which the node have been visited (seevisit_cnode()
for more information).
-
get_cnode_label
(label_num)¶ Method which return the
CNode
which represents the start of a specific label in the function.Parameters: label_num (int) – The label number for which to get the CNode
.Returns: A CNode
which represent label location, or None if the label number was not found.
-
cnodes_with_label
¶ Property which return a list of
CNode
which represent the start of the labels in the function.It is necessary to visit all the AST for doing this, so it is costly.
Returns: A list of CNode
which have a label.
-
hx_root_stmt
¶ Property which return the
HxCItem
object for the root element of this function. In practice this should always be aHxCStmtBlock
.For the
CNode
equivalent, seeroot_node()
.Returns: The root object for this function which inherit from HxCItem
.
-
hx_visit_expr
(func_visit)¶ Allow to use the hexrays visitor for visiting all expressions (
HxCExpr
) of this function.Internally this function use the
_hx_visitor_expr
visitor.Parameters: func_visit – A function which take as argument an HxCExpr
object. This function will be called on allHxCExpr
element which are part of this function.
-
hx_visit_list_expr
(expr_list, func_visit)¶ Allow to use the hexrays visitor for visiting only expressions (
HxCExpr
) which are part of a list.# example which print all the HxCExprCall from the function # hxf is an object of this class HxCFunc. def fu(e): print(e) hxf.visit_list_expr([HxCExprCall], fu)
Internally this function use the
_hx_visitor_list_expr
visitor.Parameters:
-
hx_visit_stmt
(func_visit)¶ Allow to use the hexrays visitor for visiting all statements (
HxCStmt
) of this function.Internally this function use the
_hx_visitor_stmt
visitor.Parameters: func_visit – A function which take as argument an HxCStmt
object. This function will be called on allHxCStmt
element which are part of this function.
-
hx_visit_list_stmt
(stmt_list, func_visit)¶ Allow to use the hexrays visitor for visiting only statements (
HxCStmt
) which are part of a list.Internally this function use the
_hx_visitor_list_stmt
visitor.Parameters:
-
hx_visit_all
(func_visit)¶ Allow to use the hexrays visitor for visiting all items (statements
HxCStmt
and expressionHxCExpr
) of this function.Internally this function use the
_hx_visitor_all
visitor.Parameters: func_visit – A function which take as argument an object which inherit from HxCItem
. This function will be called on all those elements which are part of this function.
-
hx_visit_list_all
(item_list, func_visit)¶ Allow to use the hexrays visitor for visiting only statements (
HxCStmt
) which are part of a list. Allow to use the hexrays visitor for visiting only items (statementsHxCStmt
and expressionHxCExpr
) which are part of a list.Internally this function use the
_hx_visitor_list_all
visitor.Parameters:
-
hx_get_label
(label_num)¶ Allow to use the the hexrays API for finding the
HxCItem
which is reference by a label.Parameters: label_num (int) – The label number. Returns: A HxCItem
object or None if the label was not found.
-
classmethod
from_addr
(ea=None)¶ Class method which return a
HxCFunc
object corresponding to the function at a particular address.This may raise a
BipDecompileError
if the decompilation failed or if the address provided is not in a function.Parameters: ea (int) – An address inside the function for which we want an HxCFunc
. IfNone
the screen address will be used.Returns: A HxCFunc
object.
-
static
invalidate_all_caches
()¶ Static method for invalidating cache of all hexrays decompiled functions. See
invalidate_cache()
for invalidating the cache of a specific function.Warning
This function may generate the same problem as decompiling again a function. See
HxCFunc
warning for more information about this potential problem.
-


Format: FontColor red green blue alpha,
Example: FontColor 1.0 0.201 1.0 1.0,
Purpose: Color of the text in enabled state. Can be skiped in which case the Text will be white. Text accpets coloring text with BlzFrameSetText having the warcraft 3 color code as prefix |cff0021ff.
the last value, alpha can be skiped
Used in: String, TEXT,


Panthers owner David Tepper addresses Cam Newton's future with team
by TSD StaffIt didn’t take long for Panthers quarterback Kyle Allen to have a fall from grace, and all of a sudden, talk has shifted back to Cam Newton.
Allen gave the team a spark when he first took over for Newton, winning four consecutive games, only to get blown out in San Francisco, then lose two of the three contests that followed.
And while Ron Rivera’s defense has underperformed, it’s hard to overlook Allen’s regression, as he’s thrown five interceptions and just one touchdown in the past two games. Turnovers lose games in the NFL, and Allen has been hurting his team as a result.
This is interesting because it was assumed that the Panthers would look to shut Newton down for the season, then trade him next spring. Carolina did do the former, but now, all of a sudden, maybe moving Newton isn’t the best idea, given how Allen has played. As such, Panthers owner David Tepper was asked about Newton’s long-term future with the team this week, but he didn’t offer much.
It’ll be interesting to see how Newton’s rehab progresses, and what the team looks to do with him (and Rivera, for that matter) going forward.


{% extends CMS_TEMPLATE %} {% load cms_tags menu_tags sekizai_tags static %} {% block title %}Login{% endblock title %} {% block content %}
Your username and password didn't match. Please try again.
{% endif %} {% if next %} {% if user.is_authenticated %}Your account doesn't have access to this page. To proceed, please login with an account that has access.
{% else %}Please login to see this page.
{% endif %} {% endif %}Please fill out your login credentials below.
{# Assumes you setup the password_reset view in your URLconf #}


@* * Copyright 2023 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @import config.ApplicationConfig @import views.html.helpers._ @import views.ViewHelpers @import uk.gov.hmrc.govukfrontend.views.html.components._ @this(gmpMain: gmp_main, viewHelpers: ViewHelpers) @(bulkReferenceForm: Form[models.BulkReference])(implicit request: Request[_], messages: Messages, ac:ApplicationConfig) @gmpMain(title = Messages("gmp.bulk_reference.header") + " - " + Messages("service.title") + " - " + Messages("gov.uk"), supportLinkEnabled = true) { @viewHelpers.govukBackLink(BackLink( href = controllers.routes.FileUploadController.get.url, content = Text("Back") )) @views.html.helpers.errorSummary(bulkReferenceForm)


End User Programming / Informal Programming
Authors
Howie Goodell, Sarah Kuhn, David Maulsby, and Carol Traynor
Status
Unread
Relevance
Quotations
Notes
References
Concepts
Field of Study
Methodology


The following images are loaded sequentially in an attempt to load the visible images faster.
Open the timeline in the web-inspector to properly observe the result. You also might want to clear your caches to clearly see the result.
Original image: here
Original image: here
Original image: here
This page demonstrates how to make the images load as the user scrolls. Just scroll down, you'll see.
Original image: here
Original image: https://i.redd.it/d9tnox3a0x101.jpg
Original image: https://upload.wikimedia.org/wikipedia/commons/7/7d/Atomium_de_Bruxelles.jpg


###YEAR### & ###YEAR-1### can be used as variables. Default is "###YEAR### Membership (Responses)"
Optional if Google Form responses are stored within a Google Team Drive
Files must be shared with service account either directly of via folder AND/OR be a member of the Google Team Drive (if applicable)Upload New Service Account Filecloud_upload
Optional if you want to use Google Analytics
Automatically change user status after graduation
Automatically import and link Slack information with user data
Automatically pull reponses from membership form
Automatically update events from Google Calendar
Automatically remove sign-ins that haven't signed out after 12 hours
Automatically send Slack notification at 9pm local with the numberof hours completed that day


New rule adopted in awarding of medals
The SEA GAMES Federation Council Friday announced a new rule for the Philippine hosting of the 30th South East Asian Games which unfolds today at the Philippine Arena in Bocaue, Bulacan.
SEA Games Executive Committee chairman Celso Dayrit said that upon the initiative of SEA Games Federation and Philippine Olympic Committee president Abraham “Bambol” Tolentino, a bronze medal will be awarded even if there are only three countries entered in an event.
“The current rule is, if for instance in boxing, only 3 countries are entered in a certain weight category, only a gold and a silver medal are to be awarded. The third placer gets nothing”, said Dayrit.
Tolentino had emphasized that the Games are supposed to be “about the athletes. So why penalize an athlete who sacrifices, trains and participates, places third and is deprived of a medal because other countries withdrew at the last minute? That’s not his fault”.
With support from all the member countries, the exemption from the current rule was sponsored by Prof.Charoen Watanasim of Thailand and approved unanimously.


Coffee Roasting Timer v2
00:00
Start
First Crack
Weight Loss
First Crack:
Development:
15.0%:
17.5%:
20.0%:
22.5%:
25.0%:
Bean:
Green Weight:
Roast Weight:
Weight Loss: 0.00%
Date:


Otiende Amollo, Wamatangi Take Part In Khalwale Challenge On Live TV (Video)
by Eva NyamburaDuring the Kibra by-election, former Kakamega senator Boni Khalwale was not just the butt of jokes, he was also a trending topic on social media sites.
Khalwale had been violently chased out of Kibra’s Laini Saba area by stone wielding goons but the bull fighter was not cowed. Instead, he threw stones back at his assailants.
The photo of him holding some three stones went viral, bringing forth a hashtag, Khalwale Challenge.
Taking up the challenge on live TV was Rarieda MP Otiende Amollo and Kiambu senator Kimani Wamatangi. They were appearing on NTV’s AM Live show where they, Khalwale, Kericho Senator Aaron Cheruiyot and Tongaren MP Eseli Simiyu are regulars.
First up was the former ombudsman who picked up what seemed like stones, at least three to recreate the Khalwale challenge.
“The first challenge is to pick up the stone, and the second is to hide it properly,” said Otiende to his colleague’s amusement.
“There must be at least a minimum of three stones, then you must have a serious face, too bad I did not carry my cape,” he joked.
Also having a go at it was Wamatangi who picked too many “stones”, hid them in the back of his hands as did the former legislator.
“…But there is also the aspect of making sure that you carry enough, and hold them at an angle like you are waiting for a disaster,” Wamatangi teased.
Appearing on the same show, Khalwale said he was only protecting himself as he called for an end to the violent culture during elections.

Explaining his reasons for carrying stones, the ex lawmaker said there were at least 30 youths baying blood as police officers stood around and did nothing.
Read: Selfish Atwoli Secretly Calls DP Ruto At Night – Boni Khalwale [Video]
Speaking in Kakamega on Sunday, he blamed Interior CS Fred Matiang’i and his PS Karanja Kibicho for being lax about security arrangements.
“I call on Matiang’i, police boss and Principal Secretary Karanja Kibicho, they must stop playing with security of Kenyans.”
“Why is it that when these goons were causing chaos nobody took action? I was left to fight for my life as police officers watched.”


Let's be honest, not everyone is as funny as Dad. But now, with the help of Dad Jokes, you too, can be as funny. You now have access to Dad Jokes with a click of your mouse!
For those who want jokes that make people laugh uncomfortably, we have a page just for you. Please be aware that these jokes are for mature audience and age verification is required!


--- layout: post title: "#3 – Why did people sign up and then not show up?" redirect_from: - /3 - /2019/06/24/2-why-did-people-sign-up-and-then-not-show-up.html ---
In this episode:
Correction: GDG Wellington are hosting Kotlin/Everywhere, not Kotlin/Extended
Shownotes:


vcf2clinvar.js is a program to generate a report on matching a genome file to a ClinVar variant database. All processing is done in browser and local to your computer.
The genome file is typically one provided by one of the direct to consumer (DTC) genotyping services such as 23andMe or AncestryDNA. The genotyping file provides information about your genomic variants at specific points in your genome. As of this writing, both AncestryDNA and 23andMe get information on about 1 million points on your genome (of the total 3.2 billion positions).
ClinVar provides a database of variants as they relate to human health. ClinVar is provided by the National Institute of Health's (NIH) National Center for Biotechnolog Information (NCBI).
From their website:
The information ... is not intended for direct diagnostic use or medical decision-making without review by a genetics professional. Individuals should not change their health behavior solely on the basis of information contained on this website. NIH does not independently verify the submitted information. If you have questions about the information contained on this website, please see a health care professional. More information about NCBI's disclaimer policy is available.
If you would like to see a sample report based on a public 23andMe genotype file, hit the button below:
The sample report is based off of a converted 23andMe VCF file available through OpenHumans.


{% load static %}
{% include "yamlview/index_header.html" %}
Network
Hosts
Software
{% include "yamlview/index_network.html" %} {% include "yamlview/index_hosts.html" %} {% include "yamlview/index_software.html" %}


My Favorite Places
Cities
Cities I like to visit
Karawa
Paris
Edinburgh
Buildings
Structures that have interesting stuff
colosseum
Great Wall
Taj Mahal
Ecosystems
Habitats that are great to visit
Coral Reef
Jungle
Mountains


Welcome to NutriCounter
Track your nutritional statistics and personalize your experience with your own recipes.
Sign Up or Login if you already have an account.


I am a results-oriented professional eager to learn new concepts and technologies, that I can apply and improve real projects. I aim to deepen and expand my knowledge of technology, marketing and people and unite them in the development of digital structures of high conversion and performance.
Made in partnership with a UI/UX designer who designed the entire project and I developed the code and animations.
Stack: HTML, CSS, JavaScript, GSAP, AnimeJS
Made in partnership with a UI/UX designer who designed the entire project and I developed the code and animations.
Stack: HTML, CSS, JavaScript, Wordpress
Made in partnership with a UI/UX designer who designed the entire project and I developed the code and animations.
Stack: HTML, CSS, React, NextJS
Design, development and UX all done by me
Stack: HTML, CSS, JavaScript
Made in partnership with a UI/UX designer who designed the entire project and I developed the code and animations.
Stack: HTML, CSS, JavaScript


This module adds an extended log in any model with inheritance over an object that create the field message_ids(mail.message) for each change made in the fields of the model unlike the traditional way in wich Odoo did.
Features
We add two server action to add o remove the feature in the model, with this you do not requiere modify the code directly at least that you model does not have a direct relation with mail.message
In the ir.model object we added three new fields:
-
- Tracked: A boolean to indicate if the model has the track activated
- Exclude Fields: A many2many field to indicate if you want to exclude of the track some fields related with the model
- Exclude External Fields: A string to specify fields(database name) that does not have a direct relation with the object. This fields must be separaten by (,) without spaces among them. E.g product_uom_qty,product_uos_qty,name
- To add the track:
-
- To remove it:
-
At the moment to add the track over the object in each change that a record has, a message is left in the log
If you want to exclude some fields of the model to avoid left a message if these fields are changed you can use the field "Exclude Fields" explained previously
In some case you will need to exclude fields that does not have a direct relation of the main model(The quantity in a line of an order) and these do not apper in the Exclude Fields(many2many with domain). For these fields exist the "Exclude External fields", where you will can specify this fields separate by (,) without spaces among them
Also, if you need it, there is a testing module called message_post_test to prove the funtionality.
Maintainer
This module is maintained by Vauxoo.
A latinamerican company that provides training, coaching, development and implementation of enterprise management sytems and bases its entire operation strategy in the use of Open Source Software and its main product is odoo.
To contribute to this module, please visit http://www.vauxoo.com.


{{! This is a comment with
some markup
 in it }}
{{! This is a comment }} {{ this_is_not }}

{{ text }}

{{article.title}}

{{{ triple_stash_is_supported }}}
{{articles.[10].[#comments]}}
{{{link "See more..." story.url}}}
{{ true }}
{{ custom_helper 42 href="somepage.html" false }}

{{#bold}}{{body}}{{/bold}}

{{#with story}}

{{{intro}}}

{{{body}}}

{{/with}}

{{#list array}}
{{@index}}. {{title}}
{{/list}}
{{#block-with-hyphens args=yep}}
This should probably work...
{{/block-with-hyphens}}
There are certain edge cases where Prism will fail. There are always such cases in every regex-based syntax highlighter. However, Prism dares to be open and honest about them. If a failure is listed here, it doesn’t mean it will never be fixed. This is more of a “known bugs” list, just with a certain type of bug.


- rasterize(GlyphBuffer, int, int) - Method in class jtxt.emulator.ChunkingRasterizer
-
- rasterize(GlyphBuffer, int, int) - Method in interface jtxt.emulator.GlyphRasterizer
-
For the given frame of Glyphs
, this method will rasterize the
glyphs onto an image, according to the properties defined in the
Context
which was used to construct this instance.
- rasterize(GlyphBuffer, int, int) - Method in class jtxt.emulator.SwingRasterizer
-
- rasterizedFrame - Variable in class jtxt.emulator.Renderer
-
The frame that is being painted to the window, where the last call to
this render generated this image.
- rasterizer - Variable in class jtxt.emulator.Renderer
-
The GlyphRasterizer
that is used to convert the frames passed to
this renderer into an image suitable for drawing to the screen.
- Region - Class in jtxt.emulator
-
Defines a region within the terminal in terms of a start and end location.
- Region(Location, Location) - Constructor for class jtxt.emulator.Region
-
Constructs a Region
with the given start and end
Location
s.
- Region(int, int, int, int) - Constructor for class jtxt.emulator.Region
-
Constructs a new region for the given lines and positions.
- registerObserver(ComponentObserver) - Method in class jtxt.emulator.tui.Component
-
- remove(ResizeSubscriber) - Method in class jtxt.emulator.Context
-
- remove(ResizeSubscriber) - Method in interface jtxt.emulator.ResizeSubject
-
Stops the given subscriber from receiving notifications about this
subject being resized.
- renderer - Variable in class jtxt.emulator.EventDispatcher
-
The instance of the Renderer
that the terminal constructed.
- Renderer - Class in jtxt.emulator
-
- Renderer(Color, float, GlyphRasterizer, int, int) - Constructor for class jtxt.emulator.Renderer
-
- resize(int, int) - Method in interface jtxt.emulator.ResizeSubscriber
-
This method is called for each subscriber whenever the subject that
dictates when these events should be propagated determines that it
is necessary to update the dimensions of the interface.
- resize() - Method in class jtxt.emulator.tui.ASCIImage
-
Resize the source image to the width and height allocated by the layout.
- resize(int, int) - Method in class jtxt.emulator.tui.RootContainer
-
- resize(int) - Method in class jtxt.emulator.tui.Table.Column
-
Adjusts the number of rows within this Column, growing or shrinking
as necessary.
- resize(int, int) - Method in class jtxt.Terminal
-
- resized() - Method in class jtxt.emulator.Context
-
- resized() - Method in interface jtxt.emulator.ResizeSubject
-
A subscriber should call this method whenever the number of lines or the
size of a line is changed by a client.
- ResizeSubject - Interface in jtxt.emulator
-
- ResizeSubscriber - Interface in jtxt.emulator
-
- resizeSubscribers - Variable in class jtxt.emulator.Context
-
All of the objects which wish to be notified when the dimensions of the
text interface are changed.
- resolution - Variable in class jtxt.emulator.tui.Slider
-
- ret - Variable in class jtxt.emulator.Prompt
-
- root - Variable in class jtxt.Terminal
-
The root container that all components that appear in the terminal
belong to.
- RootContainer - Class in jtxt.emulator.tui
-
- RootContainer(Region, Layout, Component...) - Constructor for class jtxt.emulator.tui.RootContainer
-
Creates a new container which occupies the entire area which was given
when the context was created.
- rowHeight - Variable in class jtxt.emulator.tui.Table.Column
-
- rows - Variable in class jtxt.emulator.tui.Table
-
- run() - Method in class jtxt.emulator.EventDispatcher
-
- running - Variable in class jtxt.emulator.EventDispatcher
-


BEML posts Q2 loss Rs 27.2 cr on inventory loss, revenue falls
Consolidated revenue during the quarter declined 6.4 percent year-on-year to Rs 687.1 crore, the company said in its BSE filing.
BEML, the state-owned construction equipment supplier and metro train manufacturer, has posted a consolidated loss at Rs 27.2 crore for the quarter that on ended September 2019, impacted by negative inventory.
The company had reported a profit of Rs 16.6 crore in corresponding period last fiscal, but the net loss narrowed compared to Rs 98.21 crore loss reported in the June quarter.
Its inventory loss stood at Rs 125.7 crore for the quarter against a loss of Rs 12.8 crore in the same period a year ago.
Consolidated revenue during the quarter declined 6.4 percent year-on-year to Rs 687.1 crore, the company said in its BSE filing.
At the operating level, BEML posted its earnings before interest, tax, depreciation and amortisation (EBITDA) loss at Rs 7.3 crore in Q2FY20 as against a profit of Rs 44.8 crore in the same period last year.
Other expenses also impacted the company's bottomline, which increased 18.6 percent year-on-year during the quarter to Rs 124.96 crore, while its other income jumped 79.43 percent to Rs 7.59 crore YoY.Special Thursday Expiry on 10th 7th Nov
Early Closure to The Great Diwali Discount. Last Chance to get Moneycontrol PRO for a year @ Rs. 289/- only
Coupon code: DIWALI


I'm an game developer, programmer, extended reality enthusiast and graduated in Game Development with four years of professional experience in making games.
I have worked in projects on many platforms as PC, mobile, web, and extended reality, on different kinds of projects like, gamification, serious games, diseases treatment, VR and AR experiences, and of course general games.
Playstation Awards
Playstation Awards
Comic-Con Portugal
Playstation Awards
Playstation Awards
Indie X
Send me an email and I will get back to you as soon as possible!