Migrate blogs

content/blogs/2017-01-08-hemos-tenido-un-sueno/es.mdx

@@ -0,0 +1,38 @@
+---
+layout: post
+current: post
+cover: assets/images/posts/2017-01-08-hemos-tenido-un-sueno/header.jpg
+navigation: True
+title: "Hemos tenido un sueño"
+date: 2017-01-08 12:00:00
+tags: nocountryforgeeks
+class: post-template
+subclass: 'post'
+author: aclopez
+---
+
+
+"La mejor forma de predecir el futuro es implementarlo" [Alan Kay](https://hipertextual.com/2011/10/historia-de-la-tecnologia-alan-kay-padre-legitimo-de-la-computacion-personal)
+
+Hemos tenido un sueño. Hemos tenido un sueño en el cual teníamos todo el tiempo para poder aprender todos los lenguajes. Un sueño en el que quedan atrás todos los prejuicios, en donde la gente siempre mira hacia delante. Un sueño en el cual no existen _Global.asax_ ni _WebConfig_, un sueño donde _Webpack_ genera todos los ```js``` ordenados, un sueño donde la programación funcional va entrando en nuestro código. Un sueño donde había equipo y no gente trabajando junta. Un sueño donde el pair programming surge de forma espontánea. Un sueño donde las _Pull Request_ llegaban a más de 4.000, llenas de comentarios positivos. Un sueño donde nadie piensa eso de _"Aquí se viene con to aprendío"_, donde se valoran las cosas bien hechas, no las cosas funcionales. Un sueño donde el programador busca esa excelencia en su código de manera natural. Un sueño donde escribir código es un arte.
+
+Y así es como nace __No Country For Geeks__. Tenemos un sueño y queremos compartirlo. Queremos programar con _C#_, con _Node_, ver el mundo de las APIs con la perspectiva de _GraphQL_, adentrarnos en _React_ y _Webpack_, _Clojure.js_, que nuestros bots hablen como personas, descubrir _Cognitives Services_ con _LUIS_, _Watson_, y lo más importante, compartir el mundo que vamos aprendiendo. Porque nosotros somos esos __eternos aprendices__ que están detrás de la pantalla de ordenador picando código, desaprendiendo y aprendiendo constantemente del mundo de los bits, la programación y el trabajo en equipo.
+
+![Padawan](/assets/images/posts/2017-01-08-hemos-tenido-un-sueno/starwars.jpg)
+
+Nuestra única aspiración al compartir nuestro código es que en el mundo haya algunos programadores más que puedan decir:
+
+> Soy un programador a pesar de tener que volver a ser un aprendiz cada día.
+
+Y estaríamos aún más satisfechos si algunos de ellos fueran más lejos y dijeran:
+
+> Soy un programador y me encanta tener que volver a ser un aprendiz cada día.
+
+Para ello podéis seguirnos en este blog y nuestras redes sociales:
+
+* Blog: [http://www.nocountryforgeeks.com/](http://www.nocountryforgeeks.com/)
+* Twitter: [https://twitter.com/nocountry4geeks](https://twitter.com/nocountry4geeks)
+* Instagram: [https://www.instagram.com/nocountryforgeeks](https://www.instagram.com/nocountryforgeeks/)
+* Facebook: [https://www.facebook.com/463217730714163/](https://www.facebook.com/463217730714163/)
+
+> ¡Bienvenidos!

content/blogs/2017-08-10-first-vs-single/es.mdx

@@ -0,0 +1,129 @@
+---
+layout: post
+current: post
+cover: assets/images/posts/2017-08-10-first-vs-single/header.jpg
+navigation: True
+title: "First vs Single"
+date: 2017-08-10 12:00:00
+tags: csharp
+class: post-template
+subclass: 'post'
+author: maktub82
+---
+
+¡Hola a todos! Linq se ha convertido en nuestro mejor amigo cuando trabajamos con colecciones de datos. Pese a la comodidad que nos ofrece, Linq no es solo azúcar sintáctico: es mucho más, pero ¿siempre usamos Linq correctamente?
+
+Hoy vamos a comparar `Single` y `First` para ver las diferencias y si los usamos correctamente.
+
+**Nota:** Para hacer la comparativa vamos a utilizar tanto en el método `Single` como en el `First` la sobrecarga que recibe un predicado con una condición para buscar el elemento.
+
+## Principales diferencias
+
+La principal diferencia es que **`Single` lanzará una excepción si existe más de un ítem en la colección que cumpla la condición del predicado**.
+
+Esto ya nos está indicando que **`Single`, por norma general, realizará más iteraciones sobre la colección** porque no le basta con encontrar un ítem que cumpla el predicado, sino que tiene que seguir hasta encontrar otro ítem que cumpla la condición, para lanzar la excepción, o hasta llegar al final de la colección.
+
+**`First` únicamente devuelve el primer ítem que encuentre que cumple con el predicado.** En ese momento dejará de iterar sobre los elementos de la colección.
+
+Por suerte Linq es Open Source y lo tenemos disponible en [GitHub]( https://github.com/dotnet/corefx/tree/master/src/System.Linq/src/System/Linq) para poder ver las *entrañas* y comprender mejor cómo funciona. Vamos a ver la implementación de estos dos métodos.
+
+## First
+
+He extraído parte del código de la familia de métodos de extensión de [`First`]( https://github.com/dotnet/corefx/blob/master/src/System.Linq/src/System/Linq/First.cs) de GitHub para poder analizarlo mejor.
+
+
+```cs
+foreach (TSource element in source)
+{
+    if (predicate(element))
+    {
+        found = true;
+        return element;
+    }
+}
+```
+
+La parte del `First` que se encarga de encontrar el primer ítem que cumpla con el predicado no es más que un `foreach` que evalúa el predicado y en caso de cumplirse devuelve el ítem.
+
+Por tanto, en cuando haya encontrado el ítem dejará de iterar sobre la colección y devolverá el resultado. Por otro lado, si no encuentra el ítem lanzará una excepción en el caso de `First` o `default(T)` en el caso de `FirstOrDefault`.
+
+## Single
+
+El código de [`Single`](https://github.com/dotnet/corefx/blob/master/src/System.Linq/src/System/Linq/Single.cs) es un poco más complejo. Para empezar, trabajamos con el `Enumerator` que nos va a permitir navegar por la colección.
+
+```cs
+using (IEnumerator<TSource> e = source.GetEnumerator())
+{
+    while (e.MoveNext())
+    {
+        TSource result = e.Current;
+        if (predicate(result))
+        {
+            while (e.MoveNext())
+            {
+                if (predicate(e.Current))
+                {
+                    throw Error.MoreThanOneMatch();
+                }
+            }
+
+            return result;
+        }
+    }
+}
+```
+
+**Nota:** El método `e.MoveNext()` avanzará en la colección y devolverá `true` en caso de que haya podido realizarse y `false` en caso contrario, es decir, no quedan ítems en la colección.
+
+Por tanto, lo que tenemos es un *mientras queden ítems en la colección* que evalúa el predicado a ver si se cumple. En el caso de que se cumpla entramos en otro *mientras queden ítems en la colección* que de nuevo evalúa el predicado. En este caso si se cumple lanzamos una excepción, ya que hemos encontrado más de un ítem.
+
+En caso de no haber encontrado otro elemento que cumpla el predicado devolvemos el que ya habíamos encontrado.
+
+## ¿Cuál utilizar?
+
+Como hemos podido comprobar `First`, por normal general, ejecuta menos iteraciones sobre la colección.
+
+En un caso habitual en el que el predicado sólo lo cumpla un ítem, `First` recorrerá la colección hasta que lo encuentre, mientras que `Single` recorrerá toda la colección para asegurar que solo un ítem cumple el predicado.
+
+Es evidente que **si no tenemos necesidad de comprobar que el predicado solo lo cumple un elemento la mejor opción es utilizar `First`** que va a iterar sobre la lista sólo hasta que encuentre el ítem.
+
+## Bonus Track: Find
+
+Existe otro método, disponible para las listas, llamado `Find` que también acepta un predicado. Podemos consultar el [código de `List`]( https://github.com/dotnet/coreclr/blob/master/src/mscorlib/src/System/Collections/Generic/List.cs) en Github.
+
+```cs
+public T Find(Predicate<T> match)
+
+...
+
+for (int i = 0; i < _size; i++)
+{
+    if (match(_items[i]))
+    {
+        return _items[i];
+    }
+}
+return default(T);
+```
+
+Como vemos, **`Find` utiliza un `for` para recorrer la colección, a diferencia de `First` que utilizaba un `foreach`**. Por tanto, podemos concluir que **`Find` es más rápido recorriendo los ítems**, pero no podemos utilizarlo en todo tipo de colecciones.
+
+**Nota:** Además, si `Find` no encuentra ningún ítem que cumpla con el predicado, devolverá `default(T)`, teniendo el mismo comportamiento que `FirstOrDefault`.
+
+## Conclusiones
+
+Hemos comprobado que es mejor utilizar `First` que `Single` salvo que queramos asegurarnos que no existen más ítems que cumplen el predicado. Además, lo hemos comprobado leyendo el código de Linq.
+
+Es interesante tener disponible el código de Linq porque nos ayuda a comprender mejor los diferentes métodos de extensión que nos ofrece para trabajar con las colecciones.
+
+Escribí este post para investigar y sopesar si era verdad que no estaba utilizando `Single` en ocasiones que tendría que haberlo utilizado y creo que la respuesta es sí. En algunos desarrollos tendría que haberlo añadido y, si es el caso, controlar la excepción que lanza para ver cómo actuar al respecto.
+
+## Referencias
+
+* [Código]( https://github.com/dotnet/corefx/tree/master/src/System.Linq/src/System/Linq) de Linq.
+
+* [Código]( https://github.com/dotnet/coreclr/blob/master/src/mscorlib/src/System/Collections/Generic/List.cs) de List.
+
+Free Vector Graphics by [Vecteezy.com](https://vecteezy.com)
+
+¡Nos vemos en el futuro!

content/blogs/2017-08-14-atributos-en-unity/es.mdx

@@ -0,0 +1,164 @@
+---
+layout: post
+current: post
+cover: assets/images/posts/2017-08-14-atributos-en-unity/header.jpg
+navigation: True
+title: "Atributos en Unity"
+date: 2017-08-14 12:00:00
+tags: csharp
+class: post-template
+subclass: 'post'
+author: carlosklsone
+---
+
+Buenas a tod@s! Vamos a aprender cómo personalizar las propiedades que se muestran en el inspector de un *Script* mediante atributos. 
+
+Como sabemos, en *Unity*, todas las propiedades que añadimos públicas a un *Script* se muestran automáticamente en el inspector con una forma predeterminada, los '*int*', los '*float*' y los '*string*' por ejemplo, se muestran con una caja de texto, en la que podemos modificar el valor mediante el teclado. Vemos en la siguiente imagen el ejemplo que voy a seguir, con el *Script* de '*Player.cs*'.
+
+```csharp
+public class Player : MonoBehaviour
+{
+    #region Public Fields
+
+    public float Speed = 0.0f;
+    public float JumpPower = 0.0f;
+    public float MaxSpeed = 0.0f;
+    public int Lives = 0;
+    public float MaxHealth = 0.0f;
+
+    #endregion
+
+    #region Private Fields
+
+    private float _health;
+    private bool _grounded;
+    private bool _jump;
+    private bool _attack;
+
+    #endregion
+}
+```
+
+![Attributes](/assets/images/posts/2017-08-14-atributos-en-unity/attributes01.jpg)
+
+
+## Atributos
+
+Hay diferentes atributos que nos ofrecen tanto **Unity** como librerias propias de **.NET**. Aquí vamos a ver algunos que considero útiles a la hora de visualizar las propiedades en el inspector. Para saber todo lo que ofrece *Unity* podéis visitar este [link](https://docs.unity3d.com/ScriptReference/AddComponentMenu.html), donde hay un listado completo con todos los atributos.
+
+### Atributo Header
+
+El primero de ellos es el atributo '*Header*', que sirve para agrupar o categorizar propiedades. En nuestro ejemplo podríamos categorizar nuestras propiedades por control de *Player* y por salud del *Player*, por ejemplo. Para que el atributo surja efecto habría que añadirlo delante del grupo de propiedades que queramos categorizar con esta linea: `[Header("Text")]`. En nuestro ejemplo quedaría así:
+
+```csharp
+[Header("Control Settings")]
+public float Speed = 0.0f;
+public float JumpPower = 0.0f;
+public float MaxSpeed = 0.0f;
+
+[Header("Health Settings")]
+public int Lives = 0;
+public float MaxHealth = 0.0f;
+```
+
+![Attributes](/assets/images/posts/2017-08-14-atributos-en-unity/attributes02.jpg)
+
+**Nota:** estos atributos, solo funcionan en propiedades públicas como es lógico, más adelante veremos como mostrar una propiedad privada en el inspector.
+
+### Atributo Range
+
+El segundo que os voy a mostrar es el atributo '*Range*', que nos va a facilitar el uso en el inspector de números enteros y flotantes, mediante una '*slider*', y con la posibilidad de ponerle un mínimo y un máximo. Su nomenclatura sería así: `[Range(min, max)]`. Podríamos añadirlo a cualquier '*int*' o '*float*' que tengamos, pero en nuestro ejemplo vamos añadirlo a la velocidad, a las vidas y a la salud máxima del personaje. 
+
+```csharp
+[Header("Control Settings")]
+[Range(1.0f, 10.0f)]
+public float Speed = 0.0f;
+public float JumpPower = 0.0f;
+public float MaxSpeed = 0.0f;
+
+[Header("Health Settings")]
+[Range(1, 5)]
+public int Lives = 0;
+[Range(50.0f, 100.0f)]
+public float MaxHealth = 0.0f;
+```
+
+![Attributes](/assets/images/posts/2017-08-14-atributos-en-unity/attributes03.jpg)
+
+### Atributos HideInInspector y SerializeField
+
+Estos dos atributos sirven para ocultar variables públicas y para mostrar privadas en el inspector respectivamente. Muy útiles, ya que no siempre queremos que una propiedad pública se modifique en el editor, pero si desde otro *Script* por código. Al igual pasa con las propiedades privadas, no siempre queremos que se tenga acceso desde fuera del *Script*, pero si nos es cómodo poder modificarlas desde el inspector. 
+
+En nuestro ejemplo, la propiedad velocidad máxima es pública, y no queremos que se muestre en el inspector, ya que esta propiedad solo se modificará *in game*, cogiendo algún *power up*, por ejemplo. Solo tendríamos que poner encima de la propiedad la siguiente linea `[HideInInspector]`.
+
+Y en el caso de la propiedad privada de salud, que indica la salud actual del personaje, no queremos que se tenga acceso fuera de nuestro *Script*, pero queremos ir haciendo pruebas en el editor, subiendo y bajando la salud actual del personaje, pues solo necesitaríamos añadir `[SerializeField]` encima de la salud.
+
+```csharp
+#region Public Fields
+
+[Header("Control Settings")]
+[Range(1.0f, 10.0f)]
+public float Speed = 0.0f;
+public float JumpPower = 0.0f;
+[HideInInspector]
+public float MaxSpeed = 0.0f;
+
+[Header("Health Settings")]
+[Range(1, 5)]
+public int Lives = 0;
+[Range(50.0f, 100.0f)]
+public float MaxHealth = 0.0f;
+
+#endregion
+
+#region Private Fields
+
+[SerializeField]
+private float _health;
+private bool _grounded;
+private bool _jump;
+private bool _attack;
+
+#endregion
+```
+
+![Attributes](/assets/images/posts/2017-08-14-atributos-en-unity/attributes04.jpg)
+
+### Atributo Tooltip
+
+Este atributo es muy útil para trabajar en equipo, si estás trabajando con más compañeros en un componente, para ayudar a los diseñadores a la hora de trabajar con los componentes en el editor o si estás creando un componente para otros usuarios. Se define de esta manera: `[Tooltip("Description")]`. En nuestro ejemplo se lo añado a la propiedad Speed:
+
+```csharp
+[Header("Control Settings")]
+[Range(1.0f, 10.0f)]
+[Tooltip("Player Speed. Value between 1 and 10.")]
+public float Speed = 0.0f;
+public float JumpPower = 0.0f;
+[HideInInspector]
+public float MaxSpeed = 0.0f;
+```
+
+![Attributes](/assets/images/posts/2017-08-14-atributos-en-unity/attributes05.jpg)
+
+### Bonus: Atributo RequireComponent
+
+Este atributo ya no se aplica a una propiedad como los anteriores, si no a un *Script* o *Componente*. Y cuando se añade de esta forma `[RequireComponent(typeof(Type))]` delante de la declaración de la clase, hace que todo **GameObject** que lleve el componente '*Player.cs*', va a llevar obligatoriamente un componente del tipo que hemos definido. **Para que surja efecto, debemos de eliminar el componente Player.cs del GameObject si ya lo habiamos incluido**. Lo tenemos que volver a incluir y automaticamente se incluirá también el tipo definido. En nuestro ejemplo vamos a añadir un *Componente* de tipo *Rigidbody2D*:
+
+```csharp
+[RequireComponent(typeof(Rigidbody2D))]
+public class Player : MonoBehaviour
+{
+   ...
+}
+```
+
+![Attributes](/assets/images/posts/2017-08-14-atributos-en-unity/attributes06.jpg)
+
+Hasta aquí los atributos que más útiles me han sido hasta ahora. Hay muchos más, como veréis en el link anterior, podéis probar por vuestra cuenta y ver si os son útiles o no a la hora de vuestros desarrollos.
+
+Podéis bajar el código del ejemplo desde [GitHub](https://github.com/NoCountryForGeeks/Blog/tree/feature/atributosUnity/carlos/atributos-unity/content)
+
+¡Hasta la Próxima!
+
+@CarlosKlsOne
+[![Twitter Follow](https://img.shields.io/twitter/follow/carlosklsone.svg?style=social&label=Follow)](https://twitter.com/carlosklsone)