text:
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.

using Debug = System.Diagnostics.Debug;
using Interlocked = System.Threading.Interlocked;

namespace System.Xml.Linq
{
    /// <summary>
    /// This is a thread-safe hash table which maps string keys to values of type TValue.  It is assumed that the string key is embedded in the hashed value
    /// and can be extracted via a call to ExtractKeyDelegate (in order to save space and allow cleanup of key if value is released due to a WeakReference
    /// TValue releasing its target).
    /// </summary>
    /// <remarks>
    /// All methods on this class are thread-safe.
    ///
    /// When the hash table fills up, it is necessary to resize it and rehash all contents.  Because this can be expensive,
    /// a lock is taken, and one thread is responsible for the resize.  Other threads which need to add values must wait
    /// for the resize to be complete.
    ///
    /// Thread-Safety Notes
    /// ===================
    ///
    /// 1. Because performance and scalability are such a concern with the global name table, I have avoided the use of
    ///    BIFALOs (Big Fat Locks).  Instead, I use CompareExchange, Interlocked.Increment, memory barriers, atomic state objects,
    ///    etc. to avoid locks.  Any changes to code which accesses these variables should be carefully reviewed and tested,
    ///    as it can be *very* tricky.  In particular, if you don't understand the CLR memory model or if you don't know
    ///    what a memory barrier is, DON'T attempt to modify this code.  A good discussion of these topics can be found at
    ///    <![CDATA[http://discuss.develop.com/archives/wa.exe?A2=ind0203B&L=DOTNET&P=R375]]>.
    ///
    /// 2. Because I am not sure if the CLR spec has changed since versions 1.0/1.1, I am assuming the weak memory model that
    ///    is described in the ECMA spec, in which normal writes can be reordered.  This means I must introduce more memory
    ///    barriers than otherwise would be necessary.
    ///
    /// 3. There are several thread-safety concepts and patterns I utilize in this code:
    ///      a. Publishing -- There are a small number of places where state is exposed, or published, to multiple threads.
    ///                       These places are marked with the comment "PUBLISH", and are key locations to consider when
    ///                       reviewing the code for thread-safety.
    ///
    ///      b. Immutable objects -- Immutable objects initialize their fields once in their constructor and then never modify
    ///                              them again.  As long as care is taken to ensure that initial field values are visible to
    ///                              other threads before publishing the immutable object itself, immutable objects are
    ///                              completely thread-safe.
    ///
    ///      c. Atomic state objects -- Locks typically are taken when several pieces of state must be updated atomically.  In
    ///                                 other words, there is a window in which state is inconsistent, and that window must
    ///                                 be protected from view by locking.  However, if a new object is created each time state
    ///                                 changes (or state changes substantially), then during creation the new object is only
    ///                                 visible to a single thread.  Once construction is complete, an assignment (guaranteed
    ///                                 atomic) can replace the old state object with the new state object, thus publishing a
    ///                                 consistent view to all threads.
    ///
    ///      d. Retry -- When several threads contend over shared state which only one is allowed to possess, it is possible
    ///                  to avoid locking by repeatedly attempting to acquire the shared state.  The CompareExchange method
    ///                  is useful for atomically ensuring that only one thread succeeds, and other threads are notified that
    ///                  they must retry.
    ///
    /// 4. All variables which can be written by multiple threads are marked "SHARED STATE".
    /// </remarks>
    internal sealed class XHashtable<TValue>
    {
        private XHashtableState state;                          // SHARED STATE: Contains all XHashtable state, so it can be atomically swapped when resizes occur

        private const int StartingHash = (5381 << 16) + 5381;   // Starting hash code value for string keys to be hashed

        /// <summary>
        /// Prototype of function which is called to extract a string key value from a hashed value.
        /// Returns null if the hashed value is invalid (e.g. value has been released due to a WeakReference TValue being cleaned up).
        /// </summary>
        public delegate string ExtractKeyDelegate(TValue value);

        /// <summary>
        /// Construct a new XHashtable with the specified starting capacity.
        /// </summary>
        public XHashtable(ExtractKeyDelegate extractKey, int capacity)
        {
            state = new XHashtableState(extractKey, capacity);
        }

        /// <summary>
        /// Get an existing value from the hash table.  Return false if no such value exists.
        /// </summary>
        public bool TryGetValue(string key, int index, int count, out TValue value)
        {
            return state.TryGetValue(key, index, count, out value);
        }

        /// <summary>
        /// Add a value to the hash table, hashed based on a string key embedded in it.  Return the added value (may be a different object than "value").
        /// </summary>
        public TValue Add(TValue value)
        {
            TValue newValue;

            // Loop until value is in hash table
            while (true)
            {
                // Add new value
                // XHashtableState.TryAdd returns false if hash table is not big enough
                if (state.TryAdd(value, out newValue))
                    return newValue;

                // PUBLISH (state)
                // Hash table was not big enough, so resize it.
                // We only want one thread to perform a resize, as it is an expensive operation
                // First thread will perform resize; waiting threads will call Resize(), but should immediately
                // return since there will almost always be space in the hash table resized by the first thread.
                lock (this)
                {
                    XHashtableState newState = state.Resize();

                    // Use memory barrier to ensure that the resized XHashtableState object is fully constructed before it is assigned
#if !SILVERLIGHT
                    Thread.MemoryBarrier();
#else // SILVERLIGHT
                    // According to this document "http://my/sites/juddhall/ThreadingFeatureCrew/Shared Documents/System.Threading - FX Audit Proposal.docx"
                    // The MemoryBarrier method usage is busted (mostly - don't know about ours) and should be removed.

                    // Replacing with Interlocked.CompareExchange for now (with no effect)
                    //   which will do a very similar thing to MemoryBarrier (it's just slower)
                    System.Threading.Interlocked.CompareExchange<XHashtableState>(ref state, null, null);
#endif // SILVERLIGHT
                    state = newState;
                }
            }
        }

        /// <summary>
        /// This class contains all the hash table state.  Rather than creating a bucket object, buckets are structs
        /// packed into an array.  Buckets with the same truncated hash code are linked into lists, so that collisions
        /// can be disambiguated.
        /// </summary>
        /// <remarks>
        /// Note that the "buckets" and "entries" arrays are never themselves written by multiple threads.  Instead, the
        /// *contents* of the array are written by multiple threads.  Resizing the hash table does not modify these variables,
        /// or even modify the contents of these variables.  Instead, resizing makes an entirely new XHashtableState object
        /// in which all entries are rehashed.  This strategy allows reader threads to continue finding values in the "old"
        /// XHashtableState, while writer threads (those that need to add a new value to the table) are blocked waiting for
        /// the resize to complete.
        /// </remarks>
        private sealed class XHashtableState
        {
            private int[] buckets;                  // Buckets contain indexes into entries array (bucket values are SHARED STATE)
            private Entry[] entries;                // Entries contain linked lists of buckets (next pointers are SHARED STATE)
            private int numEntries;                 // SHARED STATE: Current number of entries (including orphaned entries)
            private ExtractKeyDelegate extractKey;  // Delegate called in order to extract string key embedded in hashed TValue

            private const int EndOfList = 0;        // End of linked list marker
            private const int FullList = -1;        // Indicates entries should not be added to end of linked list

            /// <summary>
            /// Construct a new XHashtableState object with the specified capacity.
            /// </summary>
            public XHashtableState(ExtractKeyDelegate extractKey, int capacity)
            {
                Debug.Assert((capacity & (capacity - 1)) == 0, "capacity must be a power of 2");
                Debug.Assert(extractKey != null, "extractKey may not be null");

                // Initialize hash table data structures, with specified maximum capacity
                buckets = new int[capacity];
                entries = new Entry[capacity];

                // Save delegate
                this.extractKey = extractKey;
            }

            /// <summary>
            /// If this table is not full, then just return "this".  Otherwise, create and return a new table with
            /// additional capacity, and rehash all values in the table.
            /// </summary>
            public XHashtableState Resize()
            {
                // No need to resize if there are open entries
                if (numEntries < buckets.Length)
                    return this;

                int newSize = 0;

                // Determine capacity of resized hash table by first counting number of valid, non-orphaned entries
                // As this count proceeds, close all linked lists so that no additional entries can be added to them
                for (int bucketIdx = 0; bucketIdx < buckets.Length; bucketIdx++)
                {
                    int entryIdx = buckets[bucketIdx];

                    if (entryIdx == EndOfList)
                    {
                        // Replace EndOfList with FullList, so that any threads still attempting to add will be forced to resize
                        entryIdx = Interlocked.CompareExchange(ref buckets[bucketIdx], FullList, EndOfList);
                    }

                    // Loop until we've guaranteed that the list has been counted and closed to further adds
                    while (entryIdx > EndOfList)
                    {
                        // Count each valid entry
                        if (extractKey(entries[entryIdx].Value) != null)
                            newSize++;

                        if (entries[entryIdx].Next == EndOfList)
                        {
                            // Replace EndOfList with FullList, so that any threads still attempting to add will be forced to resize
                            entryIdx = Interlocked.CompareExchange(ref entries[entryIdx].Next, FullList, EndOfList);
                        }
                        else
                        {
                            // Move to next entry in the list
                            entryIdx = entries[entryIdx].Next;
                        }
                    }
                    Debug.Assert(entryIdx == EndOfList, "Resize() should only be called by one thread");
                }

                // Double number of valid entries; if result is less than current capacity, then use current capacity
                if (newSize < buckets.Length / 2)
                {
                    newSize = buckets.Length;
                }
                else
                {
                    newSize = buckets.Length * 2;

                    if (newSize < 0)
                        throw new OverflowException();
                }

                // Create new hash table with additional capacity
                XHashtableState newHashtable = new XHashtableState(extractKey, newSize);

                // Rehash names (TryAdd will always succeed, since we won't fill the new table)
                // Do not simply walk over entries and add them to table, as that would add orphaned
                // entries.  Instead, walk the linked lists and add each name.
                for (int bucketIdx = 0; bucketIdx < buckets.Length; bucketIdx++)
                {
                    int entryIdx = buckets[bucketIdx];
                    TValue newValue;

                    while (entryIdx > EndOfList)
                    {
                        newHashtable.TryAdd(entries[entryIdx].Value, out newValue);

                        entryIdx = entries[entryIdx].Next;
                    }
                    Debug.Assert(entryIdx == FullList, "Linked list should have been closed when it was counted");
                }

                return newHashtable;
            }

            /// <summary>
            /// Attempt to find "key" in the table.  If the key exists, return the associated value in "value" and
            /// return true.  Otherwise return false.
            /// </summary>
            public bool TryGetValue(string key, int index, int count, out TValue value)
            {
                int hashCode = ComputeHashCode(key, index, count);
                int entryIndex = 0;

                // If a matching entry is found, return its value
                if (FindEntry(hashCode, key, index, count, ref entryIndex))
                {
                    value = entries[entryIndex].Value;
                    return true;
                }

                // No matching entry found, so return false
                value = default(TValue);
                return false;
            }

            /// <summary>
            /// Attempt to add "value" to the table, hashed by an embedded string key.  If a value having the same key already exists,
            /// then return the existing value in "newValue".  Otherwise, return the newly added value in "newValue".
            ///
            /// If the hash table is full, return false.  Otherwise, return true.
            /// </summary>
            public bool TryAdd(TValue value, out TValue newValue)
            {
                int newEntry, entryIndex;
                string key;
                int hashCode;

                // Assume "value" will be added and returned as "newValue"
                newValue = value;

                // Extract the key from the value.  If it's null, then value is invalid and does not need to be added to table.
                key = extractKey(value);
                if (key == null)
                    return true;

                // Compute hash code over entire length of key
                hashCode = ComputeHashCode(key, 0, key.Length);

                // Assume value is not yet in the hash table, and prepare to add it (if table is full, return false).
                // Use the entry index returned from Increment, which will never be zero, as zero conflicts with EndOfList.
                // Although this means that the first entry will never be used, it avoids the need to initialize all
                // starting buckets to the EndOfList value.
                newEntry = Interlocked.Increment(ref numEntries);
                if (newEntry < 0 || newEntry >= buckets.Length)
                    return false;

                entries[newEntry].Value = value;
                entries[newEntry].HashCode = hashCode;

                // Ensure that all writes to the entry can't be reordered past this barrier (or other threads might see new entry
                // in list before entry has been initialized!).
#if !SILVERLIGHT
                Thread.MemoryBarrier();
#else // SILVERLIGHT
                // According to this document "http://my/sites/juddhall/ThreadingFeatureCrew/Shared Documents/System.Threading - FX Audit Proposal.docx"
                // The MemoryBarrier method usage is busted (mostly - don't know about ours) and should be removed.

                // Replacing with Interlocked.CompareExchange for now (with no effect)
                //   which will do a very similar thing to MemoryBarrier (it's just slower)
                System.Threading.Interlocked.CompareExchange<Entry[]>(ref entries, null, null);
#endif // SILVERLIGHT

                // Loop until a matching entry is found, a new entry is added, or linked list is found to be full
                entryIndex = 0;
                while (!FindEntry(hashCode, key, 0, key.Length, ref entryIndex))
                {
                    // PUBLISH (buckets slot)
                    // No matching entry found, so add the new entry to the end of the list ("entryIndex" is index of last entry)
                    if (entryIndex == 0)
                        entryIndex = Interlocked.CompareExchange(ref buckets[hashCode & (buckets.Length - 1)], newEntry, EndOfList);
                    else
                        entryIndex = Interlocked.CompareExchange(ref entries[entryIndex].Next, newEntry, EndOfList);

                    // Return true only if the CompareExchange succeeded (happens when replaced value is EndOfList).
                    // Return false if the linked list turned out to be full because another thread is currently resizing
                    // the hash table.  In this case, entries[newEntry] is orphaned (not part of any linked list) and the
                    // Add needs to be performed on the new hash table.  Otherwise, keep looping, looking for new end of list.
                    if (entryIndex <= EndOfList)
                        return entryIndex == EndOfList;
                }

                // Another thread already added the value while this thread was trying to add, so return that instance instead.
                // Note that entries[newEntry] will be orphaned (not part of any linked list) in this case
                newValue = entries[entryIndex].Value;

                return true;
            }

            /// <summary>
            /// Searches a linked list of entries, beginning at "entryIndex".  If "entryIndex" is 0, then search starts at a hash bucket instead.
            /// Each entry in the list is matched against the (hashCode, key, index, count) key.  If a matching entry is found, then its
            /// entry index is returned in "entryIndex" and true is returned.  If no matching entry is found, then the index of the last entry
            /// in the list (or 0 if list is empty) is returned in "entryIndex" and false is returned.
            /// </summary>
            /// <remarks>
            /// This method has the side effect of removing invalid entries from the list as it is traversed.
            /// </remarks>
            private bool FindEntry(int hashCode, string key, int index, int count, ref int entryIndex)
            {
                int previousIndex = entryIndex;
                int currentIndex;

                // Set initial value of currentIndex to index of the next entry following entryIndex
                if (previousIndex == 0)
                    currentIndex = buckets[hashCode & (buckets.Length - 1)];
                else
                    currentIndex = previousIndex;

                // Loop while not at end of list
                while (currentIndex > EndOfList)
                {
                    // Check for matching hash code, then matching key
                    if (entries[currentIndex].HashCode == hashCode)
                    {
                        string keyCompare = extractKey(entries[currentIndex].Value);

                        // If the key is invalid, then attempt to remove the current entry from the linked list.
                        // This is thread-safe in the case where the Next field points to another entry, since once a Next field points
                        // to another entry, it will never be modified to be EndOfList or FullList.
                        if (keyCompare == null)
                        {
                            if (entries[currentIndex].Next > EndOfList)
                            {
                                // PUBLISH (buckets slot or entries slot)
                                // Entry is invalid, so modify previous entry to point to its next entry
                                entries[currentIndex].Value = default(TValue);
                                currentIndex = entries[currentIndex].Next;

                                if (previousIndex == 0)
                                    buckets[hashCode & (buckets.Length - 1)] = currentIndex;
                                else
                                    entries[previousIndex].Next = currentIndex;

                                continue;
                            }
                        }
                        else
                        {
                            // Valid key, so compare keys
                            if (count == keyCompare.Length && string.CompareOrdinal(key, index, keyCompare, 0, count) == 0)
                            {
                                // Found match, so return true and matching entry in list
                                entryIndex = currentIndex;
                                return true;
                            }
                        }
                    }

                    // Move to next entry
                    previousIndex = currentIndex;
                    currentIndex = entries[currentIndex].Next;
                }

                // Return false and last entry in list
                entryIndex = previousIndex;
                return false;
            }

            /// <summary>
            /// Compute hash code for a string key (index, count substring of "key").  The algorithm used is the same on used in NameTable.cs in System.Xml.
            /// </summary>
            private static int ComputeHashCode(string key, int index, int count)
            {
                int hashCode = StartingHash;
                int end = index + count;
                Debug.Assert(key != null, "key should have been checked previously for null");

                // Hash the key
                for (int i = index; i < end; i++)
                    hashCode += (hashCode << 7) ^ key[i];

                // Mix up hash code a bit more and clear the sign bit.  This code was taken from NameTable.cs in System.Xml.
                hashCode -= hashCode >> 17;
                hashCode -= hashCode >> 11;
                hashCode -= hashCode >> 5;
                return hashCode & 0x7FFFFFFF;
            }

            /// <summary>
            /// Hash table entry.  The "Value" and "HashCode" fields are filled during initialization, and are never changed.  The "Next"
            /// field is updated when a new entry is chained to this one, and therefore care must be taken to ensure that updates to
            /// this field are thread-safe.
            /// </summary>
            private struct Entry
            {
                public TValue Value;    // Hashed value
                public int HashCode;    // Hash code of string key (equal to extractKey(Value).GetHashCode())
                public int Next;        // SHARED STATE: Points to next entry in linked list
            }
        }
    }
}


text:
<!DOCTYPE html>

    <meta charset="utf-8">

    <title>LA MULTIPREMIADA PELÍCULA MEXICANA "GÜEROS" SE ESTRENA EN MÉXICO | La Red Semanario</title>
    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">

        <meta name="keywords" content="" />

    <meta name="description" content="LA MULTIPREMIADA PELÍCULA MEXICANA "GÜEROS" SE ESTRENA EN MÉXICO
[caption id="attachment_794" align="alignleft" width="184"] La película Güeros[/caption]
Columba Vértiz de la Fuente/aproMÉXICO, D. F.">
<meta property="og:type" content="article">
<meta property="og:title" content="LA MULTIPREMIADA PELÍCULA MEXICANA "GÜEROS" SE ESTRENA EN MÉXICO">
<meta property="og:url" content="https://laredsemanario.com/2015/05/la-multipremiada-pelicula-mexicana-gueros-se-estrena-en-mexico/index.html">
<meta property="og:site_name" content="La Red Semanario">
<meta property="og:description" content="LA MULTIPREMIADA PELÍCULA MEXICANA "GÜEROS" SE ESTRENA EN MÉXICO
[caption id="attachment_794" align="alignleft" width="184"] La película Güeros[/caption]
Columba Vértiz de la Fuente/aproMÉXICO, D. F.">
<meta property="og:image" content="http://www.laredsemanario.com/wp-content/uploads/2015/04/entretenimiento_espectaculos_500x100.png">
<meta property="og:updated_time" content="2016-04-08T19:12:41.240Z">
<meta name="twitter:card" content="summary">
<meta name="twitter:title" content="LA MULTIPREMIADA PELÍCULA MEXICANA "GÜEROS" SE ESTRENA EN MÉXICO">
<meta name="twitter:description" content="LA MULTIPREMIADA PELÍCULA MEXICANA "GÜEROS" SE ESTRENA EN MÉXICO
[caption id="attachment_794" align="alignleft" width="184"] La película Güeros[/caption]
Columba Vértiz de la Fuente/aproMÉXICO, D. F.">
<meta name="twitter:image" content="http://www.laredsemanario.com/wp-content/uploads/2015/04/entretenimiento_espectaculos_500x100.png">
<meta name="twitter:creator" content="@3171117842">
<meta property="fb:app_id" content="956176474392711">

        <link rel="icon" href="/favicon.ico" />

    <link rel="stylesheet" href="/vendor/font-awesome/css/font-awesome.min.css">
    <link rel="stylesheet" href="/vendor/titillium-web/styles.css">
    <link rel="stylesheet" href="/vendor/source-code-pro/styles.css">

    <link rel="stylesheet" href="/css/style.css">

        <link rel="stylesheet" href="/vendor/fancybox/jquery.fancybox.css">

        <link rel="stylesheet" href="/vendor/scrollLoading/style.css">

                                    Inicio

    <form class="search-form">
        <input type="text" class="ins-search-input search-form-input" placeholder="Buscar" />
        <button type="submit" class="search-form-submit"></button>
    </form>

            <input type="text" class="ins-search-input" placeholder="Escribe algo..." />

    Entretenimiento y Espectáculos

        LA MULTIPREMIADA PELÍCULA MEXICANA "GÜEROS" SE ESTRENA EN MÉXICO

    <time datetime="2015-05-01T22:22:55.000Z" itemprop="datePublished">2015-05-01</time>

LA MULTIPREMIADA PELÍCULA MEXICANA "GÜEROS" SE ESTRENA EN MÉXICO

[caption id="attachment_794" align="alignleft" width="184"] La película Güeros[/caption]

Columba Vértiz de la Fuente/apro
MÉXICO, D. F. 19 de marzo (apro).- Por fin, después de casi un año de espera este viernes se exhibirá en el DF y distintas salas del país la cinta Güeros, el largometraje mexicano más premiado del año pasado en festivales nacionales e internacionales. La cantante Natalia Lafourcade interpreta el tema principal de la historia, Azul, del compositor Agustín Lara. Güeros, producida por Postal Producciones y con el apoyo del Foprocine, está filmada en blanco y negro. Se trata de un road movie por la Ciudad de México, en donde un grupo de jóvenes tendrá que vivir diferentes situaciones y así afrontar su proceso de maduración. El largometraje lo protagonizan Tenoch Huerta, Sebastián Aguirre, Leonardo Ortizgris, Ilse Salas, Raúl Briones y Laura Almela.

Ruizpalacios dice en entrevista que el filme es una suma de muchas inquietudes: "Sobre el proceso de maduración de unos jóvenes a la vida adulta. También, representa un canto a la amistad, porque la hicimos entre amigos, ya que un rodaje implica estar en condiciones muy adversas, por eso es bueno estar al lado de gente en la que confías. "Además, era muy importante y congruente hacerla con amigos, porque justamente estábamos contando la historia de unos jóvenes que viajan por la ciudad y buscamos que se transmitieran ese mismo amor con el que la hicimos".

La cinta se ubica en el contexto de la huelga de la UNAM: "Cada uno habla de lo que nos tocó vivir. Es una huelga que marcó a mi generación, yo estaba por entrar a la Universidad Nacional cuando estalló la huelga, al final me fui a estudiar a otro país, algunos se fueron a otras escuelas, otros se sumaron al movimiento. Y este tema me pareció una buena metáfora para hablar sobre el proceso de maduración que quería explorar".

Ramiro Ruiz, productor de la cinta, aclara que aunque Güeros obtuvo varios reconocimientos, "no significa que representen una buena taquilla a la hora de estrenarse comercialmente". A Tenoch Huerta le emociona "que la gente la esté recibiendo muy bien, no esperaba que conmoviera a tanta gente."

20 ANIVERSARIO LUCTUOSO DEL "MEJOR CÓMICO DEL MUNDO" CANTINFLAS

[caption id="attachment_793" align="alignleft" width="271"] Cantinflas[/caption]

El pasado martes se llevó a cabo en la Basilica de Guadalupe una misa con motivo del 22 aniversario luctuoso de Fortino Mario Alfonso Moreno Reyes, mejor conocido como "Cantinflas", quien fuera considerado por Charles Chaplin como el "Mejor cómico del mundo", alago que sin duda sirvió para animarlo a filmar "La vuelta al mundo en 80 días", película que lo hizo merecedor a ganar un Globo de Oro y un Oscar a "mejor película".

El personaje que le llevo a la fama "Cantinflas", que fue inspirado en un barrendero "borrachito" que conoció cuando trabajaba en el Teatro Follies, personaje multifacético que lo mismo daba vida a un boxeador, taxista y lustrador de calzado que a un bailarín y hasta a algún abogado. Sus tres primeros filmes "No te engañes corazón" (1936), a la cual le siguió el gran éxito "Ahí está el detalle" (1940) y "El gendarme desconocido" (1941); su último trabajo "El barrendero" (1981), una de sus obras maestras.

A lo largo de los años se le han rendido diversos homenajes por su destacada trayectoria; libro, muestras fotográficas, ciclos de cine, carteles con la figura del personaje por distintas partes del mundo son sólo algunos de ellos, sin embargo también existe el homenaje hecho por la Organización de Estados Americanos (OEA) que lo nombró "Embajador de la Paz", en reconocimiento a su "brillante labor de acercamiento entre los pueblos del mundo", creador de todo un género, "Cantinflas" y todos sus derivados como cantinflada, cantinflear y cantinflesco, forman parte del diccionario de la Real Academia de la Lengua Española, como un verbalismo vacío, incongruente, disparatado y que mezcla muletillas. Este año el homenaje consiste en la develación de una escultura realizada por Víctor Gutiérrez y una marca de ropa diseñada por Héctor Terrones.

El mejor homenaje que se le ha hecho es la película "Cantinflas", protagonizada por el actor español Óscar Jaenada, bajo la dirección de Sebastián del Amo, rodaje que plasma la vida del actor desde sus inicios como cómico hasta que alcanzó la fama, la cinta te lleva de la risa a las lágrimas en un instante, el éxito consiste en la actuación de Oscar Jaenada, se necesitaba como se dijo en su momento un actor que interpretara tanto a Cantinflas como a Mario Moreno y no a un imitador.

              La Red Semanario

    Compartir

        Please enable JavaScript to view the comments powered by Disqus.

seguir:

        más nuevo

            Descubre... Ixtapan del Oro

        antiguo

¿EXISTIÓ EL ÁGUILA DEVORANDO LA SERPIENTE?

recientes

Nacional

Detienen a Leopoldo Duarte, acusado de abuso sexual en el Colegio Matatena

<time datetime="2016-05-11T14:29:50.000Z" itemprop="datePublished">2016-05-11</time>

Ciencia

Telescopio espacial Kepler descubre 1284 nuevos planetas fuera del sistema solar

<time datetime="2016-05-11T14:24:56.000Z" itemprop="datePublished">2016-05-11</time>

Deportes

Billy Álvarez dejaría Cruz Azul

<time datetime="2016-05-11T14:14:24.000Z" itemprop="datePublished">2016-05-11</time>

Politica

Por ser desproporcionadas, El Bronco cancelará 10 mil becas estudiantiles

<time datetime="2016-05-11T14:08:06.000Z" itemprop="datePublished">2016-05-11</time>

Cultura

Los 11 mandamientos de la Iglesia de Satán son mucho más sensatos de lo que imaginarías

<time datetime="2016-05-10T14:05:56.000Z" itemprop="datePublished">2016-05-10</time>

© 2014 - 2016 La Red Semanario

redpajama_set_name: RedPajamaGithub


text:
<!doctype html>

    <title>The Secret Indian society!</title>

    <meta charset="utf-8" />
    <meta http-equiv="Content-type" content="text/html; charset=utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />

'

 THE SECRET  by Rhonda Byrne

    <form action="http://thesecret.tv/">
       <input type="submit" value="Go to main website" />
    </form>

Enter your story below and submit

    <form>
       <input type="text" placeholder="start typing here" />
    </form>

    <form action="http://thesecret.tv/living.html">
       <input type="submit" value="Read more stories" />
    </form>

 Watch full movie below


text:
This is a demo of some things you can do with webRTC.
======================================================

### What it does

*   First, it uses [angularfilre](http://angularfire.com/) to connect
    to a real-time [firebase](https://www.firebase.com/) database to get a
    list of users on this page
*   Then, it uses a service called [PeerJS](http://peerjs.com) to simplify
    and abstract away some of the details of creating an RTCPeerConnection
    to ever other person viewing this page
*   Then, using that RTCPeerConnection it establishes a RTCDataChannel w/
    each peer, enabling communication of arbitrary data
    (in this case chat messages and file uploads)
*   Then, using [navigator.getUserMedia](https://developer.mozilla.org/en-US/docs/Web/API/Navigator.getUserMedia)
    it asks you to capture your webcam and it also establishes a p2p
    video connection with every other person viewing this page
*   It uses that video connection as the "live" avatar next
    to your name in your chat messages
*   When you send a chat message or upload files, it sends it
    _directly_ to each peer connected.  no messages, files, or video ever go
    through a server

**TL,DR:**
video/text chat & p2p file sharing using **no servers**
(except to get a list of who's online) and **no plugins (no flash)**

**[Read the Source](https://github.com/ryankshaw/webRTC-demo/blob/master/js/demo.coffee) on github.**
If you have any questions email me at my github username at gmail.


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Sandbox_EF6_Test
{
   class Program
   {
      static void Main(string[] args)
      {
         Console.WriteLine("The players -");
         Console.WriteLine("===================================");
         Console.WriteLine("public partial class Entity1");
         Console.WriteLine("{");
         Console.WriteLine("   public Entity1()");
         Console.WriteLine("   {");
         Console.WriteLine("      Entity2 = new HashSet<Entity2>();");
         Console.WriteLine("   }");
         Console.WriteLine("");
         Console.WriteLine("   public int Id { get; protected set; }");
         Console.WriteLine("   public virtual ICollection<Entity2> Entity2 { get; protected set; }");
         Console.WriteLine("}");
         Console.WriteLine("");
         Console.WriteLine("public partial class Entity2");
         Console.WriteLine("{");
         Console.WriteLine("   public Entity2()");
         Console.WriteLine("   {");
         Console.WriteLine("   }");
         Console.WriteLine("");
         Console.WriteLine("   public int Id { get; protected set; }");
         Console.WriteLine("   public int? FK { get; set; }");
         Console.WriteLine("   public virtual Entity1 { get; set; }");
         Console.WriteLine("}");
         Console.WriteLine("");

         using (Context context = new Context())
         {
            Entity1 e1a = context.Entity1.Add(new Entity1());
            Entity1 e1b = context.Entity1.Add(new Entity1());
            Entity1 e1c = context.Entity1.Add(new Entity1());
            Entity2 e2 = context.Entity2.Add(new Entity2());
            context.SaveChanges();

            int e1aId = e1a.Id;
            int e1bId = e1b.Id;
            int e1cId = e1c.Id;
            int e2Id = e2.Id;

            Console.WriteLine("Initial values:");
            Console.WriteLine("===================================");
            Console.WriteLine($"   e1a.Id = {e1aId}");
            Console.WriteLine($"   e1b.Id = {e1bId}");
            Console.WriteLine($"   e1c.Id = {e1cId}");
            Console.WriteLine($"   e2.Id  = {e2Id}");
            Console.WriteLine();

            Console.WriteLine("===================================");
            Console.WriteLine("Set the navigation property, but not the foreign key");
            Console.WriteLine("===================================");
            Console.WriteLine();

            Console.WriteLine("e2.Entity1 = e1a;");
            e2.Entity1 = e1a;
            Console.WriteLine($"   e2.Entity1.Id = {e2.Entity1.Id}");
            Console.WriteLine($"   e2.FK = {e2.FK}");
            Console.WriteLine();

            Console.WriteLine("SaveChanges");
            context.SaveChanges();
            Console.WriteLine($"   e2.Entity1.Id = {e2.Entity1.Id}");
            Console.WriteLine($"   e2.FK = {e2.FK}");
            Console.WriteLine();

            Console.WriteLine("===================================");
            Console.WriteLine("Set the foreign key, but not the navigation property");
            Console.WriteLine("===================================");
            Console.WriteLine($"e2.FK = {e1bId};");
            e2.FK = e1bId;
            Console.WriteLine($"   e2.Entity1.Id = {e2.Entity1.Id}");
            Console.WriteLine($"   e2.FK = {e2.FK}");
            Console.WriteLine();

            Console.WriteLine("SaveChanges");
            context.SaveChanges();
            Console.WriteLine($"   e2.Entity1.Id = {e2.Entity1.Id}");
            Console.WriteLine($"   e2.FK = {e2.FK}");
            Console.WriteLine();

            Console.WriteLine("===================================");
            Console.WriteLine("Set the foreign key to the same value and the navigation property to a different value");
            Console.WriteLine("===================================");
            Console.WriteLine($"e2.Entity1 = e1c;");
            Console.WriteLine($"e2.FK = {e1bId};");
            e2.Entity1 = e1c;
            e2.FK = e1bId;
            Console.WriteLine($"   e2.Entity1.Id = {e2.Entity1.Id}");
            Console.WriteLine($"   e2.FK = {e2.FK}");
            Console.WriteLine();

            Console.WriteLine("SaveChanges");
            context.SaveChanges();
            Console.WriteLine($"   e2.Entity1.Id = {e2.Entity1.Id}");
            Console.WriteLine($"   e2.FK = {e2.FK}");
            Console.WriteLine();

            Console.WriteLine("===================================");
            Console.WriteLine("Set the foreign key and the navigation property to different values");
            Console.WriteLine("===================================");
            Console.WriteLine($"e2.Entity1 = e1a;");
            Console.WriteLine($"e2.FK = {e1bId};");
            e2.Entity1 = e1a;
            e2.FK = e1bId;
            Console.WriteLine($"   e2.Entity1.Id = {e2.Entity1.Id}");
            Console.WriteLine($"   e2.FK = {e2.FK}");
            Console.WriteLine();

            try
            {
               Console.WriteLine("SaveChanges");
               context.SaveChanges();
               Console.WriteLine($"   e2.Entity1.Id = {e2.Entity1.Id}");
               Console.WriteLine($"   e2.FK = {e2.FK}");
            }
            catch (Exception e)
            {
               Console.WriteLine($"   {e.GetType().Name}: {e.Message}");
            }

            Console.WriteLine();
            Console.WriteLine("Hit return to continue");
            Console.ReadLine();
         }
      }
   }
}


text:
"use strict";
module.exports = exitMessage;

/**
 * Exits the program with a simple message
 */
function exitMessage(message, opts) {
	console.error(message);
	process.exit(typeof opts.statusCode === 'number' ? opts.statusCode : 1);
}