text:
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.Contracts;
using System.Runtime.ConstrainedExecution;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Security;
using System.Security.Permissions;
using System.Threading;

namespace System.Collections.Concurrent
{

    /// <summary>
    /// Represents a thread-safe first-in, first-out collection of objects.
    /// </summary>
    /// <typeparam name="T">Specifies the type of elements in the queue.</typeparam>
    /// <remarks>
    /// All public  and protected members of <see cref="ConcurrentQueue{T}"/> are thread-safe and may be used
    /// concurrently from multiple threads.
    /// </remarks>
    [ComVisible(false)]
    [DebuggerDisplay("Count = {Count}")]
    [DebuggerTypeProxy(typeof(SystemCollectionsConcurrent_ProducerConsumerCollectionDebugView<>))]
    [HostProtection(Synchronization = true, ExternalThreading = true)]
    [Serializable]
    public class ConcurrentQueue<T> : IProducerConsumerCollection<T>, IReadOnlyCollection<T>
    {
        //fields of ConcurrentQueue
        [NonSerialized]
        private volatile Segment m_head;

        [NonSerialized]
        private volatile Segment m_tail;

        private T[] m_serializationArray; // Used for custom serialization.

        private const int SEGMENT_SIZE = 32;

        //number of snapshot takers, GetEnumerator(), ToList() and ToArray() operations take snapshot.
        [NonSerialized]
        internal volatile int m_numSnapshotTakers = 0;

        /// <summary>
        /// Initializes a new instance of the <see cref="ConcurrentQueue{T}"/> class.
        /// </summary>
        public ConcurrentQueue()
        {
            m_head = m_tail = new Segment(0, this);
        }

        /// <summary>
        /// Initializes the contents of the queue from an existing collection.
        /// </summary>
        /// <param name="collection">A collection from which to copy elements.</param>
        private void InitializeFromCollection(IEnumerable<T> collection)
        {
            Segment localTail = new Segment(0, this);//use this local variable to avoid the extra volatile read/write. this is safe because it is only called from ctor
            m_head = localTail;

            int index = 0;
            foreach (T element in collection)
            {
                Contract.Assert(index >= 0 && index < SEGMENT_SIZE);
                localTail.UnsafeAdd(element);
                index++;

                if (index >= SEGMENT_SIZE)
                {
                    localTail = localTail.UnsafeGrow();
                    index = 0;
                }
            }

            m_tail = localTail;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ConcurrentQueue{T}"/>
        /// class that contains elements copied from the specified collection
        /// </summary>
        /// <param name="collection">The collection whose elements are copied to the new <see
        /// cref="ConcurrentQueue{T}"/>.</param>
        /// <exception cref="T:System.ArgumentNullException">The <paramref name="collection"/> argument is
        /// null.</exception>
        public ConcurrentQueue(IEnumerable<T> collection)
        {
            if (collection == null)
            {
                throw new ArgumentNullException("collection");
            }

            InitializeFromCollection(collection);
        }

        /// <summary>
        /// Get the data array to be serialized
        /// </summary>
        [OnSerializing]
        private void OnSerializing(StreamingContext context)
        {
            // save the data into the serialization array to be saved
            m_serializationArray = ToArray();
        }

        /// <summary>
        /// Construct the queue from a previously seiralized one
        /// </summary>
        [OnDeserialized]
        private void OnDeserialized(StreamingContext context)
        {
            Contract.Assert(m_serializationArray != null);
            InitializeFromCollection(m_serializationArray);
            m_serializationArray = null;
        }

        /// <summary>
        /// Copies the elements of the <see cref="T:System.Collections.ICollection"/> to an <see
        /// cref="T:System.Array"/>, starting at a particular
        /// <see cref="T:System.Array"/> index.
        /// </summary>
        /// <param name="array">The one-dimensional <see cref="T:System.Array">Array</see> that is the
        /// destination of the elements copied from the
        /// <see cref="T:System.Collections.Concurrent.ConcurrentBag"/>. The <see
        /// cref="T:System.Array">Array</see> must have zero-based indexing.</param>
        /// <param name="index">The zero-based index in <paramref name="array"/> at which copying
        /// begins.</param>
        /// <exception cref="ArgumentNullException"><paramref name="array"/> is a null reference (Nothing in
        /// Visual Basic).</exception>
        /// <exception cref="ArgumentOutOfRangeException"><paramref name="index"/> is less than
        /// zero.</exception>
        /// <exception cref="ArgumentException">
        /// <paramref name="array"/> is multidimensional. -or-
        /// <paramref name="array"/> does not have zero-based indexing. -or-
        /// <paramref name="index"/> is equal to or greater than the length of the <paramref name="array"/>
        /// -or- The number of elements in the source <see cref="T:System.Collections.ICollection"/> is
        /// greater than the available space from <paramref name="index"/> to the end of the destination
        /// <paramref name="array"/>. -or- The type of the source <see
        /// cref="T:System.Collections.ICollection"/> cannot be cast automatically to the type of the
        /// destination <paramref name="array"/>.
        /// </exception>
        void ICollection.CopyTo(Array array, int index)
        {
            // Validate arguments.
            if (array == null)
            {
                throw new ArgumentNullException("array");
            }

            // We must be careful not to corrupt the array, so we will first accumulate an
            // internal list of elements that we will then copy to the array. This requires
            // some extra allocation, but is necessary since we don't know up front whether
            // the array is sufficiently large to hold the stack's contents.
            ((ICollection)ToList()).CopyTo(array, index);
        }

        /// <summary>
        /// Gets a value indicating whether access to the <see cref="T:System.Collections.ICollection"/> is
        /// synchronized with the SyncRoot.
        /// </summary>
        /// <value>true if access to the <see cref="T:System.Collections.ICollection"/> is synchronized
        /// with the SyncRoot; otherwise, false. For <see cref="ConcurrentQueue{T}"/>, this property always
        /// returns false.</value>
        bool ICollection.IsSynchronized
        {
            // Gets a value indicating whether access to this collection is synchronized. Always returns
            // false. The reason is subtle. While access is in face thread safe, it's not the case that
            // locking on the SyncRoot would have prevented concurrent pushes and pops, as this property
            // would typically indicate; that's because we internally use CAS operations vs. true locks.
            get { return false; }
        }

        /// <summary>
        /// Gets an object that can be used to synchronize access to the <see
        /// cref="T:System.Collections.ICollection"/>. This property is not supported.
        /// </summary>
        /// <exception cref="T:System.NotSupportedException">The SyncRoot property is not supported.</exception>
        object ICollection.SyncRoot
        {
            get
            {
                throw new NotSupportedException(Environment.GetResourceString("ConcurrentCollection_SyncRoot_NotSupported"));
            }
        }

        /// <summary>
        /// Returns an enumerator that iterates through a collection.
        /// </summary>
        /// <returns>An <see cref="T:System.Collections.IEnumerator"/> that can be used to iterate through the collection.</returns>
        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IEnumerable<T>)this).GetEnumerator();
        }

        /// <summary>
        /// Attempts to add an object to the <see
        /// cref="T:System.Collections.Concurrent.IProducerConsumerCollection{T}"/>.
        /// </summary>
        /// <param name="item">The object to add to the <see
        /// cref="T:System.Collections.Concurrent.IProducerConsumerCollection{T}"/>. The value can be a null
        /// reference (Nothing in Visual Basic) for reference types.
        /// </param>
        /// <returns>true if the object was added successfully; otherwise, false.</returns>
        /// <remarks>For <see cref="ConcurrentQueue{T}"/>, this operation will always add the object to the
        /// end of the <see cref="ConcurrentQueue{T}"/>
        /// and return true.</remarks>
        bool IProducerConsumerCollection<T>.TryAdd(T item)
        {
            Enqueue(item);
            return true;
        }

        /// <summary>
        /// Attempts to remove and return an object from the <see
        /// cref="T:System.Collections.Concurrent.IProducerConsumerCollection{T}"/>.
        /// </summary>
        /// <param name="item">
        /// When this method returns, if the operation was successful, <paramref name="item"/> contains the
        /// object removed. If no object was available to be removed, the value is unspecified.
        /// </param>
        /// <returns>true if an element was removed and returned succesfully; otherwise, false.</returns>
        /// <remarks>For <see cref="ConcurrentQueue{T}"/>, this operation will attempt to remove the object
        /// from the beginning of the <see cref="ConcurrentQueue{T}"/>.
        /// </remarks>
        bool IProducerConsumerCollection<T>.TryTake(out T item)
        {
            return TryDequeue(out item);
        }

        /// <summary>
        /// Gets a value that indicates whether the <see cref="ConcurrentQueue{T}"/> is empty.
        /// </summary>
        /// <value>true if the <see cref="ConcurrentQueue{T}"/> is empty; otherwise, false.</value>
        /// <remarks>
        /// For determining whether the collection contains any items, use of this property is recommended
        /// rather than retrieving the number of items from the <see cref="Count"/> property and comparing it
        /// to 0.  However, as this collection is intended to be accessed concurrently, it may be the case
        /// that another thread will modify the collection after <see cref="IsEmpty"/> returns, thus invalidating
        /// the result.
        /// </remarks>
        public bool IsEmpty
        {
            get
            {
                Segment head = m_head;
                if (!head.IsEmpty)
                    //fast route 1:
                    //if current head is not empty, then queue is not empty
                    return false;
                else if (head.Next == null)
                    //fast route 2:
                    //if current head is empty and it's the last segment
                    //then queue is empty
                    return true;
                else
                //slow route:
                //current head is empty and it is NOT the last segment,
                //it means another thread is growing new segment
                {
                    SpinWait spin = new SpinWait();
                    while (head.IsEmpty)
                    {
                        if (head.Next == null)
                            return true;

                        spin.SpinOnce();
                        head = m_head;
                    }
                    return false;
                }
            }
        }

        /// <summary>
        /// Copies the elements stored in the <see cref="ConcurrentQueue{T}"/> to a new array.
        /// </summary>
        /// <returns>A new array containing a snapshot of elements copied from the <see
        /// cref="ConcurrentQueue{T}"/>.</returns>
        public T[] ToArray()
        {
            return ToList().ToArray();
        }

        /// <summary>
        /// Copies the <see cref="ConcurrentQueue{T}"/> elements to a new <see
        /// cref="T:System.Collections.Generic.List{T}"/>.
        /// </summary>
        /// <returns>A new <see cref="T:System.Collections.Generic.List{T}"/> containing a snapshot of
        /// elements copied from the <see cref="ConcurrentQueue{T}"/>.</returns>
        private List<T> ToList()
        {
            // Increments the number of active snapshot takers. This increment must happen before the snapshot is
            // taken. At the same time, Decrement must happen after list copying is over. Only in this way, can it
            // eliminate race condition when Segment.TryRemove() checks whether m_numSnapshotTakers == 0.
            Interlocked.Increment(ref m_numSnapshotTakers);

            List<T> list = new List<T>();
            try
            {
                //store head and tail positions in buffer,
                Segment head, tail;
                int headLow, tailHigh;
                GetHeadTailPositions(out head, out tail, out headLow, out tailHigh);

                if (head == tail)
                {
                    head.AddToList(list, headLow, tailHigh);
                }
                else
                {
                    head.AddToList(list, headLow, SEGMENT_SIZE - 1);
                    Segment curr = head.Next;
                    while (curr != tail)
                    {
                        curr.AddToList(list, 0, SEGMENT_SIZE - 1);
                        curr = curr.Next;
                    }
                    //Add tail segment
                    tail.AddToList(list, 0, tailHigh);
                }
            }
            finally
            {
                // This Decrement must happen after copying is over.
                Interlocked.Decrement(ref m_numSnapshotTakers);
            }
            return list;
        }

        /// <summary>
        /// Store the position of the current head and tail positions.
        /// </summary>
        /// <param name="head">return the head segment</param>
        /// <param name="tail">return the tail segment</param>
        /// <param name="headLow">return the head offset, value range [0, SEGMENT_SIZE]</param>
        /// <param name="tailHigh">return the tail offset, value range [-1, SEGMENT_SIZE-1]</param>
        private void GetHeadTailPositions(out Segment head, out Segment tail,
            out int headLow, out int tailHigh)
        {
            head = m_head;
            tail = m_tail;
            headLow = head.Low;
            tailHigh = tail.High;
            SpinWait spin = new SpinWait();

            //we loop until the observed values are stable and sensible.
            //This ensures that any update order by other methods can be tolerated.
            while (
                //if head and tail changed, retry
                head != m_head || tail != m_tail
                //if low and high pointers, retry
                || headLow != head.Low || tailHigh != tail.High
                //if head jumps ahead of tail because of concurrent grow and dequeue, retry
                || head.m_index > tail.m_index)
            {
                spin.SpinOnce();
                head = m_head;
                tail = m_tail;
                headLow = head.Low;
                tailHigh = tail.High;
            }
        }

        /// <summary>
        /// Gets the number of elements contained in the <see cref="ConcurrentQueue{T}"/>.
        /// </summary>
        /// <value>The number of elements contained in the <see cref="ConcurrentQueue{T}"/>.</value>
        /// <remarks>
        /// For determining whether the collection contains any items, use of the <see cref="IsEmpty"/>
        /// property is recommended rather than retrieving the number of items from the <see cref="Count"/>
        /// property and comparing it to 0.
        /// </remarks>
        public int Count
        {
            get
            {
                //store head and tail positions in buffer,
                Segment head, tail;
                int headLow, tailHigh;
                GetHeadTailPositions(out head, out tail, out headLow, out tailHigh);

                if (head == tail)
                {
                    return tailHigh - headLow + 1;
                }

                //head segment
                int count = SEGMENT_SIZE - headLow;

                //middle segment(s), if any, are full.
                //We don't deal with overflow to be consistent with the behavior of generic types in CLR.
                count += SEGMENT_SIZE * ((int)(tail.m_index - head.m_index - 1));

                //tail segment
                count += tailHigh + 1;

                return count;
            }
        }

        /// <summary>
        /// Copies the <see cref="ConcurrentQueue{T}"/> elements to an existing one-dimensional <see
        /// cref="T:System.Array">Array</see>, starting at the specified array index.
        /// </summary>
        /// <param name="array">The one-dimensional <see cref="T:System.Array">Array</see> that is the
        /// destination of the elements copied from the
        /// <see cref="ConcurrentQueue{T}"/>. The <see cref="T:System.Array">Array</see> must have zero-based
        /// indexing.</param>
        /// <param name="index">The zero-based index in <paramref name="array"/> at which copying
        /// begins.</param>
        /// <exception cref="ArgumentNullException"><paramref name="array"/> is a null reference (Nothing in
        /// Visual Basic).</exception>
        /// <exception cref="ArgumentOutOfRangeException"><paramref name="index"/> is less than
        /// zero.</exception>
        /// <exception cref="ArgumentException"><paramref name="index"/> is equal to or greater than the
        /// length of the <paramref name="array"/>
        /// -or- The number of elements in the source <see cref="ConcurrentQueue{T}"/> is greater than the
        /// available space from <paramref name="index"/> to the end of the destination <paramref
        /// name="array"/>.
        /// </exception>
        public void CopyTo(T[] array, int index)
        {
            if (array == null)
            {
                throw new ArgumentNullException("array");
            }

            // We must be careful not to corrupt the array, so we will first accumulate an
            // internal list of elements that we will then copy to the array. This requires
            // some extra allocation, but is necessary since we don't know up front whether
            // the array is sufficiently large to hold the stack's contents.
            ToList().CopyTo(array, index);
        }

        /// <summary>
        /// Returns an enumerator that iterates through the <see
        /// cref="ConcurrentQueue{T}"/>.
        /// </summary>
        /// <returns>An enumerator for the contents of the <see
        /// cref="ConcurrentQueue{T}"/>.</returns>
        /// <remarks>
        /// The enumeration represents a moment-in-time snapshot of the contents
        /// of the queue.  It does not reflect any updates to the collection after
        /// <see cref="GetEnumerator"/> was called.  The enumerator is safe to use
        /// concurrently with reads from and writes to the queue.
        /// </remarks>
        public IEnumerator<T> GetEnumerator()
        {
            // Increments the number of active snapshot takers. This increment must happen before the snapshot is
            // taken. At the same time, Decrement must happen after the enumeration is over. Only in this way, can it
            // eliminate race condition when Segment.TryRemove() checks whether m_numSnapshotTakers == 0.
            Interlocked.Increment(ref m_numSnapshotTakers);

            // Takes a snapshot of the queue.
            // A design flaw here: if a Thread.Abort() happens, we cannot decrement m_numSnapshotTakers. But we cannot
            // wrap the following with a try/finally block, otherwise the decrement will happen before the yield return
            // statements in the GetEnumerator (head, tail, headLow, tailHigh) method.
            Segment head, tail;
            int headLow, tailHigh;
            GetHeadTailPositions(out head, out tail, out headLow, out tailHigh);

            //If we put yield-return here, the iterator will be lazily evaluated. As a result a snapshot of
            // the queue is not taken when GetEnumerator is initialized but when MoveNext() is first called.
            // This is inconsistent with existing generic collections. In order to prevent it, we capture the
            // value of m_head in a buffer and call out to a helper method.
            //The old way of doing this was to return the ToList().GetEnumerator(), but ToList() was an
            // unnecessary perfomance hit.
            return GetEnumerator(head, tail, headLow, tailHigh);
        }

        /// <summary>
        /// Helper method of GetEnumerator to seperate out yield return statement, and prevent lazy evaluation.
        /// </summary>
        private IEnumerator<T> GetEnumerator(Segment head, Segment tail, int headLow, int tailHigh)
        {
            try
            {
                SpinWait spin = new SpinWait();

                if (head == tail)
                {
                    for (int i = headLow; i <= tailHigh; i++)
                    {
                        // If the position is reserved by an Enqueue operation, but the value is not written into,
                        // spin until the value is available.
                        spin.Reset();
                        while (!head.m_state[i].m_value)
                        {
                            spin.SpinOnce();
                        }
                        yield return head.m_array[i];
                    }
                }
                else
                {
                    //iterate on head segment
                    for (int i = headLow; i < SEGMENT_SIZE; i++)
                    {
                        // If the position is reserved by an Enqueue operation, but the value is not written into,
                        // spin until the value is available.
                        spin.Reset();
                        while (!head.m_state[i].m_value)
                        {
                            spin.SpinOnce();
                        }
                        yield return head.m_array[i];
                    }
                    //iterate on middle segments
                    Segment curr = head.Next;
                    while (curr != tail)
                    {
                        for (int i = 0; i < SEGMENT_SIZE; i++)
                        {
                            // If the position is reserved by an Enqueue operation, but the value is not written into,
                            // spin until the value is available.
                            spin.Reset();
                            while (!curr.m_state[i].m_value)
                            {
                                spin.SpinOnce();
                            }
                            yield return curr.m_array[i];
                        }
                        curr = curr.Next;
                    }

                    //iterate on tail segment
                    for (int i = 0; i <= tailHigh; i++)
                    {
                        // If the position is reserved by an Enqueue operation, but the value is not written into,
                        // spin until the value is available.
                        spin.Reset();
                        while (!tail.m_state[i].m_value)
                        {
                            spin.SpinOnce();
                        }
                        yield return tail.m_array[i];
                    }
                }
            }
            finally
            {
                // This Decrement must happen after the enumeration is over.
                Interlocked.Decrement(ref m_numSnapshotTakers);
            }
        }

        /// <summary>
        /// Adds an object to the end of the <see cref="ConcurrentQueue{T}"/>.
        /// </summary>
        /// <param name="item">The object to add to the end of the <see
        /// cref="ConcurrentQueue{T}"/>. The value can be a null reference
        /// (Nothing in Visual Basic) for reference types.
        /// </param>
        public void Enqueue(T item)
        {
            SpinWait spin = new SpinWait();
            while (true)
            {
                Segment tail = m_tail;
                if (tail.TryAppend(item))
                    return;
                spin.SpinOnce();
            }
        }

        /// <summary>
        /// Attempts to remove and return the object at the beginning of the <see
        /// cref="ConcurrentQueue{T}"/>.
        /// </summary>
        /// <param name="result">
        /// When this method returns, if the operation was successful, <paramref name="result"/> contains the
        /// object removed. If no object was available to be removed, the value is unspecified.
        /// </param>
        /// <returns>true if an element was removed and returned from the beggining of the <see
        /// cref="ConcurrentQueue{T}"/>
        /// succesfully; otherwise, false.</returns>
        public bool TryDequeue(out T result)
        {
            while (!IsEmpty)
            {
                Segment head = m_head;
                if (head.TryRemove(out result))
                    return true;
                //since method IsEmpty spins, we don't need to spin in the while loop
            }
            result = default(T);
            return false;
        }

        /// <summary>
        /// Attempts to return an object from the beginning of the <see cref="ConcurrentQueue{T}"/>
        /// without removing it.
        /// </summary>
        /// <param name="result">When this method returns, <paramref name="result"/> contains an object from
        /// the beginning of the <see cref="T:System.Collections.Concurrent.ConccurrentQueue{T}"/> or an
        /// unspecified value if the operation failed.</param>
        /// <returns>true if and object was returned successfully; otherwise, false.</returns>
        public bool TryPeek(out T result)
        {
            Interlocked.Increment(ref m_numSnapshotTakers);

            while (!IsEmpty)
            {
                Segment head = m_head;
                if (head.TryPeek(out result))
                {
                    Interlocked.Decrement(ref m_numSnapshotTakers);
                    return true;
                }
                //since method IsEmpty spins, we don't need to spin in the while loop
            }
            result = default(T);
            Interlocked.Decrement(ref m_numSnapshotTakers);
            return false;
        }

        /// <summary>
        /// private class for ConcurrentQueue.
        /// a queue is a linked list of small arrays, each node is called a segment.
        /// A segment contains an array, a pointer to the next segment, and m_low, m_high indices recording
        /// the first and last valid elements of the array.
        /// </summary>
        private class Segment
        {
            //we define two volatile arrays: m_array and m_state. Note that the accesses to the array items
            //do not get volatile treatment. But we don't need to worry about loading adjacent elements or
            //store/load on adjacent elements would suffer reordering.
            // - Two stores:  these are at risk, but CLRv2 memory model guarantees store-release hence we are safe.
            // - Two loads: because one item from two volatile arrays are accessed, the loads of the array references
            //          are sufficient to prevent reordering of the loads of the elements.
            internal volatile T[] m_array;

            // For each entry in m_array, the corresponding entry in m_state indicates whether this position contains
            // a valid value. m_state is initially all false.
            internal volatile VolatileBool[] m_state;

            //pointer to the next segment. null if the current segment is the last segment
            private volatile Segment m_next;

            //We use this zero based index to track how many segments have been created for the queue, and
            //to compute how many active segments are there currently.
            // * The number of currently active segments is : m_tail.m_index - m_head.m_index + 1;
            // * m_index is incremented with every Segment.Grow operation. We use Int64 type, and we can safely
            //   assume that it never overflows. To overflow, we need to do 2^63 increments, even at a rate of 4
            //   billion (2^32) increments per second, it takes 2^31 seconds, which is about 64 years.
            internal readonly long m_index;

            //indices of where the first and last valid values
            // - m_low points to the position of the next element to pop from this segment, range [0, infinity)
            //      m_low >= SEGMENT_SIZE implies the segment is disposable
            // - m_high points to the position of the latest pushed element, range [-1, infinity)
            //      m_high == -1 implies the segment is new and empty
            //      m_high >= SEGMENT_SIZE-1 means this segment is ready to grow.
            //        and the thread who sets m_high to SEGMENT_SIZE-1 is responsible to grow the segment
            // - Math.Min(m_low, SEGMENT_SIZE) > Math.Min(m_high, SEGMENT_SIZE-1) implies segment is empty
            // - initially m_low =0 and m_high=-1;
            private volatile int m_low;
            private volatile int m_high;

            private volatile ConcurrentQueue<T> m_source;

            /// <summary>
            /// Create and initialize a segment with the specified index.
            /// </summary>
            internal Segment(long index, ConcurrentQueue<T> source)
            {
                m_array = new T[SEGMENT_SIZE];
                m_state = new VolatileBool[SEGMENT_SIZE]; //all initialized to false
                m_high = -1;
                Contract.Assert(index >= 0);
                m_index = index;
                m_source = source;
            }

            /// <summary>
            /// return the next segment
            /// </summary>
            internal Segment Next
            {
                get { return m_next; }
            }

            /// <summary>
            /// return true if the current segment is empty (doesn't have any element available to dequeue,
            /// false otherwise
            /// </summary>
            internal bool IsEmpty
            {
                get { return (Low > High); }
            }

            /// <summary>
            /// Add an element to the tail of the current segment
            /// exclusively called by ConcurrentQueue.InitializedFromCollection
            /// InitializeFromCollection is responsible to guaratee that there is no index overflow,
            /// and there is no contention
            /// </summary>
            /// <param name="value"></param>
            internal void UnsafeAdd(T value)
            {
                Contract.Assert(m_high < SEGMENT_SIZE - 1);
                m_high++;
                m_array[m_high] = value;
                m_state[m_high].m_value = true;
            }

            /// <summary>
            /// Create a new segment and append to the current one
            /// Does not update the m_tail pointer
            /// exclusively called by ConcurrentQueue.InitializedFromCollection
            /// InitializeFromCollection is responsible to guaratee that there is no index overflow,
            /// and there is no contention
            /// </summary>
            /// <returns>the reference to the new Segment</returns>
            internal Segment UnsafeGrow()
            {
                Contract.Assert(m_high >= SEGMENT_SIZE - 1);
                Segment newSegment = new Segment(m_index + 1, m_source); //m_index is Int64, we don't need to worry about overflow
                m_next = newSegment;
                return newSegment;
            }

            /// <summary>
            /// Create a new segment and append to the current one
            /// Update the m_tail pointer
            /// This method is called when there is no contention
            /// </summary>
            internal void Grow()
            {
                //no CAS is needed, since there is no contention (other threads are blocked, busy waiting)
                Segment newSegment = new Segment(m_index + 1, m_source);  //m_index is Int64, we don't need to worry about overflow
                m_next = newSegment;
                Contract.Assert(m_source.m_tail == this);
                m_source.m_tail = m_next;
            }

            /// <summary>
            /// Try to append an element at the end of this segment.
            /// </summary>
            /// <param name="value">the element to append</param>
            /// <param name="tail">The tail.</param>
            /// <returns>true if the element is appended, false if the current segment is full</returns>
            /// <remarks>if appending the specified element succeeds, and after which the segment is full,
            /// then grow the segment</remarks>
            internal bool TryAppend(T value)
            {
                //quickly check if m_high is already over the boundary, if so, bail out
                if (m_high >= SEGMENT_SIZE - 1)
                {
                    return false;
                }

                //Now we will use a CAS to increment m_high, and store the result in newhigh.
                //Depending on how many free spots left in this segment and how many threads are doing this Increment
                //at this time, the returning "newhigh" can be
                // 1) < SEGMENT_SIZE - 1 : we took a spot in this segment, and not the last one, just insert the value
                // 2) == SEGMENT_SIZE - 1 : we took the last spot, insert the value AND grow the segment
                // 3) > SEGMENT_SIZE - 1 : we failed to reserve a spot in this segment, we return false to
                //    Queue.Enqueue method, telling it to try again in the next segment.

                int newhigh = SEGMENT_SIZE; //initial value set to be over the boundary

                //We need do Interlocked.Increment and value/state update in a finally block to ensure that they run
                //without interuption. This is to prevent anything from happening between them, and another dequeue
                //thread maybe spinning forever to wait for m_state[] to be true;
                try
                { }
                finally
                {
                    newhigh = Interlocked.Increment(ref m_high);
                    if (newhigh <= SEGMENT_SIZE - 1)
                    {
                        m_array[newhigh] = value;
                        m_state[newhigh].m_value = true;
                    }

                    //if this thread takes up the last slot in the segment, then this thread is responsible
                    //to grow a new segment. Calling Grow must be in the finally block too for reliability reason:
                    //if thread abort during Grow, other threads will be left busy spinning forever.
                    if (newhigh == SEGMENT_SIZE - 1)
                    {
                        Grow();
                    }
                }

                //if newhigh <= SEGMENT_SIZE-1, it means the current thread successfully takes up a spot
                return newhigh <= SEGMENT_SIZE - 1;
            }

            /// <summary>
            /// try to remove an element from the head of current segment
            /// </summary>
            /// <param name="result">The result.</param>
            /// <param name="head">The head.</param>
            /// <returns>return false only if the current segment is empty</returns>
            internal bool TryRemove(out T result)
            {
                SpinWait spin = new SpinWait();
                int lowLocal = Low, highLocal = High;
                while (lowLocal <= highLocal)
                {
                    //try to update m_low
                    if (Interlocked.CompareExchange(ref m_low, lowLocal + 1, lowLocal) == lowLocal)
                    {
                        //if the specified value is not available (this spot is taken by a push operation,
                        // but the value is not written into yet), then spin
                        SpinWait spinLocal = new SpinWait();
                        while (!m_state[lowLocal].m_value)
                        {
                            spinLocal.SpinOnce();
                        }
                        result = m_array[lowLocal];

                        // If there is no other thread taking snapshot (GetEnumerator(), ToList(), etc), reset the deleted entry to null.
                        // It is ok if after this conditional check m_numSnapshotTakers becomes > 0, because new snapshots won't include
                        // the deleted entry at m_array[lowLocal].
                        if (m_source.m_numSnapshotTakers <= 0)
                        {
                            m_array[lowLocal] = default(T); //release the reference to the object.
                        }

                        //if the current thread sets m_low to SEGMENT_SIZE, which means the current segment becomes
                        //disposable, then this thread is responsible to dispose this segment, and reset m_head
                        if (lowLocal + 1 >= SEGMENT_SIZE)
                        {
                            //  Invariant: we only dispose the current m_head, not any other segment
                            //  In usual situation, disposing a segment is simply seting m_head to m_head.m_next
                            //  But there is one special case, where m_head and m_tail points to the same and ONLY
                            //segment of the queue: Another thread A is doing Enqueue and finds that it needs to grow,
                            //while the *current* thread is doing *this* Dequeue operation, and finds that it needs to
                            //dispose the current (and ONLY) segment. Then we need to wait till thread A finishes its
                            //Grow operation, this is the reason of having the following while loop
                            spinLocal = new SpinWait();
                            while (m_next == null)
                            {
                                spinLocal.SpinOnce();
                            }
                            Contract.Assert(m_source.m_head == this);
                            m_source.m_head = m_next;
                        }
                        return true;
                    }
                    else
                    {
                        //CAS failed due to contention: spin briefly and retry
                        spin.SpinOnce();
                        lowLocal = Low; highLocal = High;
                    }
                }//end of while
                result = default(T);
                return false;
            }

            /// <summary>
            /// try to peek the current segment
            /// </summary>
            /// <param name="result">holds the return value of the element at the head position,
            /// value set to default(T) if there is no such an element</param>
            /// <returns>true if there are elements in the current segment, false otherwise</returns>
            internal bool TryPeek(out T result)
            {
                result = default(T);
                int lowLocal = Low;
                if (lowLocal > High)
                    return false;
                SpinWait spin = new SpinWait();
                while (!m_state[lowLocal].m_value)
                {
                    spin.SpinOnce();
                }
                result = m_array[lowLocal];
                return true;
            }

            /// <summary>
            /// Adds part or all of the current segment into a List.
            /// </summary>
            /// <param name="list">the list to which to add</param>
            /// <param name="start">the start position</param>
            /// <param name="end">the end position</param>
            internal void AddToList(List<T> list, int start, int end)
            {
                for (int i = start; i <= end; i++)
                {
                    SpinWait spin = new SpinWait();
                    while (!m_state[i].m_value)
                    {
                        spin.SpinOnce();
                    }
                    list.Add(m_array[i]);
                }
            }

            /// <summary>
            /// return the position of the head of the current segment
            /// Value range [0, SEGMENT_SIZE], if it's SEGMENT_SIZE, it means this segment is exhausted and thus empty
            /// </summary>
            internal int Low
            {
                get
                {
                    return Math.Min(m_low, SEGMENT_SIZE);
                }
            }

            /// <summary>
            /// return the logical position of the tail of the current segment
            /// Value range [-1, SEGMENT_SIZE-1]. When it's -1, it means this is a new segment and has no elemnet yet
            /// </summary>
            internal int High
            {
                get
                {
                    //if m_high > SEGMENT_SIZE, it means it's out of range, we should return
                    //SEGMENT_SIZE-1 as the logical position
                    return Math.Min(m_high, SEGMENT_SIZE - 1);
                }
            }

        }
    }//end of class Segment

    /// <summary>
    /// A wrapper struct for volatile bool, please note the copy of the struct it self will not be volatile
    /// for example this statement will not include in volatilness operation volatileBool1 = volatileBool2 the jit will copy the struct and will ignore the volatile
    /// </summary>
    struct VolatileBool
    {
        public VolatileBool(bool value)
        {
            m_value = value;
        }
        public volatile bool m_value;
    }
}


WordPress has a new comprehensive SEO solution. Yoast.com has announced that the new WordPress SEO plugin is now in public beta. The beta period will probably last another two weeks or more. This plugin is packed full of SEO goodies, including titles, meta descriptions, breadcrumbs, XML sitemaps and some impressive new features.
Another really handy feature is the Focus Keyword that you see in the image above. It will automatically check your content for usage of the keyword so that you can optimize your page accordingly.
WordPress SEO also comes with breadcrumbs support, including configurable breadcrumbs titles, making Yoast's previous breadcrumbs plugin obsolete.
You have the options to index, follow, noindex or nofollow any tag, category or custom taxonomy, as well as to give them unique titles and meta descriptions. This makes the plugin very flexible to allow you to promote or hide content as you wish.
My favorite feature of this plugin is the ability to easily edit the robots.txt and .htaccess files from the files menu inside the plugin's dashboard panel. It saves time when working with a site, because you don't have to fire up your FTP client. It's just another little piece of convenience included in the WordPress SEO plugin.
The WordPress SEO plugin comes packaged with a News SEO module, which allows for the generation of a XML News Sitemap. This is a necessary requirement if you want your site to be included in Google News. A Video SEO and a Local SEO module will be developed next as premium add-ons.
These are just a few exciting features of the all-new WordPress SEO plugin. A full explanation of features is included on the WordPress SEO plugin's homepage. We're excited to see this new addition to the SEO toolbox available to the WordPress community. Even though it's still in beta, this is one you're going to want to watch. It's shaping up to be an excellent plugin.


Hi, I'm Mark, an International Emmy nominated and PAGE award-winning screenwriter, novelist, script editor and speaker. I've had my work broadcast on Sky Arts, Sky One, the BBC, the Cartoon Network and Disney XD.
On this site you can find writing blogs and my fantasy series, Heroes of Hastovia, which is a mix of my love of fantasy worlds, hapless characters, and my strange imagination, influenced by growing up on RPGs and choose your own adventure books.
Join my mailing list if you want to hear about the latest book offers, get sent blogs and receive a FREE book, plus other exclusive content.


Jay covered the plane with the colors I had chosen. You can see the underside of my wing, in all of its orange glory. There's also a green stripe along the leading edge, but it's difficult to see in this picture.
It's all in white… except for the underside. Jay has never covered a plane with the light color on top and the super-contrasting color on the bottom. I told him that I wanted the orange on the bottom so that no matter what color the sky was behind it I should be able to see its orientation as I'm learning to fly.
I decided that I wouldn't be able to cut out the Dolphins logo or name in the exact way that it should be displayed, so we cheated. We went to the local sports fan shop and bought stickers that people usually put on their cars. Are you ready for the unveil??
I did a little happy dance when I saw all of the stickers applied and the nose on it. I can't wait to get it up in the air!
Even the sticker on the fuselage looks good. I'm currently on the search for the perfect material to use for the wheel pants. I'm going to make them like the wheel pants on the LT, but they have to go with the theme of the plane.
The Kavalier is just about done. There are a few little details left (like gluing the canopy to the wing), but we could take it out and fly it tonight if we wanted. I'm just so excited! I can't wait to see it in the air. Jay is going to set up a plane on the simulator that will fly in a similar manner to the Kavalier so that I can get used to it before the snow melts and we can actually get up to the field.
This entry was posted in Miami Dolphins, RC Planes and tagged Kavalier, Miami Dolphins, R/C, RC Planes. Bookmark the permalink.


In my previous post I talked about ForumCoin Faucet and how easy it is to use and everyone using ForumCoin should really sign up to it, to get those extra ForumCoins. Another great way to earn some extra ForumCoin though is to become a writer for the site and post some articles. So let's check it out together.
Finding it is very easy. On The Forum index page it is at the bottom where it says "Articles & Tutorials". I understand writing is not for everyone. That section has been up for quite a while and I didn't post my first article until Feb 9th 2017. I waited a long time because even though I love to write and enjoy writing I do get self conscious about it. So since that date I have managed to post 2 articles which earned me 100 ForumCoins so far. 100 ForumCoins is the equivalent of $1.00.
After you sign up you should make an introduction post and from there just post and add some good comments to existing threads or make your own. ForumCoin is a wonderful place I have been paid many times. Please keep in mind though that ForumCoin is just an extra cash website that you should add to your existing earning websites or just do it for fun! I can't stress this enough, ForumCoin won't make you rich. ForumCoin is a forum that pays you to post. Not a huge amount but an amount.
Now I mentioned above to try to make some post before applying to become a writer and this is why. ForumCoin has a much different process then some writing sites. You don't need to submit a 1st article to write in the "Articles & Tutorials" section.
I did not talk about article earnings in great detail yet as I am sure it might scare a few people off. This is how it works. When you post your article you get 50 ForumCoins for posting it. So 50 cents in other words. To gain the 100 ForumCoins ($1.00) your article must receive at least 20 replies and 300 views. I have yet to get the extra dollar but I don't mind. I don't think my writing is good enough to get 300 views to be honest and I don't mind that because I am happy with the 50 ForumCoins for the article I posted.
I don't think this is a bad deal when you factor in low payment amounts on sites like Niume or LiteracyBase for example. Try to keep in mind too that ForumCoin is staying alive for us to make extra cash by having these rules.


"You Love Sports" offers you a 15 day return policy. This means that within 15 days from the date of delivery you can ask for replacement of the products.
The purchased product can be replaced in case of any manufacturing defect found in the product and the same product will be replaced with a new one.
Before the product is replaced it will be inspected by the YouLoveSports team.
Our policy is applicable only if the product is not used and returned in the Original packaging and there are no signs of wear and tear.
The return policy will not be applicable in excess of 15 days.
Replacement is offered for the products sold by YouLoveSports ONLY.
If after using the product you find there is a defect or damage for any reason, returns and replacement will be as per the warranty terms and conditions.
If you cancel your order before the product has been shipped, you can choose to have the entire amount refunded or choose a different product. In case of a refund, the same amount will be credited in the manner in which the Original payment had been made.
DO NOT accept delivery of any shipments where the packaging is damaged in any manner. If for any reason, after taking the delivery, you realize that the product is damaged in any manner, you need to report the matter to our customer service within 24 hours of the delivery. YouLoveSports will bear the cost of replacements, if the damage is found to be due to mishandling in transit. These returns will not be accepted if there is any identification of use of the product.
The 15 day replacement Guarantee on the product(s) sold by YouLoveSports is at the sole discretion of YouLoveSports and the decision of YouLoveSports shall be final and binding. YouLoveSports reserves the right to withdraw from the replacement warranty at any time without giving any intimation whatsoever.
Before proceeding with any return please contact our customer service. They will guide you regarding the process. Customers need to produce the Original invoice and the items need to be returned in their Original packaging.


Mangrove Steelband is one of the most prominent steel orchestras in Europe and is commonly known as "The People's Choice".
Formed in 1980 on All Saints Road in Notting Hill, Mangrove started as a 'Pan Round Neck' band of the traditional type. Since then they have developed a reputation for musical excellence and professionalism.
A core element of fifteen dedicated players rehearse and perform throughout the year. During the summer months this figure swells to seventy five as the band prepares to participate at the UK National Panorama Competition – a title they have captured nine times.
With a wide repertoire they have performed at a diversity of prestigious venues and events around the world. They are no strangers to high profile performances as the band has appeared in front of an array of distinguished guests including HRH the Queen, international royalty and heads of states.
Mangrove Steel band provides classes at their pan yard base at Carnival Village at The Tabernacle, Powis Square, London W11 2AY. Students follow a progressive programme of basic technical skills, steel pan repertoire and history, aural training and musicianship, improvisation and performance.


Are you struggling to find a company that can ship your goods to anywhere in Africa? By choosing to use our service at Luna Shipping, you can have your goods shipped to any destination with our affordable shipping to Africa.
Whether it's palletized goods, vehicles or even personal items, we at Luna Shipping are sure that we can provide you with suitable support for transferring your goods. During the journey we can also let you know where your items are along the way; giving you peace of mind that you know where your goods are throughout the course.
Previous customers have praised us for our communication and attentive services. Many clients have become long-term partners of our company and use our services on a regular basis.
For over 18 years we have been providing our top-quality shipping services and have become one of the largest export shipping businesses in the UK. Don't hesitate to choose our team at Luna Shipping and you too can experience a stress-free service.
If you would like to have your items shipped to Africa by our accomplished team or want to find out more about our service, you can email us at sales@lunashipping.co.uk. Alternatively, you can give us a call on 0208 508 8088.


The Voices of Gwynedd is a 100-member choir comprised of full- and part-time students, faculty, staff, alumni and friends of Gwynedd Mercy University. Directed by Carol Evans, a seasoned soprano and assistant professor of music in the School of Arts and Sciences, the choir has developed into a highly professional choral ensemble presenting quality programs representing many different genres. Performances by the choir and our musical collaborators are establishing GMercyU as a strong cultural presence in Southeastern Pennsylvania and the entire Tri-state area.
Stay tuned for announcements on the 2019 events!
Show your support for the Voices of Gwynedd by taking part in one of our many fundraisers.
Candles are a favorite holiday tradition, so why not contact a VOG member now to order your favorite scent, beautiful holders or one-of-a-kind wrapping paper for the holidays! Or order online at www.yankeecandlefundraising.com and use Group Number: 990037105. All orders are due by October 22, for Christmas delivery. For more information, please contact the VOG Office at 215-646-7300, ext. 21157 or vog@gmercyu.edu.
Carol Evans is Assistant Professor of Music and Choral Director of The Voices of Gwynedd at Gwynedd Mercy University. Carol has distinguished herself by receiving the Christian R. and Mary F Lindback Award for Distinguished Teaching at Gwynedd Mercy University and also the Gwynedd Mercy University Outstanding Professor of the Year Award.
Carol holds a Master of Music degree in Vocal Performance from Temple University and a bachelor's degree in Music Education from the Wheaton College Conservatory of Music. Under the Carol's direction, the Voices of Gwynedd has developed into a highly professional choral ensemble presenting quality programs of many different genres.


This study is about battery transportation by a Vehicle Manufacturer that was found to have inefficient space utilization in the truck container. This problem negatively affected the company's profit and opportunity. Therefore, the use of GRASP (Greedy Randomized Adaptive Search Procedure) is proposed to minimize the problem substantially. In this research, a Vehicle Manufacturer focuses on its battery exports, which are transported by commercial vehicles. Data was collected by interviewing personnel, observing actual operations, and analyzing historical data. The result showed that a container truck utilized only 68% of its space. This impacted two areas: a high number of transportation trips, and high transportation cost. The conceptual framework of the research is to find the causes of the battery transportation problem as well as to implement GRASP methodology as a solution. GRASP methodology is a heuristics approach to allocating the right space. This methodology is widely applied in vessel container businesses, and can be useful in related fields such as truck containers. The objective of this research is to build a significant tool to enhance space utilization for loading batteries. The result indicates that the proposed solution can be accomplished and solve space utilization. According to this research, the company should implement a tower rack to stack batteries on pallets, and change the truck size from six wheels to ten wheels. These changes will provide cost saving, customer satisfaction, and collaboration, which increases the focus firm's competitiveness in the industry.


text:
Hotcelebon.com
Home » Celebrities » 'Willy Wonka' Actress Denise Nickerson Dead at 62
'Willy Wonka' Actress Denise Nickerson Dead at 62
Denise Nickerson, the actress best known for playing Violet Beauregarde in Willy Wonka & the Chocolate Factory, died on Wednesday, July 10. She was 62.
"She's gone," Nickerson's son, Josh, and his wife, Jasmine, announced in a Facebook post.
Josh and Jasmine, who described themselves as the former child star's "only immediately family and caretakers," had been providing updates about Nickerson's health on Facebook since she suffered a severe stroke in June 2018.
"It's been a long, hard year, and we have been with her and caring for her everyday since then," the couple wrote in a GoFundMe campaign created earlier this month to raise money for Nickerson's funeral expenses. "Jasmine quit her job to stay at home with [Denise] full-time so she didn't have to live in a nursing home. We gave up over half of our income at that time and have done everything we can to survive. Joshua works a second job to float us for groceries and necessities. We found out in January we are pregnant with [our] first child, due August 26th."
Nickerson's condition worsened on Monday, July 8, when "she aspirated, and caught pneumonia" after being rushed to the hospital, according to the GoFundMe page. The next day, she had a massive seizure and was subsequently "in a coma-like state."
"They just took off all the equipment. None of it was helping, but making her only more uncomfortable," Josh and Jasmine wrote on Facebook early Wednesday morning. "We're telling her it's okay to let go."
The New York City native got her big break in 1968 when she joined the cast of the ABC soap opera Dark Shadows as Amy Jennings and Nora Collins. At the age of 13, she landed her signature role as the sassy, gum-chewing Violet in the 1971 adaptation of Willy Wonka & the Chocolate Factory.
Nickerson later had roles on TV shows including PBS' The Electric Company and CBS' Search for Tomorrow, in addition to a one-episode stint as Peter Brady (Christopher Knight)'s girlfriend on ABC's The Brady Bunch. Her final onscreen appearance was in the 1978 movie Zero to Sixty.
The actress' Willy Wonka costars Julie Dawn Cole (Veruca Salt) and Paris Themmen (Mike Teevee) paid her a visit in September 2018 as she recovered from her stroke at home.
« Fans Think Taylor Swift Shaded Scooter Braun With a Single Lyric
Prince Harry Received Perfect Greeting at Event After Busy Day with Archie: 'Are You Still Awake?' »
'Bachelor' Trivia: Test Your Knowledge on Queen Victoria and More
New Radicals Reunite To Sing 'You Get What You Give' For Biden Inauguration 'Parade'
Love Island's Dr Alex opens up about finding out his brother killed himself
Lucie Arnaz Weighs In on Lucille Ball Casting Controversy
EastEnders star Jessica Plummer in tears as she misses her daughter
Jason Cope of The Steel Woods Dies at 42
Dancing On Ice's Rufus Hound SLAMS Government over free meals scandal
Barack Obama Shares A Sweet Message To Michelle Obama For Her BDAY!

redpajama_set_name: RedPajamaCommonCrawl


text:
/*----------------------------------------------------------------------------*/
/* Copyright (c) FIRST 2016. All Rights Reserved.                             */
/* Open Source Software - may be modified and shared by FRC teams. The code   */
/* must be accompanied by the FIRST BSD license file in the root directory of */
/* the project.                                                               */
/*----------------------------------------------------------------------------*/

#include "external_limit_switch.h"

ExternalLimitSwitch::ExternalLimitSwitch(sdf::ElementPtr sdf) {
  sensor = std::dynamic_pointer_cast<sensors::ContactSensor>(
      sensors::get_sensor(sdf->Get<std::string>("sensor")));

  gzmsg << "\texternal limit switch: "
        << " sensor=" << sensor->Name() << std::endl;
}

bool ExternalLimitSwitch::Get() {
  return sensor->Contacts().contact().size() > 0;
}

redpajama_set_name: RedPajamaGithub


text:
Armadillo insularis is een pissebed uit de familie Armadillidae. De wetenschappelijke naam van de soort is voor het eerst geldig gepubliceerd in 1933 door Arcangeli.

Armadillidae

redpajama_set_name: RedPajamaWikipedia


text:
California immigrant youth will not be scapegoat for Democrats' nativist proposals
By Luis Ojeda and Deyaneira Garcia — 07/21/15 05:00 PM EDT
The views expressed by contributors are their own and not the view of The Hill
View Latest Opinions >>
The July 1 shooting of Katheryn Steinle by Juan Francisco Lopez was truly a tragedy. Early reports indicate it was potentially a terrible accident where anyone at the wrong place and at the wrong time could have found themselves at the center of it. Those details will be answered in court, but lack of them has not stopped opportunists from both major political parties to come out of the woodwork to exploit the situation for short-sighted political gain.
Reactionary response is something we've come to expect from Republicans like Donald Trump Donald John TrumpTrump rails against impeachment in speech to Texas farmers Trump administration planning to crack down on 'birth tourism': report George Conway on Trump adding Dershowitz, Starr to legal team: 'Hard to see how either could help' MORE and Rep. Steve King (Iowa). But the response from California's Democratic Sens. Dianne Feinstein Dianne Emiel FeinsteinSenate opens Trump impeachment trial Democrats ask if US citizens were detained at border checkpoints due to Iranian national origin Pelosi set to send impeachment articles to the Senate next week MORE and Barbara Boxer Barbara Levy BoxerFormer Democratic Sen. Barbara Boxer joins DC lobbying firm Hillicon Valley: Ocasio-Cortez clashes with former Dem senator over gig worker bill | Software engineer indicted over Capital One breach | Lawmakers push Amazon to remove unsafe products Ocasio-Cortez blasts former Dem senator for helping Lyft fight gig worker bill MORE worry us most. They've turned the hateful rhetoric into policy proposals that threaten to fill prisons and trample on the constitutional rights of millions of immigrants to a degree demagogues like Trump could only dream of.
When the public reaction to the incident first started, we stayed quiet. We believed that a family should be able to mourn without their suffering being manipulated or put in the public eye. Even when Trump, Clinton, and others started equating the act of one person with all of us, we wanted to honor the tragedy for what it is and not feed into the frenzy.
But now that the senators are holding hearings and proposing policies, they are threatening all of our families. And we will not allow that to happen.
We will not be your scapegoat.
When a young white man deliberately walks into a church and murders black parishioners to instigate race war, there is no sweeping legislative response. When black churches burn across the South, the media speculates if it's caused by faulty wiring. When a black person is killed by law enforcement, security, or vigilante every 28 hours, politicians hesitate to respond with even a hashtag.
But when incidents reinforce stereotypes or serve prejudiced agendas, we've seen bipartisan readiness to act. One person's actions are used to judge entire races of people and one family's loss is exploited to break apart thousands of others.
In the wake of tragedy, it is always hard to find a way forward. But dividing our communities is never the answer. We need solutions that bring us more closely together as a whole and serve our best interests not our worst fears.
Policies like what Feinstein is proposing are the cause of California Immigrant Youth Justice Alliance members having empty seats at their family's meals. Marcela and her cousins haven't seen her uncle in five years after he was deported for a drug offense; Adrian and his siblings can only see their deported parents through a computer screen. Policies like these are the reason the majority of middle school youth who attended OC Immigrant Youth United's summer program are deeply fearful of police officers, and intimately aware of the consequences of collaborations between local police and ICE.
We can't begin to understand what the Steinle family is going through. But we do know deeply the harm and the sorrow that U.S. deportation policy has inflicted on our own. We've worked hard to heal from the traumas caused by growing up in a country that threatens to take away our loved ones at any moment. Feinstein's proposal would undo that healing but it won't prevent any future incidents because it's a false solution. We won't allow ourselves to be scapegoated, and thankfully in this case, neither will the constitution her proposal would shred to pieces.
Ojeda is the statewide coordinator for the California Immigrant Youth Justice Alliance, a network of thirteen immigrant youth-led organizations from San Diego to Sonoma County. Garcia is a student at Segerstrom High School, a member of the Orange County Immigrant Youth United, and a Steering Committee member of the California Immigrant Youth Justice Alliance.
Tags Dianne Feinstein Barbara Boxer Donald Trump


text:
Interview with Actor Paul Higgins
17 December 2014 | Jessica Johnston
"I first did John the Baptist and my lines were taken off me because they said I couldn't act."
Actor Paul Higgins is best known for his role as foul-mouthed Press Officer Jamie McDonald in political comedy series The Thick of It. But as well as being a pro in profanities, he is also well versed in the world of theatre. London Calling managed to catch up with Paul backstage at the Royal Court, ahead of a performance of his new play Hope, directed by John Tiffany, to find out about local authorities, government cuts and becoming an actor.
London Calling: So what's Hope about?
Paul Higgins: It's about a Labour council in a working class town that has to implement government cuts. This is something that is happening across Britain, with local authorities having to administer cuts imposed on them by the government, which means their budgets are reduced by millions of pounds every year. The play is really about these people in the council who went into politics to do one thing and have ended up doing something completely alien to them; making cuts is not the sort of thing Labour councillors want to do.
LC: Tell us about your character Mark...
PH: Mark is a divorced, recovering alcoholic who is a committed member of the Labour party. He is also Deputy Leader of his local council and is committed to being a good professional counsellor. At the start of the play he is quite gung ho about making these cuts, legally he has to do it and so he tries to find the areas where the cuts can be made, but during the play he struggles more and more with the things he has to cut and close down.
LC: How was the rehearsal process?
PH: It was really good. We did a lot of research during the rehearsal process, with each of us adopting a different council from across Britain to follow. We used to report back on the sorts of things our council was doing and the decisions the councillors were making day to day. It was interesting and people may find it somewhat surprising that the nature of these cuts means that they hit poor towns much harder than they hit rich towns. In the play it is revealed that Hart district council in Hampshire, which is the least deprived council in Britain, has cuts resulting in the loss of £28 per person whilst in Liverpool District B, the most deprived area, the figure is over £800 per person.
LC: How is it to work with John Tiffany again?
PH: It's great to work with John again. We did the original production of Black Watch together, which was a massive international success and such an amazing play to be a part of. John also directed a play that I wrote and he did a fantastic job on that! So we know each other quite well and I really enjoy working with him. John knows exactly what he is doing and because we have worked together before, I have got such a lot of confidence in him. It's great, as an actor, to go into rehearsals knowing that if the director asks you to do something there is a very good reason for it.
LC: What did you think when you first read Jack Thorne's script?
PH: I though it was very unusual, because you don't usually see plays about local politics. Local politics is very important and I think most of us don't realise what an influence local politics has on our lives, we just notice when are bins don't get emptied and that sort of thing. This is an untold story about the people who don't get paid, except a small amount of expenses, but who are really dedicated to doing some good in their community.
Usually if you watch anything about local councillors they are presented with that kind of satire that belittles them, but Jack doesn't do that, he likes these people and he thinks they are good people struggling to do a really difficult job. It's very unusual to see a play written from that perspective. It's important to mention that the play is really funny but just not in that satirical way.
LC: Did you always want to pursue a career in acting?
PH: No I actually never wanted to be an actor. I got into drama through singing and performed in musicals at my high school. I first did John the Baptist and my lines were taken off me because they said I couldn't act. Eventually they did give me some lines in another musical and that production was seen by a professional director who invited us all to a drama camp a few weeks before I was heading off to university. The director ended up giving me the lead part in the play and told me that I should be an actor. I had enjoyed the experience so much that I deferred my university entry, auditioned for drama school and got accepted into every single one I applied for. When I went home and told my mum I got in, her face fell and she said 'well if you've got any talent I can't see it' because she was so keen on me going to university. She hates me telling that story.
LC: You are best known for playing Press Officer Jamie McDonald. Did you find it challenging to muster such viciousness for the role or was it surprisingly easy?
PH: Oh it all came naturally to me. I have always been able to channel rage from somewhere. Rage is on tap.
LC: As well as acting in plays, you have also turned to writing them. What inspired you to put pen to paper and write Nobody Will Ever Forgive Us?
PH: I always wanted to write something, it just took me a very long time to decided to write something right through to the end regardless of whether it was good or not. I started with an autobiographical story because I wanted to capture the voice of my dad. He had a very particular way of speaking, he was very bright, somewhat poetic and a complete bullshit artist as well. I just wanted to try and get his voice, which was my main goal at first and then a fictional story developed from there. Seeing the end result being performed on stage was thrilling.
LC: Do you find that that there is an overlap between acting and writing?
PH: There is definitely a huge overlap. Actors are reputed to be good at writing dialogue and I think we probably are because we know what is 'say-able'. Sometimes you look at a line and think, well that's good writing but its not very 'say-able', it's too long or it's too well written. Sometimes you have to think really hard about what you are going to say but most of the time the characters are improvising, so the way they speak should have that quality and I think actors understand that.
LC: And finally, what should audiences expect when they come and see Hope?
PH: They should expect to be entertained; the play is funny and it doesn't out stay its welcome as each half is less than an hour long. Audiences will learn about local government in general and about the massive problem in local politics right now, this second. You really couldn't see a more current play and there are even councils in Britain who are considering doing what we do in the play. There is stuff in the play about divorce and having a teenage son and coping with work and family life so this really is a proper human drama as apposed to an education.
Hope is on at the Royal Court from 26th November – 10th January. Tickets cost £10 - £32, available here.


Kyle joined CtR as our Rector in 2017, and lives on Francis Peninsula with his wife Becky.
Our Rector's Warden, and also leads our Music Ministry. She and her husband Ian live on Fran Pen.
Our People's Warden. She and her husband Andrew live in Garden Bay.
The 2018-2019 Parish Council also includes Laurie Barker (treasurer), Sue Campbell (member-at-large), Nancy Enns (secretary), and Ian Mackay (verger). We are under Bishop Trevor Walters (Victoria, BC) and nationally under Bishop Charlie Masters, in the Anglican Network in Canada.


Do You Stand by Your Brand? It's Time for an Audit.
While many executives will rightfully claim that they understand the benefits of a great brand, the bigger test is how well they defend it when things go wrong.
Take Target's recent credit card security breach that potentially compromised as many as 70 million customers who, up until that time, expected the national retailer to protect their identities. It couldn't have happened at a worse time -- during the holiday shopping season -- and will likely cost them in the tens if not hundreds of millions of dollars in lawsuit settlements, penalties and lost revenues.
Yet to Target's credit, they came out very early to notify and apologize to those who were affected as well as the consumer-buying public, offering a 10 percent discount on all purchases made the weekend prior to Christmas. This is the mark of a great company; one that lives up to its promise by trying to make things right when things go awry.
At the most basic level, a brand is a set of both tangible and intangible items -- stories, illustrations, activities, statements, culture and much more -- that collectively invite an individual or entity to enter into a "memorable" relationship with a business. This customer relationship and experience will in turn generate brand equity for your business, thus creating new and repeat sales.
Brand strategy. Review the company's business and marketing plans and measure it against what the brand is supposed to represent. This should be a frank review of the organization's strengths and weaknesses as well as an evaluation of the market opportunities and threats that could support or potentially impede the success of the company.
Brand positioning. Take an honest look at how the company's brand is positioned and how it measures up to the competition. Better yet, interview or survey key management and staff about what they believe to be the company's positioning and mission as well as their understanding their beliefs about the brand, either real or perceived. Some surprising truths -- both positive and negative -- will come forth.
Customer journey. Review how customers shop for the company's particular products or services, who are their influencers and what their buying pattern is. The experience from their perspective is important to understand as it is all part of the brand.
Customer analysis. It's important to perform both qualitative and -- if budgets allow -- quantitative research to understand customer loyalty, perception, awareness and attitude towards the brand. Customers will make or break a brand by how much, or how little, they embody it.
Chances are, many companies are already doing a lot of this, but most likely in a piecemeal manner without the full participation of the C-suite. The time has come to embrace the potential of the brand and its full revenue and valuation potential. Let's make 2014 the year to realize the brand's full capabilities in elevating an organization's bottom line.


IBC is the world's leading media, entertainment and technology show, it is held in every september in beautiful Amsterdam, Netherlands.
IBC 2017 is the 50th anniversary, it was held from 15th__ 19th September in Rai Amsterdam. Nanguang stand is in Hall12, E10.
Now, let us review Nanguang exhibition in IBC 2017.
There are two sections in this exhibition, one is the professional LED studio lightings, the other section is the portable LED lightings.
The RGB lights are amazing and catches many people's eye, they beyond your imagine how portable and functional they are! They are the witness of the progress which made by Nanguang.
That is all about Nanguang in IBC2017, we hope to meet you next year in the same time!


text:
3 reasons to spend $1,000 on the Samsung Galaxy Note 20, and 3 reasons not to
By Jacob Suite 1 year ago
You might think the new $1,000 Galaxy Note 20 and $1,000 Galaxy S20 are two peas in the same pod as "affordable" counterparts to their high-priced Ultra siblings. They're not.
While the Galaxy S20 is basically a smaller version of the S20 Ultra, with the same chip, RAM, and screen tech as its pricier sibling, the Galaxy Note 20 shares very little with the Note 20 Ultra. Samsung has set the cheaper Galaxy Note 20 apart from both the Note 20 Ultra and the Galaxy S20 Ultra with a number of changes, many of which might make buyers think twice about buying one.. Here's why your thousand bucks might be better spent on the slightly older Galaxy S20—or not.
The Galaxy Note 20's processor is faster than the S20's…
For the first time since Samsung has been using Snapdragon processors in the U.S., the Galaxy Note has a faster processor than the Galaxy S. Samsung has opted to outfit the Galaxy Note 20 with the Snapdragon 865+ processor, which brings a 10-percent boost in speed and graphics. Whether that translates into a performance boost that you can feel is another story, but anyone who buys a Note 20 will have the best chip Samsung ever shipped.
The Note 20 (right) is just a little smaller than the Note 20 Ultra but it's missing a lot of features.
…But the Galaxy Note 20 has less RAM
Like the Galaxy S20, the Galaxy Note 20 Ultra is loaded with 12GB of speedy LPDDR5 RAM, but that's not the case for the Galaxy Note 20. The "cheaper" Note 20 only has 8GB of RAM, so you won't be able to keep as many apps open at one time or lock any of them to the RAM for instant loading. Granted, 8GB is plenty for a phone—and the Ultra still has 12GB of RAM—but if you're paying the same price, you'd expect the same RAM.
The Galaxy Note 20 has a new speedy S Pen stylus…
The main reason for the existence of the Note line is its onboard S Pen stylus, and Samsung has made it even better on the Galaxy Note 20. Latency has been reduced all the way down to 9ms, so writing will feel as natural as an actual pen, and it has a whole assortment of new tricks, including air gestures, PDF annotation in Notes, and enhanced handwriting recognition.
The new Notes app gives the Note 20's S Pen super writing and drawing powers.
…But you can't expand the Galaxy Note 20's storage
The Galaxy Note line is generally synonymous with power users and productivity, but the Note 20 is missing several high-end features, including an expandable memory slot. While all models of the Galaxy S20 can expand their storage up to a terabyte with a microSD card, you're stuck with 128GB of fixed storage with the Note 20.
You can wirelessly connect the Galaxy Note 20 to an external screen…
DeX has been one of the more underrated features of Samsung's premium Galaxy phones, letting you turn your phone into a mini PC with mouse and keyboard support, and bonafide desktop experience. What started as a full dock turned into a charging pad, then a cable, and now you don't need any extra equipment at all. If you have a TV or monitor with Miracast support you can beam your Galaxy Note 20 to it with just a tap.
You can beam your Note 20 to a larger screen without wires.
…But the Galaxy Note 20's screen is slower than the S20's
The Galaxy S20 was Samsung's first 120Hz phone, and we naturally assumed it would also come to the Galaxy Note 20. We were wrong. While the higher-priced Note 20 Ultra has a fast 120Hz screen, the cheaper Note 20 has the old 60Hz one. And while it's a good deal larger than the S20 (6.7 inches vs 6.2 inches), it also has a lower resolution.
The Galaxy Note 20 has a big battery…
The Galaxy Note 20 has a 6.7-inch display and 5G onboard, so it's going to need a big battery to make it through the day. Samsung has fitted the Note 20 with a 4,300mAh battery, about 10 percent bigger than the 4,000mAh battery inside the Galaxy S20. That might not seem like much, but with fewer pixels and a 60Hz screen, the Galaxy Note 20 could be one of Samsung's longest-lasting flagships in years.
Christopher Hebert/iDG
The Galaxy S20 has the exact same camera as the Note 20—and a very similar bump.
…But the exact same camera as the Galaxy S20
While Samsung has added laser autofocus and refined the Space Zoom system on the Galaxy Note 20 Ultra, the camera on the Galaxy Note 20 is identical to the one on the S20 released in March:
Camera 1: 12MP ultra-wide (120 degrees), f/2.2
Camera 2: 12MP wide, f/1.8, OIS
Camera 3: 64MP telephoto, f/2.0
Not that there's anything wrong with that. The Galaxy S20 has one of the best cameras this side of the iPhone 11 Pro, so the Galaxy Note 20 will take fantastic photos with very little effort. Still, it would have been nice to get a new feature or two.
Tags: galaxy, Note, reasons, samsung, spend
Previous 5 reasons to buy a new 27-inch iMac rather than waiting for the Apple silicon transition
Next What's wrong with Intel, and how to fix it: Former principal engineer unloads


Jonathan Harvey the author of Beautiful Thing is still amazed at people's reactions to the Film, so many years after it first came out. Although I highly recommend everyone who is gay, straight, BI or alive watch this endearing tale of two boys love.
Ste and Jamie are two teenagers growing up side by side in London on one of the roughest housing estates in the area. Ste with his abusive father and Jamie with his loud mother, Sandra who steals the show at many points struggle to accept their new found attraction to each other during a memorable summer .
Jamie's best friend, Leah who lives next believes that she is the reincarnation of Mamma Cass and the wonderful upbeat lyrics and tunes of the Mammas and the Pappas set the story perfectly.
The story is gentle yet poignant at the same time, dealing with some of the issues of self acceptance, but shying away from the issues of homophobia and fear surrounding queer people.
The film is a truly lovely and gentle love story although it has its fair share of reality with abuse and other serious and real issues dealt with. It's one of those films that I believe should be mandatory for all school to play to teenagers to dispel many of the myths about being gay and coming out.
Ste with his abusive father and Jamie with his loud mother, Sandra who steals the show at many points struggle to accept their new found attraction to each other during a memorable summer . Jamies best friend, Leah who lives next believes that she is the reincarnation of Mamma Cass and the wonderful upbeat lyrics and tunes of the Mammas and the Pappas set the story perfectly.
The story is gentle yet poignant at the same time, dealing with some of the issues of self acceptance, but shying away from the issues of homophobia and fear surrounding queer people. The film is a truly lovely and gentle love story although it has its fair share of reality with abuse and other serious and real issues dealt with. It's one of those films that I belive should be mandatory for all school to play to teenagers to dispel many of the myths about being gay and coming out.
The film is a truly lovely and gentle love story although it has its fair share of reality with abuse and other serious and real issues dealt with. It's one of those films that I belive should be mandatory for all school to play to teenagers to dispel many of the myths about being gay and coming out.


Mid-week woes have you feeling less than inspired? Time you change things up with a fresh playlist.
"Sound Literally penetrates the human body"
Think about it. Sound is a vibration that enters in through your ear and reverberates your ear drum. Feeling calmed by a hum, startled by a siren or emotionally charged by an Adele song shows how sound can directly affect the body and the mind. Sound therapy can even help stroke victims regain the ability to speak.
Ready to harness the power of sound?
Let your mind doddle in the grooves of Woodstock Past or try out some music style you've never heard of. Switching up your playlist and listening to new music stimulates the brain. The next time you're in a rut, turn something new to you. The total brain workout will get the creative juices flowing.
Every body is different. Slow down and take time to listen to your body's responses to different music. Weave music that stimulates positive responses like relaxation and happiness into your self care routine and feel the results.
Find something that really clicks for you? Enlighten us with your by leaving a comment or using #CheersAndNamaste to share your favorite "new" music.


Early every morning, that I drive my car to my job, I use the same driving routine.
Following exactly the same streets and make the turns and stops like a pre-made map.Each morning, same time, the same route, sometimes five minutes later, others earlier, but almost every day I get to meet the same people.
I drive, they walk. The same people for months. When I am late for work, it happens to be late too and so got to meet them again at our morning accidental date.I have some seconds to see what they wear, their facial expressions and sometimes I risk to think of how they might be feeling this particular morning.
At a turn of the road, I get to meet a mother and a daughter walking down the street hand in hand.The mother is about 48-50 yrs old, has long naturally red hair, freckles on her face and she is always smiling. She is wearing long printed skirts and she obviously walks her teenage daughter to school as I got to assume.
The first times we accidentally met I felt sympathy for her. I felt her agony that her kid was old enough to walk in the city streets. Imagined myself in her shoes, when my two and a half years old son, will be going to high school. I fantasised with fear the day he would walk "by himself" on the street. I kept these ideas in my head for some mornings that I was meeting them.
After some weeks of the same routine and thinking pattern in my head, one morning, my attention was thrown at the eyes of the daughter. I saw a young, serious girl, smiling but not at the same style like her mother. Her smile was wiser, with modesty and for the first time, I felt that it was the daughter that was "protecting" the mother than the opposite.
The way she was holding her hand, her look upon her eyes, the rhythm of her walking…Everything on this teenage girl was witnessing much more wisdom than I have seen in enough grown-ups.
though they are with you, yet they belong not to you.
Now, 20 years or so later I recall this poem and I feel I am the "bow". Now that I am a mother and I read again this poem my wish is to keep the essence of it in my mind. To try to never forget the wisdom-since-birth of my little boy, on my everyday effort to take care of him.
With these in mind, I wanted to paint something that would include what to call motherhood, infinity, time, space, movement, liquid elements.
Wanted to paint the mystery of a childbirth.
So although one might think this is an abstract painting, I can assure you that there is the intention in almost all the elements of this artwork. I thought of children coming into this world and a river of space and a galaxy was made in the top corner of the page. Children are the miracles of the universe.
They represent the time that passes so fast when they change to grow every morning. I painted some details with a gold hourglass to represent time. I made something like a flower but the petals are women breasts, which are a synonym for upbringing a child. An arrow is traced within the galaxy and some more under this.
There is a shape of a fish that I cannot explain why is there. I painted it spontaneously and I didn't want to paint over it for no reason. So I left it swimming among my watercolours and gold arrows.
Given the details, anyone can have a connection with the whole painting that brings all the elements together. As an abstract painting doesn't have to "mean" something specific. Can have a different meaning for each viewer and this could be the beauty of it.
If you were given the time to read the whole poem, what would be your favourite line?
I 'd love to hear in the comments area below.
forty years on, I still know that children are not ours. they are theirs. my fear for the future for danger was mine, but not his. before he came to us, my partner and I had had several adult room mates living with us and had to accommodate each other and recognize that each of us was entitled to use the space in which we lived, needed to listen to each other and give room when it was needed, pick up our share and more when one of the others was stressed, overworked, tired or sick or lonely. when our son came, we decided he was simply another room mate with more needs as first, but over time he came to live as a full partner sharing in food, space, earnings and emotional needs. today his daughter stays with us often another room mate and good friend to her great grandmother who lives with us sharing in all our lives as whole persons supporting each other.
Your approach reminds me of an advice i was given "that you should always treat your children like guests" and therefore you should not insult them or ignore their needs and opinion…The room mate idea is a step further! i ll keep it!
IDEAS	Love , Freedom and Palm trees!


Travel and Event » Walking Street Pattaya The centre of Pattaya's nightlife.
Walking Street is a part of the city of Pattaya, Thailand. It is a tourist attraction that draws foreigners and Thai nationals, primarily for the night life. It is a red-light district with many go-go bars and brothels. The street runs from the south end of Beach Road to the Bali Hai Pier. A large video sign was erected in March 2010 at the Beach Road entrance, replacing an earlier metal arch, and a small arch adorns the Bali Hai entrance.
Walking Street is probably the most famous street in Thailand. It is at the very centre of the night life scene in the city of Pattaya, and is home to some of the best bars, gogo bars and restaurants the city has to offer.
Walking Street is the most exciting streets in the world if you are looking for fun. 1000 metres of bars, gogo bars, restaurants, nightclubs and of course, the hostesses!


text:
Social Media Monitoring Software Reveals Paris Fashion Week's Biggest Moments
This year's Paris Fashion Week was very special and different from previous years. A few days before the start of the event, Chanel's iconic designer Karl Lagerfeld passed away. Many celebrities and fashion icons paid tribute to him on social media and everyone was waiting to see Lagerfeld's last collection. This year fashion week started on February 25th and ended on March 5th, with Chanel's show in the morning and Louis Vuitton in the evening. Let's find out what the biggest moments were from this year's Paris Fashion Week thanks to our social media monitoring software…
Twitter: most used social media
Our social media monitoring software uncovered that most content about Paris Fashion Week was written by females (69%) and Twitter was the preferred social media by far.
K-Pop takeover
Surprisingly, our social media monitoring software reveals that people were more excited about K-Pop singers attending fashion week than the actual shows themselves. The top shared content all related to "Sandara Park", "Jennie Kim", "Chanyeol" and "Irene". They are all K-Pop singers who attended Paris Fashion Week. Moreover, the vocabulary used in the top mentions is more related to K-Pop than to fashion. Indeed, most of the words which come up are names of K-Pop singers and hashtags related to these singers.
Social media monitoring software shows Chloe was the most talked about designer
Surprisingly, the most talked about designer was Chloe. But again, it wasn't the clothes that got people talking. The biggest driver of conversation was the presence of K-pop singer Sandara Park who attended the Chloe show.
Alongside Sandara Park, two other K-pop singers generated big reactions on social media: Jennie Kim and Chanyeol. They attended the Chanel and Tommy Hilfiger fashion shows. Our social media monitoring software uncovered over 20,000 mentions about these singers.
However, K-Pop singers were not the only center of attention, since Chanel was the second most talked about topic.
Last tribute to Karl Lagerfeld
The Chanel show was the one everyone was waiting for. People were excited and nostalgic to see Lagerfeld's last collection. The show took place in Le Grand Palais with a phenomenal setting. The venue was designed as a snow-filled village with a Swiss chalet from which models started their walk. Cara Delevingne, Lagerfeld's muse opened the show with a checked jumpsuit, one of Chanel's signature patterns. This opening generated many reactions on social media with people expressing their excitement for both the outfit and the presence of Cara Delevingne.
The show ended with a standing ovation from all of the guests while models walked down the runway. Many of them were very emotional as this marked the end of 36 years under the command of Karl Lagerfeld for Chanel. Our social media monitoring software shows that this final moment generated thousands of reactions. People took this opportunity to say farewell to the designer on Twitter.
Grace Jones' big comeback
Paris Fashion Week also saw the return of iconic model and singer Grace Jones. Designer Tommy Hilfiger teamed up with singer Zendaya to create a 70's disco-themed collection. For the occasion, they asked several iconic 70s models to wear the collection. Among them was Grace Jones who sparked many reactions on social media. Her performance stunned everyone and people were very excited to see her back on the catwalk.
This Paris Fashion Week was filled with surprises and closed the 2019 Fall/Winter season with emotion. Although we expected conversations to focus on clothing collections, our social media monitoring software proved that people tend to be more excited by celebrities attending the shows. Indeed most mentions, especially on Twitter, seem to focus on people who attend the show rather than designers' creations.
Get a full picture of the conversations that matter most to your brand. Request a free demo of our social listening platform here.
Tifène Abaab2019-03-11T09:08:25-04:0011 March 2019|
About the Author: Tifène Abaab
As a marketing intern at Synthesio, Tifène writes blog posts on relevant topics for the French and English websites. She also contributes to Synthesio's social presence across social channels by sharing marketing content. Tifène studies Communication at Loughborough University and enjoys spending time with her friends and travelling.