¿Qué es una promesa?

Una promesa de JavaScript es un objeto que representa la finalización o falla de una tarea asíncrona y su valor resultante.¹

El fin.

Estoy bromeando, por supuesto. Entonces, ¿qué significa esa definición?

En primer lugar, muchas cosas en JavaScript son objetos. Puedes crear un objeto de diferentes maneras. La forma más común es con sintaxis literal de objeto:

const miCarro = {
   color: 'azul',
   tipo: 'sedán',
   puertas: '4',
};

También puedes crear un class e instanciarla con la palabra clave new.

class Carro {
   constructor(color, tipo, puertas) {
      this.color = color;
      this.tipo = tipo;
      this.puertas = puertas
   }
}

const miCarro = new Carro('azul', 'sedán', '4');

console.log(miCarro);

Una promesa es simplemente un objeto como el que creamos con el último ejemplo. Lo instanciamos con la palabra clave new. En lugar de los tres parámetros que pasamos para hacer nuestro auto (color, tipo y puertas), pasamos una función que toma dos argumentos: resolve y reject.

En última instancia, las promesas nos dicen algo sobre la finalización de la función asíncrona de la que la devolvimos–si funcionó o no. Decimos que la función tuvo éxito al decir que la promesa se resolvió, y que no tuvo éxito al decir que la promesa se rechazó.

const myPromesa = new Promesa(function(resolve, reject) {});

console.log(myPromesa);

const myPromesa = new Promesa(function(resolve, reject) {
   resolve(10);
});

Vez, no es demasiado aterrador, solo un objeto que creamos. Y, si lo ampliamos un poco:

Además, podemos pasar cualquier cosa que nos gustaría a resolve y reject. Por ejemplo, podríamos pasar un objeto en lugar de una cadena:

return new Promesa((resolve, reject) => {
   if(algoExitosoPasó) {
      const objetoDeÉxito = {
         msg: 'Éxito',
         data,//...algunos datos que obtuvimos
      }
      resolve(objetoDeÉxito); 
   } else {
      const objetoDeError = {
         msg: 'Ocurrió un error',
         error, //...algún error que recibimos
      }
      reject(objetoDeError);
   }
});

O, como vimos antes, no tenemos que pasar nada:

return new Promesa((resolve, reject) => {
   if(algoExitosoPasó) {
      resolve()
   } else {
      reject();
   }
});

¿Qué pasa con la parte "asincrónica" de la definición?

JavaScript es de un solo subproceso. Esto significa que solo puede ejecutar una cosa a la vez. Si puedes imaginar una carretera, puedes pensar en JavaScript como una autopista de un solo carril. Cierto código (código asíncrono) puede deslizarse hacia el hombro para permitir que otro código lo pase. Cuando se realiza ese código asíncrono, vuelve a la carretera.

Como nota al margen, podemos devolver una promesa desde cualquier función. No tiene que ser asíncrono. Dicho esto, las promesas normalmente se devuelven en los casos en que la función de la que devuelven es asíncrona. Por ejemplo, un API que tiene métodos para guardar datos en un servidor sería un gran candidato para devolver una promesa.

La conclusión:

Las promesas nos brindan una forma de esperar a que se complete nuestro código asíncrono, capturar algunos valores de él y pasar esos valores a otras partes de nuestro programa.

¿Cómo usamos una promesa?

El uso de una promesa también se llama consumir una promesa. En nuestro ejemplo anterior, nuestra función devuelve un objeto de promesa. Esto nos permite usar el encadenamiento de métodos con nuestra función.

Aquí hay un ejemplo de encadenamiento de métodos que apuesto a que no has visto:

const a = 'Una cadena impresionante';
const b = a.toUpperCase().replace('CA', '').toLowerCase();

console.log(b); // una dena impresionante

Ahora, recuerda nuestra (pretendida) promesa:

const algoFueExitoso = true;

function algunaFunciónAsíncrona() {
   return new Promesa((resolve, reject){
      if (algoFueExitoso) {
         resolve();     
      } else {
         reject()
      }
   });
}

Y, consumiendo nuestra promesa usando el encadenamiento de métodos:

algunaFunciónAsíncrona
   .then(ejecutarUnaFunciónSiSeResuelve(conElValorResuelto))
   .catch(oEjecutarUnaFunciónSiEsRechazada(conElValorRechazado));

Un ejemplo (más) real.

Imagina que tienes una función que obtiene usuarios de una base de datos. He escrito una función de ejemplo en Codepen que simula una API que podrías usar. Proporciona dos opciones para acceder a los resultados. Uno, puede proporcionar una función de retrollamada donde puede acceder al usuario o cualquier error. O dos, la función devuelve una promesa como una forma de acceder al usuario o error.

Tradicionalmente, accederíamos a los resultados del código asíncrono mediante el uso de retrollamadas.

rr algoDeBaseDeDatos(talVezUnID, function(err, result)) {
   //...Una vez que recuperemos la cosa de la base de datos...
   if(err) {
      hacerAlgoConElError(error)
   }   else {
      hacerAlgoConLosResultados(results);
   }
}

El uso de retrollamada está bien hasta que se anidan demasiado. En otras palabras, tiene que ejecutar más código asincrónico con cada nuevo resultado. Este patrón de retrollamada dentro de las retrollamadas puede conducir a algo conocido como "infierno de retrollamada".

Las promesas nos ofrecen una forma más elegante y legible de ver el flujo de nuestro programa.

hazAlgo()
   .then(hacerAlgoMás) // y si no te importa
   .catch(cualquierErrorPorFavor);

Escribiendo nuestra propia promesa: Ricitos de Oro, los Tres Osos y una Supercomputadora

Imagina que encuentras un plato de sopa. Te gustaría saber la temperatura de esa sopa antes de comerla. No te quedan termómetros, pero por suerte tienes acceso a una supercomputadora que te dice la temperatura del plato de sopa. Desafortunadamente, esta supercomputadora puede tardar hasta 10 segundos en obtener los resultados.

Aquí hay un par de cosas para notar.

1. Iniciamos una variable global llamado result.
2. Simulamos la duración del retraso de la red con Math.random() y setTimeout().
3. Simulamos una temperatura con Math.random().
4. Mantenemos los valores de retardo y temperatura confinados dentro de un rango agregando algunas "matemáticas" adicionales. El rango de temp es de 1 a 300; el rango de delay es de 1000 ms a 10000 ms (1s a 10 segundos).
5. Registramos el retraso y la temperatura para tener una idea de cuánto tiempo llevará esta función y los resultados que esperamos ver cuando esté lista.

Ejecute la función y registre los resultados.

getTemperature(); 
console.log(results); // undefined (indefinido)

La temperatura no está definida. ¿Qué pasó?

La función tardará un cierto tiempo en ejecutarse. El variable no se establece hasta que finaliza el retraso. Entonces, mientras ejecutamos la función, setTimeout es asíncrono. La parte del código en setTimeout sale del subproceso principal hacia un área de espera.

Dado que la parte de nuestra función que establece el variable de result se mueve a un área de espera hasta que finaliza, nuestro analizador puede pasar a la siguiente línea. En nuestro caso, es nuestro console.log(). En este punto, el result aún no está definido, ya que nuestro setTimeout no ha terminado.

Entonces, ¿qué más podríamos intentar? Podríamos ejecutar getTemperature() y luego esperar 11 segundos (ya que nuestro retraso máximo es de diez segundos) y luego console.log los resultados.

getTemperature();
   setTimeout(() => {
      console.log(result); 
   }, 11000);
   
// Too Hot | Delay: 3323 | Temperature: 209 deg

Esto funciona, pero el problema con esta técnica es que, aunque en nuestro ejemplo conocemos el retraso máximo de la red, en un ejemplo de la vida real, en ocasiones puede tardar más de diez segundos. Y, aunque pudiéramos garantizar un retraso máximo de diez segundos, si el resultado está listo antes, estamos perdiendo el tiempo.

Promesas al Rescate

Vamos a refactorizar nuestra función getTemperature() para devolver una promesa. Y en lugar de establecer el resultado, rechazaremos la promesa a menos que el resultado sea "Exacto", en cuyo caso resolveremos la promesa. En cualquier caso, pasaremos algunos valores para resolver y rechazar.

Ahora podemos usar los resultados de nuestra promesa que estamos devolviendo (también conocido como consumir la promesa).

getTemperature()
   .then(result => console.log(result))
   .catch(error => console.log(error));
   
// Reject: Too Cold | Delay: 7880 | Temperature: 43 deg

.then será llamado cuando nuestra promesa se resuelva y devolverá cualquier información que pasemos a resolve.

Se llamará a .catch cuando nuestra promesa se rechace y devolverá cualquier información que pasemos al reject.

Lo más probable es que consumas más promesas de lo que las creas. En cualquier caso, ayudan a que nuestro código sea más elegante, legible y eficiente.

Resumen

1. Las promesas son objetos que contienen información sobre la finalización de algún código asíncrono y los valores resultantes que queremos pasar.
2. Para devolver una promesa usamos return new Promise((resolve, reject)=> {})
3. Para consumir una promesa usamos .then para obtener la información de una promesa que se ha resuelto y .catch para obtener la información de una promesa que se ha rechazado.
4. Probablemente, usarás (consumirás) promesas más de lo que escribirás.

Referencias

1.)https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Promise

He estado trabajando con Go durante la mejor parte de este año, implementando una infraestructura de blockchain escalable en Orbs, y ha sido un año estupendo. En el curso de 2018, investigué qué lenguaje elegir para nuestra implementación de blockchain. Esto nos llevó elegir Go porque, a nuestro entender, tiene una buena comunidad y un conjunto de herramientas maravilloso.

En las semanas recientes estamos entrando en las etapas finales de integración de nuestro sistema. Como en cualquier sistema grande, las etapas siguientes los cuales incluyen problemas de rendimiento, más específico fugas de memoria, podrían ocurrir. Mientras estábamos integrando el sistema, nos dimos cuenta de que encontramos uno. En este artículo tocaré los detalles de cómo investigar una fuga de memoria en Go, detallando los pasos tomados para encontrar, entender y resolverlo.

El conjunto de herramientas ofrecido por Go(lang) es excepcional, pero tiene sus limitaciones. Tocando estos primeros, el más grande es la habilidad limitada de investigar volcados de memoria completos. Un volcado de memoria completo sería la imagen de la memoria (o memoria de usuario) tomado por el proceso que ejecuta el programa.

Podemos imaginar el mapeo de memoria como un árbol, y atravesar ese árbol nos tomaría a través de distintas asignaciones de objetos y las relaciones. Esto significa que cualquier cosa que esté en la raíz es la razón para 'sostener' la memoria y que no sea tomado por el Recolector de Basura. Ya que en Go no hay una manera sencilla de analizar el volcado de memoria completo, ir a las raíces de un objeto que no pasa por el Recolector de Basura es difícil.

Al momento de escribir, fuimos incapaz de encontrar alguna herramienta en línea que nos pueda asistir con eso. Ya que existe un formato de volcado de memoria y una sencilla manera suficiente de exportarlo desde el paquete de depuración, podría ser que haya usado uno en Google. Buscando en línea parece que está en la tubería de Go(lang), creando un visualizador de volcado de memoria como tal, pero parece que nadie está trabajando en él. Habiendo dicho eso, inclusive sin acceso a tal solución, con las herramientas existentes podemos usualmente llegar a la raíz de la causa.

Fugas de Memoria

Las fugas de memoria, o presión de memoria, pueden venir en varias formas a través de todo el sistema. Usualmente, podemos abarcarlos como errores, pero a veces su causa raíz podría ser en decisiones de diseño.

A medida que construimos nuestro sistema bajo principios de diseño emergentes, tales consideraciones no se toman como de importancia y eso está bien. Es más importante construir el sistema de una manera que evita las optimizaciones prematuras y te permita ejecutarlos luego a medida que el código madure, más que sobredimensionarlo desde el principio. Aún, algunos ejemplos comunes de ver problemas de presión de memoria materializarse son:

• Demasiadas asignaciones, representación de datos incorrectos
• Uso intenso de reflexión o de cadenas
• Usar globales
• Huérfanos, rutinas de go interminables

En Go, la manera más sencilla de crear una fuga de memoria es definir una variable global, un arreglo, y adjuntar datos a ese arreglo.

Entonces, ¿por qué estoy escribiendo este post? Cuando estaba investigando este caso encontré muchos recursos sobre fugas de memoria. Aunque, en realidad los sistemas tienen más de 50 líneas de código y un solo struct. En tales casos, encontrar el recurso de un problema de memoria es mucho más complejo de lo que ese ejemplo describe.

Go(lang) nos da una herramienta maravillosa llamada pprof. Esta herramienta, cuando se lo domina, puede ayudar en investigar y muy probablemente encontrar cualquier problema de memoria. Otro propósito que tiene es para investigar problemas de CPU, pero no iré en nada relacionado al CPU en este post.

Herramienta de go pprof

Cubrir todo lo que esta herramienta hace requerirá más que un post de blog. Una cosa que tomó tiempo fue encontrar cómo usar esta herramienta para tener algo procesable. Me concentraré en este post en su característica relacionada a memoria.

El paquete pprof crea un archivo de volcado de muestra de pila, el cual puedes analizar / visualizar luego para darte un mapeo de ambos:

• Asignaciones de memoria Actuales
• Asignaciones de memoria Totales (acumulativas)

La herramienta tiene la habilidad de comparar tomas de imágenes instantáneas. Esto te permite comparar en una pantalla la diferencia de tiempo de lo que pasó ahora mismo y 30 segundos atrás, por ejemplo. Para escenarios de estrés, esto puede ser útil para asistir en asignar áreas problemáticas de tu código.

Perfiles de pprof

La forma en que pprof funciona es usando perfiles.

Un Perfil es una colección de rastros de pila mostrando las secuencias de llamada que llevó a las instancias de un evento particular, tales como asignación.

El archivo runtime/pprof/pprof.go contiene la información detallada y la implementación de los perfiles.

Go tiene varias incorporaciones en perfiles para nosotros para usarlos en casos comunes:

• goroutine — rastros de pila de todas las rutinas de go actuales
• heap — un muestreo de asignaciones de memoria de objetos vivos
• allocs — un muestreo de todas las asignaciones de memoria anteriores
• threadcreate — rastros de pila que llevó a la creación de nuevos hilos del OS
• block — rastros de pila que llevó a bloquear las primitivas de sincronización
• mutex — rastros de pila de poseedores de mutexes disputados

Cuando miremos a los problemas de memoria, nos concentraremos en el perfil de pila. El perfil de asignaciones es idéntico en lo referido a la colección de datos que hace. La diferencia entre los dos es en la manera en que la herramienta pprof lee allí al mismo tiempo. El perfil de asignaciones comenzará pprof en un modo el cual muestra el número total de bytes asignados desde que el programa comenzó (incluyendo los bytes recogidos como basura). Usualmente, usaremos ese modo cuando intentemos hacer nuestro código más eficiente.

La pila

En resumen, aquí es donde el OS (Sistema Operativo) almacena los objetos de memoria que nuestro código utiliza. Esta es la memoria el cual luego queda 'coleccionado como basura', o liberado manualmente en lenguajes no coleccionados como basura.

La pila no es el único lugar donde las asignaciones de memoria ocurren, alguna memoria también es asignado en el Stack. El propósito del stack es de corto plazo. En go el stack es usualmente usado para asignaciones que ocurren dentro del cierre de una función. Otro lugar donde Go usa el stack es donde el compilador 'sabe' cuánto de memoria necesita ser reservada antes del tiempo de ejecución (por ej. arreglos de tamaño fijos). Hay una manera de ejecutar el compilador de Go de manera que mostrará una análisis de dónde las asignaciones 'escapan' del stack a la pila, pero no tocaré eso en este post.

Mientras que los datos de la pila necesitan ser 'liberados' y pasar por gc, los datos del stack no lo necesitan. Esto significa que es más eficiente usar el stack donde fuera posible.

Esto es un resumen de las distintas localizaciones donde la asignación de memoria ocurre. Hay un montón más de esto pero estará fuera del alcance para este post.

Obtener datos de la pila con pprof

Hay dos manera generales de obtener los datos para esta herramienta. El primero será usualmente parte de esta prueba o una rama e incluye importar runtime/pprof y después llamar a pprof.WriteHeapProfile(algun_archivo) para escribir la información del heap.

Nota que WriteHeapProfile es sintaxis legible para ejecutar :

// lookup toma un perfil namepprof.Lookup("heap").WriteTo(algun_archivo, 0)

De acuerdo con la documentación, WriteHeapProfile existe para retrocompatibilidad. El resto de los perfiles no tienen tales atajos y debes usar la función Lookup() para obtener sus datos de perfil.

El segundo, el cual es el más interesante, es habilitarlo sobre HTTP (puntos finales basados en web). Esto te permite extraer el adhoc de los datos, desde un contenedor en ejecución en tu entorno e2e / prueba o inclusive desde 'producción'. Este es un lugar mas donde el tiempo de ejecución y el conjunto de herramientas de Go sobresale. La documentación del paquete entero lo encuentras aquí, pero el TL;DR es que necesitarás agregarlo a tu código así:

import (  "net/http"  _ "net/http/pprof")
...
func main() { ... http.ListenAndServe("localhost:8080", nil)}

El 'efecto secundario' de importar net/http/pprof es el registro de los puntos finales de pprof en la raíz del servidor web en /debug/pprof.  Ahora usando curl podemos obtener los archivos de información del heap para investigar:

curl -sK -v http://localhost:8080/debug/pprof/heap > heap.out

Agregando el http.ListenAndServe() arriba es requerido solamente si tu programa no tenía un oyente de http antes. Si lo tienes lo enganchará y no hay necesidad de escuchar otra vez. Hay formas también de configurarlo usando ServeMux.HandleFun() el cual tendría más sentido para un programa habilitado para http más complejo.

Usando pprof

Así que hemos recogidos datos, ¿ahora qué? Como mencionamos arriba, hay dos estrategias de análisis de memorias principales con pprof. Una es mirar las asignaciones actuales (cuenta de bytes u objeto), llamado inuse. El otro es mirar todos los bytes asignados o cuenta de objeto a lo largo del tiempo de ejecución del programa, llamado alloc. Esto significa que a sin importar si fue a través de gc, una suma de todo lo muestreado.

Este es un buen lugar para reiterar que el perfil de la pila es un sampleo de las asignaciones de memoria. pprof en detrás de escena está usando la función runtime.MemProfile, el cual por defecto recolecta información de asignación en cada 512KB de los bytes asignados. Es posible cambiar MemProfile para recoger información de todos los objetos. Nota que muy probablemente, esto ralentizará tu aplicación.

Esto significa que por defecto, hay alguna chance de que un problema pueda ocurrir con objetos más pequeños que pasará inadvertido del radar de pprof. Para una base de código grande / programa de larga duración, esto no es un problema.

Una vez que recogimos el archivo del perfil, es tiempo de cargarlo en la consola interactiva que pprof ofrece. Hazlo así corriendo:

> go tool pprof heap.out

Observemos la información que se muestra

Type: inuse_spaceTime: Jan 22, 2019 at 1:08pm (IST)Entering interactive mode (type "help" for commands, "o" for options)(pprof)

Lo importante a notar aquí es el Type: inuse_space. Esto significa que estamos mirando a los datos de asignación de un momento específico (cuando capturamos el perfil). El tipo es el valor de configuración de sample_index, y los valores posibles son:

• inuse_space — cantidad de memoria asignada y no liberada todavía
• inuse_object s— cantidad de objetos asignados y no liberados todavía
• alloc_space — cantidad total de memoria asignada (sin importar of released)
• alloc_objects — cantidad total de objetos asignados (sin importar de released)

Ahora escribe top en el interactivo, la salida serán los consumidores máximos de memoria

Podemos ver una línea diciéndonos sobre Droppped Nodes, esto significa que son filtrados. Un nodo es una entrada de objeto, o un 'nodo' en el árbol. Discontinuar nodos es una buena idea para reducir algo de ruido, pero a veces podría ocultar la causa raíz de un problema de memoria. Veremos un ejemplo de eso mientras continuamos con nuestra investigación.

Si quieres incluir todos los datos del perfil, agrega la opción -nodefraction=0 cuando ejecutes pprof o escribe nodefraction=0 en la consola interactiva.

En la lista expuesta podemos ver dos valores, flat y cum.

• flat significa que la memoria es asignada por esta función y retenida por esa función
• cum significa que la memoria fue asignada por esta función o una función que llamó al stack

Esta sola información puede a veces ayudarnos en entender si hay un problema. Toma por ejemplo un caso en donde la función es responsable de asignar mucha memoria pero no lo está reteniendo. Esto significaría que algún otro objeto está apuntando a esa memoria y manteniéndola asignada, lo que significa que tendríamos un problema de diseño de sistema o un error.

Otro truco elegante sobre top en la ventana interactiva es que en realidad está ejecutando top10. El comando top soportar el formato topN donde N es el número de entradas que quieres ver. En el caso pegado arriba, ejecutar top70 por ejemplo, imprimiría todos los nodos.

Visualizaciones

Mientras que el topN da una lista textual, hay varias opciones de visualizaciones muy útiles que vienen con pprof. Es posible escribir png o gif y muchos más (mira go tool pprof -help para una lista completa).

En nuestro sistema, la salida visual por defecto se ve algo así:

Esto podría ser intimidante al principio, pero es la visualización de los flujos de asignación de memoria (según los rastros del stack) en un programa. Leer el gráfico no es tan complicado como parece. Un cuadrado en blanco con un número muestra espacio asignado (y lo acumulativo de cuánta memoria está tomando ahora mismo en el borde del gráfico), y cada rectángulo más ancho muestra la función de asignación.

Nota que en la imagen de arriba, tomé un png de un modo de ejecución inuse_space. Muchas veces deberías ver  también a inuse_objects, ya que puede ayudar en encontrar problemas de asignación.

Indagando más profundo, encontrando una cause raíz

Hasta ahora, fuimos capaz de entender qué es asignar memoria en nuestra aplicación durante el tiempo de ejecución. Esto nos ayuda a tener una sensación de cómo nuestro programa se comporta (o se malcomporta).

En nuestro caso, podríamos ver que la memoria es retenida por membuffers, el cual es nuestra librería de serialización de datos. Esto no significa que tenemos una fuga de memoria en ese segmento de código, sino que la memoria está siendo retenida por esa función. Es importante entender cómo leer el gráfico, y la salida de pprof en general. En este caso, entender que cuando serializamos los datos, lo que quiere decir que asignamos memoria a objetos structs y primitivos (int, string), nunca es liberado.

Saltando a conclusiones o malinterpretando el gráfico, podríamos haber asumido que uno de los nodos en el camino a serialización es responsable de retener la memoria, por ejemplo:

En algún lugar en la cadena podemos ver nuestra librería de registro, responsable de >50Mb de memoria asignada. Esto es memoria la cual es asignada por funciones llamadas por nuestro registrador. Pensándolo bien, en realidad es lo que se espera. El registrador ocasiona asignaciones de memoria ya que necesita serializar datos para imprimirlos al registro y así causa asignaciones de memoria en el proceso.

También podemos ver el camino de asignación, la memoria es retenida solamente por serialización y nada más. Adicionalmente, la cantidad de memoria retenida por el registrador es de 30% del total. Lo de arriba nos dice que, muy probablemente, el problema no es con el registrador. Si fuera 100%, o algo cerca a eso, entonces deberíamos haber estado mirando allí – pero no. Lo que podría significar es que algo está siendo registrado que no debería, pero no es una fuga de memoria por el registrador.

Este es un buen tiempo para introducir otro comando de pprof llamado list. Acepta una expresión regular el cual será un filtro de qué listar. La 'lista' es en realidad el código fuente anotado relacionado a la asignación. En el contexto del registrador el cual estamos viendo, ejecutaremos list RequestNew ya que nos gustaría ver llamadas hechas al registrador. Estas llamadas están viniendo de dos funciones los cuales vienen a empezar con el mismo prefijo.

Podemos ver que las asignaciones están en la columna cum, lo que significa que la memoria asignada es retenida al stack de llamada. Esto se correlaciona a lo que el gráfico también muestra. En este punto es fácil ver que la razón de que el registrador estaba asignando la memoria es porque le enviamos  el objeto 'bloque' entero. Necesitaba serializar algunas partes de éste a lo menos (nuestros objetos son objetos de membuffer, lo cuales siempre implementan algunas función String()). ¿Es un mensaje de registro útil, o una buena práctica? Probablemente no, pero no es una fuga de memoria, no al final del registrador o del código el cual llamó el registrador.

list puede encontrar el código fuente al buscarlo en tu entorno GOPATH. En casos donde la raíz que se busca no coincide, el cual depende en tu máquina de construcción, puedes usar la opción -trim_path. Esto te ayudará para arregrarlo y te permite ver el código de fuente anotado. Recuerda poner tu git al commit correcto el cual se estaba ejecutando cuando el perfil heap fue capturado.  

Entonces, ¿por qué la memoria es retenida?

El trasfondo de esta investigación fue la sospecha de que tenemos un problema – una fuga de memoria. Llegamos a esa noción mientras vimos que el consumo de memoria fue más alto de lo que esperaríamos que el sistema necesitara. Encima de eso, lo vimos incrementar, lo cual fue otro fuerte indicador de que 'hay un problema aquí'.

En este punto, en el caso de Java o .Net, abriríamos algún análisis 'gc roots' o el perfilador y llegar al objeto actual el cual está referenciando a ese dato, y está creando la fuga. Como se explicó, esto no es exactamente posible con Go, ambos por un error de herramienta pero también por la representación baja de memoria de Go.

Sin ir en detalles, no pensamos que Go tiene noción de qué objeto es almacenado en tal dirección (excepto por los punteros tal vez). Esto significa que en realidad, entender qué dirección de memoria representa tal miembro de tu objeto (struct) requerirá algún tipo de mapeo a la salida de un perfil de pila. Hablando de teoría, esto podría significar que antes de tomar un volcado de memoria completo, uno debería también tomar un perfil de pila, de esa manera las direcciones pueden ser mapeados a la línea de asignación y archivo y así el objeto representado en la memoria.

En este punto, porque estamos familiarizado con nuestro sistema, fue fácil entender que ya no es un error. Fue (casi) por diseño. Pero continuemos explorando en cómo obtener la información de las herramientas (pprof) para el encontrar la causa raíz.

Cuando ponemos nodefraction=0 llegaremos a ver el mapeo entero de los objetos asignados, incluyendo los más pequeños. Miremos la salida:

Tenemos dos subárboles nuevos. Recordando otra vez, el perfil de pila de pprof está muestreando asignaciones de memoria. Para nuestro sistema eso funciona – no estamos perdiendo ninguna información importante. El nuevo árbol más largo, en verde, el cual está completamente desconectado del resto del sistema es el ejecutador de pruebas, no es interesante.

El más corto, en azul, el cual tiene una esquina conectándolo al sistema entero es inMemoryBlockPersistance. Ese nombre también explica la 'fuga' que imaginamos que tenemos. Este es el backend de los datos, el cual está ordenando todos los datos en memoria y no persiste en el disco. Lo que es lindo de notar es que podríamos ver inmediatamente que está reteniendo dos objetos grandes. ¿Por qué dos? Porque podemos ver que el objeto es del tamaño de 1.28MB y la función está reteniendo 2.57MB, lo que significa dos de ellos.

El problema está bien entendido en este punto. Podríamos haber usado delve (el depurador) para ver que este es el arreglo reteniendo todos los bloques para el controlador de persistencia en memoria que tenemos.  

Así que, ¿qué podríamos arreglar?

Bueno, eso apesta, fue un error humano. Mientras el proceso fue educativo (y compartir es cuidar), no mejoramos, ¿o sí?

Hubo una cosa que todavía 'olía' sobre esta información de la pila. Los datos deserializados estaban tomando demasiada memoria, ¿por qué 142MB para algo que debería estar tomando sustancialmente menos?... pprof puede responder eso – en realidad, existe una manera de responder a tales preguntas exactamente.

Para buscar el código fuente anotado de la función, ejecutaremos list lazy. Usamos lazy, ya que el nombre de la función que estamos buscando es lazyCalcOffsets(), y no sabemos de otra funciones en nuestro código que comiencen con lazy. Escribir list lazyCalcOffsets funcionaría también por supuesto.

Podemos ver dos pedazos interesantes de información. De nuevo, recuerda que el perfil de pila de pprof muestrea la información sobre las asignaciones. Podemos ver que ambos números flat y cum son los mismos. Esto indica que la memoria asignada también es retenida por estos puntos de asignación.

Luego, podemos ver que el make() está tomando algo de memoria. Tiene sentido, es el puntero a la estructura de datos. Aunque también vemos la asignación en la línea 43 está tomando memoria, lo que significa que crea una asignación.

Esto nos enseñó sobre mapeos, donde una asignación a un mapeo no es una asignación de variable directa. Este artículo va en gran detalle sobre cómo el mapeo funciona. En pocas palabras, un mapeo tiene una sobrecarga, y cuanto más elementos, más grande esta sobrecarga va a 'costar' cuando comparamos a un slice.

Lo siguiente debería ser tomado como un granito de sal: Estaría bien decir que usar un map[int]T, cuando los datos no están esparcidos o pueden ser convertidos a índices sequenciales, usualmente deberían ser probados con una implementación de corte si el consumo de memoria es una consideración relevante. Aunque, un corte grande, cuando se expanda, podría ralentizar una operación, siendo que en un mapeo esta ralentización será despreciable. No hay una fórmula mágica para las optimizaciones.

En el código de arriba, después de chequear cómo usamos ese mapeo, nos dimos cuenta que mientras nos imaginábamos que es un arreglo esparcido, no llegó a ser tan esparcido. Esto coincide con el argumento de arriba y podríamos ver inmediatamente que una refactorización pequeña de cambiar el mapeo a un corte es en realidad posible, y podría hacer ese código más eficiente para la memoria. Así que lo cambiamos a:

Tan simple como eso, en vez de usar un mapeo ahora estamos usando un corte. Debido a la manera en que recibimos los datos los cuales son cargados de manera perezoza dentro del corte, y cómo después accedemos a esos datos, aparte de esas dos líneas y la estructura reteniendo esos datos, ningún otro cambio de código fue requerido. ¿Qué le hizo al consumo de memoria?  

Miremos a benchcmp durante un par de pruebas.

Las pruebas de lectura inicializan la estructura de datos, los cuales crean las asignaciones. Podemos ver que el tiempo de ejecución mejoró con un ~30%, las asignaciones han bajado en un 50% y el consumo de memoria con un >90%(!).

Ya que el mapeo, ahora corte, nunca fue llenado con muchos items, los números más o menos muestran que veremos en producción. Depende en la entropía de los datos, pero podría haber casos donde las asignaciones y las mejoras de consumo de memoria hubieran sido aún más grandes.

Viendo a pprof otra vez, y tomando un perfil de pila de la misma prueba, veremos que ahora el consumo de memoria es de hecho por debajo del ~90%.

El punto será que para los conjuntos de datos más pequeños, no deberías usar mapeos donde los cortes bastarían, ya que los mapeos tienen una sobrecarga grande.

Volcado de memoria completo

Como se mencionó, aquí es donde vemos la limitación más grande con las herramientas ahora mismo. Cuando estábamos investigando este problema, nos obsesionamos con ser capaz de llegar al objeto raíz, sin mucho éxito. Go evoluciona con el tiempo a un gran ritmo, pero esa evolución viene con un precio en el caso del volcado de memoria o la representación de memoria. El formato del volcado de la pila completa, ya que cambia, no es retrocompatible. Para la última versión descrito aquí y escribir un volcado de pila completa, puedes usar debug.WriteHeapDump().

Aunque ahora mismo, no nos encontramos 'estancados' porque no hay una buena solución para explorar volcados completos. pprof contestó todas nuestras preguntas hasta ahora.

Toma nota, la internet recuerda un montón de información que ya no es más relevante. Aquí hay algunas cosas que deberías ignorar si vas a intentar y abrir un volcado completo tu mismo, a partir de go1.11:

• No hay manera de abrir y depurar un volcado de memoria completo en MacOS, solamente en Linux.
• Las herramientas en https://github.com/randall77/hprof son para Go1.3, existe un fork para 1.7+ pero no funciona apropiadamente tampoco (incompleto).
• viewcore at https://github.com/golang/debug/tree/master/cmd/viewcore no compila realmente. Es bastante fácil arreglar (los paquetes en lo interno están apuntando a golang.org y no a github.com), pero, tampoco funciona, no en MacOS, tal vez en Linux.
• https://github.com/randall77/corelib también falla en MacOS

pprof UI

Un último detalle a tener en mente cuando se trata de pprof, es su característica UI. Puede salvar mucho tiempo cuando se empieza una investigación en cualquier problema relacionando a un perfil tomado con pprof.

go tool pprof -http=:8080 heap.out

A este punto debería abrir el navegador web. Si no lo hace entonces busca en el puerto en el que lo configuraste. Te permite cambiar las opciones y tener retroalimentación visual más rápido de lo que puedes con una línea de comando. Una manera muy útil de consumir la información.

La UI en realidad me hizo familiarizar con los gráficos de llama, los cuales exponen áreas culpables del código muy rápidamente.

Conclusión

Go es un lenguaje emocionante con un muy rico conjunto de herramientas, hay mucho más de lo que puedes hacer con pprof. Este post no toca perfilado de CPU en absoluto, por ejemplo.

Las estructuras de datos y los algoritmos son algunos de los temas más esenciales para los programadores, tanto para conseguir un trabajo como para hacerlo bien. Un buen conocimiento de las estructuras de datos y los algoritmos es la base para escribir un buen código.

Si estás familiarizado con las estructuras de datos esenciales, como por ejemplo: arreglo, cadenas, listas enlazadas, árboles binarios, mapas, y estructuras de datos avanzadas como tries, y árboles autoequilibrados como los árboles AVL, etc., sabrás cuando usar cuál estructura de datos y calcular el costo de CPU y memoria de tu código.

Aunque no necesitas escribir tu propia arreglo, lista enlazada, o tabla hash, dado que cada SDK de programación importante los proporciona, por ejemplo: JDK o la librería STL de C++, necesitarás entenderlos para poder utilizarlos en el lugar adecuado.

El uso de la estructura de datos correcta puede mejorar drásticamente el rendimiento de un algoritmo.

Idealmente, todos deberíamos aprender estructuras de datos y algoritmos en nuestras escuelas y universidades, pero rara vez se cubre. La mayoría de los programadores, incluyéndome a mí, solo conocemos una estructura de datos en nuestros cursos de informática, pero realmente no aprendimos su importancia en el mundo real, y es por eso que no los entendemos mejor.

Para nosotros, son solo los algoritmos y las estructuras de datos, solo conceptos, no herramientas que puedas utilizar para escribir buenos programas. No sabíamos que Facebook los usaría para almacenar nuestros datos o que Google los usaría para almacenar páginas web y enlaces a consultas de búsqueda.

De todos modos, nunca es demasiado tarde.

Si crees que tu conocimiento de estructura de datos no está a la altura o deseas mejorar tu conocimiento de estructura de datos, entonces has venido al lugar correcto.

Anteriormente, compartí algunos libros en inglés gratuitos para aprender estructuras de datos y algoritmos, y en este artículo, aprenderás sobre algunos de los mejores cursos de estructura de datos y algoritmos que están disponibles de forma gratuita en línea.

Cursos gratis para aprender estructura de datos y algoritmos

Aquí está mi lista de algunos de los mejores cursos para aprender estructuras de datos y algoritmos, que además son gratuitos. Muchos programadores piensan que los recursos gratuitos no son buenos, lo cual no es cierto.

Aunque a veces no igualan la calidad y la cobertura de los recursos pagos, son, de hecho, los mejores recursos para empezar.

Puedes usar estos cursos para familiarizarse con las estructuras de datos esenciales y aprender algunos conceptos básicos.

Algunos de ellos son particularmente buenos desde el punto de vista de una entrevista, por lo que puede utilizarlos junto con cualquier libro que estés utilizando para prepararte para su entrevista de trabajo de programación.

Curso #1: Conceptos de estructura de datos en C

Este es otro curso gratuito de capacitación en línea sobre algoritmos y estructuras de datos, cuyo objetivo es enseñar estructuras de datos básicas en la programación de computadoras.

Las estructuras de datos que se enseñan en el curso incluyen Stack, Queue y Listas enlazadas, empleando el lenguaje de programación C.

El objetivo principal de esto es hacer que los estudiantes y los ingenieros de software visualicen cómo funcionan las diferentes estructuras de datos.

Este no es un curso exhaustivo, pero aprenderás sobre Stack, Queue y listas enlazadas.

En resumen, es un gran curso para programadores nuevos en estructuras de datos y para aquellos que acaban de aprender un lenguaje de programación y quieren aprender los conceptos básicos de cómo funcionan las estructuras de datos.

Curso #2: Algoritmos Parte 1 - Coursera

Esta es la primera parte de una serie de cursos de dos partes que cubren algoritmos y estructuras de datos en Coursera por Robert Sedgewick.

En esta parte, aprenderá estructuras de datos esenciales como listas enlazadas, stacks, queues, árboles binarios, y tablas hash, y algoritmos de búsqueda y clasificación como: binary search, quicksort, mergesort, insertion sort, etc.

También aprenderás sobre las estructuras de datos centrales y los algoritmos utilizados en las aplicaciones cotidianas y comprenderá las ventajas y desventajas involucradas en la elección de cada estructura de datos junto con los algoritmos de recorrido, recuperación y actualización.

Todas las características de este curso están disponibles de forma gratuita, pero no ofrece un certificado al finalizar.

Curso #3: Algoritmos - Parte 2

Esta es la segunda parte de una serie de dos partes de cursos gratuitos en línea de Coursera que cubren estructuras de datos y algoritmos de Robert Sedgewick y Kevin Wayne, ambos profesores de Ciencias de la Computación.

Robert Sedgewick también es el autor del libro Algoritmos 4th Edition , uno de los libros más populares sobre algoritmos para desarrolladores de Java.

En esta parte, aprenderás sobre los algoritmos de procesamiento de cadenas y gráficos.

También aprenderás algunas estructuras de datos y algoritmos avanzados empleados en el desarrollo de aplicaciones.

Hablando de la prueba social, tanto Algoritmos Parte 1 y  Algoritmos Parte 2 son cursos altamente recomendados y tienen críticas y calificaciones impresionantes.

Curso #4. Estructuras de datos en Java

Este es un curso introductorio en línea sobre estructuras de datos, algoritmos y análisis de complejidad. Te enseñará el diseño, la implementación y el análisis de estructuras de datos básicas utilizando el lenguaje Java.

La mejor parte de este curso es la cantidad de ejemplos prácticos y que se enfoca en la intuición en lugar de fórmulas y pruebas matemáticas.

El curso proporciona una buena introducción al “análisis de complejidad”, que permite detectar un programa con un rendimiento deficiente (y excelente), incluso sin necesidad de ejecutarlo.

Eso es todo acerca de algunos cursos gratuitos de estructuras de datos algoritmos disponibles en línea. Puedes usar estos cursos para aprender estructuras de datos y algoritmos a su propio ritmo.

Puede que no todos sean exhaustivos, pero proporcionan una buena introducción. Una vez que complete estos cursos, puede elegir un buen libro como Introducción a los Algoritmos para complementar aún más su conocimiento.

Curso #5. Estructuras de datos de fáciles a avanzadas

Actualización: este curso ya no es gratuito, pero es un gran curso y puede valer la pena para ti. Este curso de estructura de datos y algoritmos de Udemy son para todas aquellas personas que desean aprender estructuras de datos desde un nivel absolutamente básico hasta avanzado.

Este curso no espera que tenga ningún conocimiento previo de estructuras de datos, pero un conocimiento previo básico de Java es útil.

El autor @William Fiset es ingeniero de software en Google y ex finalista mundial de ACM-ICPC y tiene excelentes habilidades de programación informática y resolución de problemas.

Hablando de prueba social, el curso tiene más de 25 000 estudiantes y una calificación promedio de 4.1 de 683, lo cual es impresionante.

En resumen, es una guía completa para aprender todo lo que hay que saber sobre las estructuras de datos.

Este también es un curso ideal para estudiantes de ciencias de la computación y profesionales de software en activo que desean aprender estructuras de datos y algoritmos desde una perspectiva de entrevista.

Entonces, si estás buscando un trabajo en compañías basadas en productos como Amazon, Google, Microsoft, o Facebook, puedes usar este curso para poner en marcha tu preparación.

Notas de cierre

Gracias. Llegaste al final del artículo. ¡Buena suerte en tu camino para convertirte en programador! Ciertamente, no será fácil, pero al seguir estos cursos, estarás un paso más cerca de dominar la estructura de datos y los algoritmos que otros.

Si te gustó este artículo, compártelo con tus amigos y colegas, ¡y no olvides seguir a javinpaul en Twitter!

Otro gran lenguaje para añadir a tu cinturón de herramientas de desarrollador full-stack es el sencillo y productivo lenguaje de programación de propósito general Go.

Gracias a un proyecto iniciado en 2007, Go vio la luz gracias al esfuerzo de algunos programadores de Google. Pusieron mucho cuidado en el diseño de Go para que fuera claro y coherente en sus características de lenguaje y bibliotecas estándar, haciendo que Go fuera fácil y divertido de usar.

Es lo mejor del código abierto… pero no olvide que distingue entre mayúsculas y minúsculas.

Empecemos con el sistema operativo Microsoft Windows 10. Verás lo fácil que es en realidad - solo se requiere un conocimiento básico de GitHub y el símbolo del sistema. Seguro que hay otras maneras de instalar y ejecutar el programa, pero con un conocimiento limitado de codificación sentí que este conjunto de instrucciones era el más fácil de entender y seguir.

Asegúrese de seguir estos pasos en su totalidad, así como en el orden correcto (como se indica) para ahorrarse, tener que desinstalar Go y pasar unas cuantas horas solucionando cualquier problema relacionado con la instalación.

Fase 1: Instale lo siguiente en este orden

1. Como Go utiliza a menudo repositorios de código abierto (¡GRATUITOS!), asegúrate de instalar primero el paquete Git aquí.
2. Navegue hasta el sitio web de instalación de Go aquí. Descargue e instale la última versión de Go de 64 bits para el sistema operativo Microsoft Windows.
3. Siga las instrucciones del programa de instalación Go.
4. Ejecute el símbolo del sistema en su ordenador buscando "cmd". Abra la línea de comandos y escriba "go version"
5. La salida después de introducir la versión go debería tener este aspecto:

Fase 2: Creación del espacio de trabajo Go

En primer lugar, confirme sus binarios Go: vaya al Panel de control de su ordenador, luego a Sistema y seguridad > Sistema > Configuración avanzada del sistema y, en el panel de la izquierda, haga clic en la pestaña Avanzado. A continuación, haga clic en Variables de entorno en la parte inferior derecha. Asegúrese de que la variable "C:\Go\bin" está en la ruta de las variables del sistema.

A continuación, cree su espacio de trabajo Go. Esto será en una carpeta nueva y separada de donde se guardan los archivos de instalación de Go. Por ejemplo, sus archivos de instalación G se guardaron en la ruta C:\Go y usted está creando su espacio de trabajo Go en C:\Projects\Go

En tu nueva carpeta Go work-space, crea tres nuevas carpetas:

Fase 3: Crear la variable de entorno GOPATH

Crea la variable GOPATH y haz referencia a tu recién creado espacio de trabajo Go. Vuelve a tu Panel de Control y navega hasta Sistema y luego a Variables de Entorno. A continuación, en Variables del sistema, haga clic en Nuevo.

Junto a Nombre de variable, introduzca "GOPATH", y junto a Valor de variable introduzca "C:\Proyectos\Go".

Para comprobar que la ruta se ha establecido correctamente, introduzca "echo %GOPATH%" en la línea de comandos.

Fase 4: Probar y garantizar

Ahora estás listo para verificar que todo funciona correctamente abriendo la línea de comandos y escribiendo: go get github.com/golang/example/hello

Espere a que el código se ejecute por completo (puede tardar unos segundos) y, a continuación, introduzca lo siguiente en la línea de comandos: %GOPATH%/bin/hello

Si la instalación se ha realizado correctamente, debería recibir el siguiente mensaje de retorno: “Hello, Go examples!”

Espero que tenga éxito. Y si te encuentras con algún error o mensajes confusos, comentar a continuación con los resultados de esta línea de comandos: “go env”

¡Y ahora estás listo para convertirte en un "Gopher"!

Exploremos algunos conceptos básicos que nos ayudarán a crear una IA de ajedrez sencilla:

• move-generation
• board evaluation
• minimax
• and alpha beta pruning.

En cada paso, mejoraremos nuestro algoritmo con una de estas técnicas de programación de ajedrez probadas con el tiempo. Demostraré cómo afecta cada una de ellas al estilo de juego del algoritmo.

Puedes consultar el algoritmo final de IA aquí, en GitHub.

Paso 1: Generación de movimientos y visualización del tablero

Usaremos la librería chess.js para la generación de movimientos, y chessboard.js para visualizar el tablero. La librería de generación de movimientos básicamente implementa todas las reglas del ajedrez. Basándonos en esto, podemos calcular todos los movimientos legales para un estado dado del tablero.

El uso de estas bibliotecas nos ayudará a centrarnos solo en la tarea más interesante: crear el algoritmo que encuentre la mejor jugada.

Empezaremos creando una función que simplemente devuelva una jugada aleatoria de entre todas las posibles:

Aunque este algoritmo no es un jugador de ajedrez muy sólido, es un buen punto de partida, ya que podemos jugar contra él:

Paso 2: Evaluación de la posición

Ahora vamos a intentar comprender qué bando es más fuerte en una posición determinada. La forma más sencilla de conseguirlo es contar la fuerza relativa de las piezas en el tablero utilizando la siguiente tabla:

Con la función de evaluación, somos capaces de crear un algoritmo que elige el movimiento que da la evaluación más alta:

La única mejora tangible es que ahora nuestro algoritmo capturará una pieza si puede.

Paso 3: Árbol de búsqueda utilizando Minimax

A continuación vamos a crear un árbol de búsqueda a partir del cual el algoritmo pueda elegir la mejor jugada. Esto se hace mediante el algoritmo Minimax.

En este algoritmo, el árbol recursivo de todos los movimientos posibles se explora hasta una profundidad determinada, y la posición se evalúa en las "hojas" finales del árbol.

Después de eso, devolvemos el menor o el mayor valor del hijo al nodo padre, dependiendo de si es un blanco o un negro para mover. (Es decir, tratamos de minimizar o maximizar el resultado en cada nivel).

Con minimax en su lugar, nuestro algoritmo está empezando a entender algunas tácticas básicas del ajedrez:

La eficacia del algoritmo minimax se basa en gran medida en la profundidad de búsqueda que podamos alcanzar. Esto es algo que mejoraremos en el siguiente paso.

Paso 4: Poda alfa-beta

La poda alfa-beta es un método de optimización del algoritmo minimax que nos permite descartar algunas ramas del árbol de búsqueda. Esto nos ayuda a evaluar el árbol de búsqueda minimax mucho más profundamente, utilizando los mismos recursos.

La poda alfa-beta se basa en la situación en la que podemos dejar de evaluar una parte del árbol de búsqueda si encontramos un movimiento que conduce a una situación peor que un movimiento descubierto anteriormente.

La poda alfa-beta no influye en el resultado del algoritmo minimax, sólo lo hace más rápido.

El algoritmo alfa-beta también es más eficiente si visitamos primero los caminos que conducen a buenas jugadas.

Con alfa-beta, obtenemos una mejora significativa del algoritmo minimax, como se muestra en el siguiente ejemplo:

Sigue este enlace para probar la versión alfa-beta mejorada de la IA de ajedrez.

Paso 5: Mejora de la función de evaluación

La función de evaluación inicial es bastante ingenua, ya que sólo contamos el material que se encuentra en el tablero. Para mejorarla, añadimos a la evaluación un factor que tiene en cuenta la posición de las piezas. Por ejemplo, un caballo en el centro del tablero es mejor (porque tiene más opciones y, por tanto, es más activo) que un caballo en el borde del tablero.

Utilizaremos una versión ligeramente ajustada de las tablas pieza-cuadrado que se describen originalmente en chess-programming-wiki.

Con la siguiente mejora, empezamos a conseguir un algoritmo que juega algo de ajedrez "decente", al menos desde el punto de vista de un jugador ocasional:

Conclusiones

El punto fuerte de un algoritmo de ajedrez sencillo es que no comete errores estúpidos. Dicho esto, le sigue faltando comprensión estratégica.

Con los métodos que he introducido aquí, hemos sido capaces de programar un algoritmo de juego de ajedrez que puede jugar al ajedrez básico. La "parte IA" (excluyendo la generación de jugadas) del algoritmo final tiene sólo 200 líneas de código, lo que significa que los conceptos básicos son bastante sencillos de implementar. Puede consultar la versión final en GitHub.

Otras mejoras que podríamos introducir en el algoritmo serían, por ejemplo:

• move-ordering
• generación de movimientos más rápidos
• y la evaluación específica de los objetivos finales.

Si quieres aprender más, echa un vistazo a la wiki de programación de ajedrez. Es un recurso útil para explorar más allá de estos conceptos básicos que he introducido aquí.

Gracias por leerme.

En este manual veremos por qué la programación es tan importante, sus aplicaciones, conceptos básicos y las habilidades que necesitas para tener éxito en el campo de la programación.

Aprenderás:

• Qué es programación y por qué es importante.
• Qué es un lenguaje de programación y por qué son importantes.
• La relación entre programación y los números binarios.
• Aplicaciones prácticas de programación.
• Habilidades que necesitas para tener éxito en el campo de la programación.
• Tips para aprender a programar.
• Conceptos básicos de programación.
• Tipos de lenguajes de programación.
• Cómo contribuir a proyectos de código abierto (open source).
• Y más...

¿Preparados? ¡Comencemos! ✨

🔹 ¿Qué es programación?

¿Sabías que la programación ya es una parte fundamental de tus actividades diarias? Veamos por qué. Estoy segura de que te sorprenderás.

Cada vez que enciendes tu smartphone, laptop, tableta, smart TV o cualquier otro dispositivo electrónico, estás ejecutando código que ha sido planeado, desarrollado y escrito por desarrolladores. Este código crea el resultado final e interactivo que puedes ver en tu pantalla.

Esto es exactamente de lo que se trata la programación. Es el proceso de escribir código para resolver un problema en particular o para implementar una tarea específica.

La programación es lo que le permite a tu computadora ejecutar los programas que usas cada día y es lo que le permite a tu smartphone ejecutar las aplicaciones que te encantan. Es una parte esencial del mundo que conocemos hoy en día.

Cuando revisas tu calendario, asistes a conferencias virtuales, navegas en la web o editas un documento, estás usando código que ha sido escrito por desarrolladores.

Y quizás te estés preguntado: "¿Qué es código?"

Código es una secuencia de instrucciones que un programador escribe para decirle a un dispositivo (como una computadora) qué hacer.

El dispositivo no puede saber por sí mismo cómo manejar una situación en particular o cómo realizar una tarea específica. Así que los desarrolladores analizan la situación y escriben instrucciones explícitas para implementar lo que se necesita.

Para hacerlo, deben usar una sintaxis en particular (un conjunto de reglas para escribir el código).

Un desarrollador (también llamado programador) es una persona que analiza un problema e implementa una solución usando código.

Suena genial, ¿cierto? Es muy poderoso y tú puedes ser parte de este maravilloso mundo si aprender a programar. Veamos cómo.

Tú, como desarrollador.

Visualízate en el rol de un desarrollador por un momento. Imagina que estás desarrollando una aplicación móvil, como las que probablemente tienes instaladas en tu smartphone en este momento.

¿Qué es lo primero que harías?

Piénsalo un momento.

La respuesta es...

Analizar el problema. ¿Qué estas intentando crear?

Como desarrollador, comenzarías diseñando la distribución de la aplicación, cómo funcionará, sus distintas pantallas y funcionalidad y todos esos pequeños detalles que harán que tu aplicación sea genial para los usuarios alrededor del mundo.

Solo después de haber planificado todo cuidadosamente, puedes comenzar a escribir tu código. Para hacerlo, deberás escoger un lenguaje de programación para el proyecto. Veamos qué es un lenguaje de programación y por qué son super importantes.

🔸 ¿Qué es un lenguaje de programación?

Un lenguaje de programación es un lenguaje que las computadoras pueden entender.

No podemos simplemente escribir palabras en español en nuestro programa, de esta forma:

"Computadora, ¡Resuelve esta tarea!"

Y esperar que nuestras computadoras pueden entender lo que intentamos decirles. Debemos seguir ciertas reglas para escribir las instrucciones.  

Cada lenguaje de programación tiene su propio conjunto de reglas que determinan si una línea de código es válida o no. Debido a esto, el código que escribas en un lenguaje de programación será diferente al código que escribas en otros lenguajes de programación.

💡 Dato: algunos lenguajes de programación son más complejos que otros pero la mayoría de ellos comparten conceptos básicos y funcionalidad básica. Si aprendes a programar en un lenguaje de programación, es muy probable que puedas aprender a programar en otro lenguaje de programación mucho más rápido.

Antes de comenzar a desarrollar aplicaciones y programas geniales, debes aprender las reglas básicas del lenguaje de programación que escojas para el proyecto.

💡 Dato: un programa es un conjunto de instrucciones escritas en un lenguaje de programación para que la computadora las ejecute. Normalmente escribimos el código de nuestro programa en un archivo o en varios archivos.

Por ejemplo, esta es una línea de código en Python (un lenguaje de programación muy popular) que muestra el mensaje "¡Hola, Mundo!":

print("¡Hola, Mundo!")

Pero si escribimos la misma línea de código en JavaScript (un lenguaje de programación usado principalmente para el desarrollo web), veremos un error porque no será válida.

Para lograr algo similar en JavaScript, debemos escribir esta línea de código:

console.log("¡Hola, Mundo!");

Visualmente, se ven muy diferentes, ¿cierto? Esto se debe a que Python y JavaScript tienen una sintaxis diferente y un conjunto diferente de funciones built-in.

💡 Dato: las funciones built-in son básicamente tareas que ya están definidas en el lenguaje de programación. Esto nos permite usarlas directamente en nuestro código al escribir sus nombres y especificar los valores que necesitan.

En nuestros ejemplos, print() es una función built-in en Python mientras que console.log() es una función que usamos en JavaScript para ver el mensaje en la consola (una herramienta interactiva) si ejecutamos nuestro código en el navegador.

Ejemplos de lenguajes de programación incluyen Python, JavaScript, TypeScript, Java, C, C#, C++, PHP, Go, Swift, SQL y R. Existen muchos lenguajes de programación y la mayoría de ellos pueden ser usados para distintos propósitos.

💡 Dato: estos fueron los lenguajes de programación más populares en la Stack Overflow Developer Survey 2022 (una encuesta muy popular en la comunidad de desarrolladores):

Existen muchos lenguajes de programación (¡cientos o incluso miles!) pero generalmente aprenderás y trabajarás con algunos de los más populares. Algunos de ellos tienen aplicaciones más amplias como Python y JavaScript mientras que otros (como R) tienen propósitos más específicos (e incluso científicos).

Esto suena muy interesante, ¿cierto? Y apenas estamos comenzando a hablar sobre los lenguajes de programación. Hay mucho que aprender sobre ellos y te prometo que si decides aprender más sobre programación, tu tiempo y esfuerzo valdrán totalmente la pena.

¡Genial! Ahora que ya sabes qué es programación y qué son los lenguajes de programación, veamos cómo la programación está relacionada con los números binarios.

🔹 Programación y números binarios

Cuando piensas en programación, probablemente lo primero que viene a tu mente es algo muy parecido a lo que puedes ver en esta imagen, ¿cierto? Una secuencia de ceros y unos en tu computadora.

En realidad, la programación sí está relacionada con los números binarios (0 y 1) pero de una forma indirecta porque los desarrolladores no escriben su código usando ceros y unos.

Generalmente escribimos nuestros programas en un lenguaje de programación de alto nivel, un lenguaje de programación con una sintaxis que reconoce palabras específicas (llamadas palabras clave o keywords en inglés), símbolos y valores de distintos tipos de datos.

Básicamente, escribimos nuestro código de una forma en la que los seres humanos pueden entenderlo.

Por ejemplo, estas son las palabras clave que usamos en Python:

False               class               from                or
None                continue            global              pass
True                def                 if                  raise
and                 del                 import              return
as                  elif                in                  try
assert              else                is                  while
async               except              lambda              with
await               finally             nonlocal            yield
break               for                 not 

Cada lenguaje de programación tiene su propio conjunto de palabras clave (palabras escritas en inglés). Estas palabras clave son parte de la sintaxis y de la funcionalidad esencial del lenguaje de programación.

Pero las palabras clave son solo palabras comunes en inglés, casi como las que encontraríamos en un libro.

Eso nos lleva a hacer dos preguntas muy importantes:

• ¿Cómo la computadora entiende e interpreta lo que intentamos decir?
• ¿Cuál es el rol del sistema numérico binario en este proceso?

La computadora no entiende estas palabras, símbolos o valores directamente.

Cuando un programa se ejecuta, el código que escribimos en un lenguaje de programación que los seres humanos pueden entender es transformado automáticamente a código binario que la computadora puede entender.

Esta transformación de código fuente (que los seres humanos pueden entender) a código binario (que la computadora puede entender) se llama compilación.

Según Britannica, un compilador se define como:

Un software de computadora que traduce (compila) código fuente escrito en un lenguaje de alto nivel (por ejemplo, C++) a un conjunto de instrucciones en lenguaje de máquina (machine-language instructions) que pueden ser entendidas por el CPU de una computadora digital.

Texto original en inglés:

Computer software that translates (compiles) source code written in a high-level language (e.g., C++) into a set of machine-language instructions that can be understood by a digital computer’s CPU.

Britannica también menciona que:

El término compilador fue acuñado por la científica de computación Americana Grace Hopper, quien diseñó uno de los primeros compiladores en los inicios de la década de 1950.

Texto original en inglés:

The term compiler was coined by American computer scientist Grace Hopper, who designed one of the first compilers in the early 1950s.

Algunos lenguajes de programación pueden ser clasificados como lenguajes de programación compilados mientras que otros pueden ser clasificados como lenguajes de programación interpretados en base a cómo se transforman a instrucciones en lenguaje de máquina.  

Sin embargo, todos deben pasar por un proceso que los convierten en instrucciones que la computadora puede entender.

Genial. Ahora ya sabes por qué el código binario es tan importante para la ciencia de la computación. Sin él, básicamente programación no existiría porque las computadoras no serían capaces de entender nuestras instrucciones.

Ahora veamos las aplicaciones de programación y las distintas áreas que puedes explorar.

🔸 Aplicaciones prácticas de programación

La programación tiene distintas aplicaciones en diversas industrias. Esto es verdaderamente sorprendente porque puedes aplicar tu conocimiento en literalmente cualquier industria que te interese.

Desde ingeniería hasta agricultura, desde desarrollo de videojuegos hasta física, las posibilidades son infinitas si aprendes a programar.

Veamos algunas de ellas. (¡Te prometo que son asombrosas! ⭐).

Desarrollo web front-end

Si aprendes a programar, puedes usar tus habilidades de programación para diseñar y desarrollar páginas web y plataformas en línea. Los desarrolladores web front-end crean las partes de las páginas web que los usuarios pueden ver y los elementos con los cuales pueden interactuar directamente.

Por ejemplo, en este momento estás leyendo un artículo en la publicación de freeCodeCamp. La publicación tiene esta estructura, presentación y funcionalidad gracias al código que los desarrolladores front-end escribieron línea por línea.

💡 Dato: si aprender desarrollo web front-end, tú también pueden crear plataformas interactivas.

Los desarrolladores web front-end usan HML y CSS para crear la estructura de un sitio web (estos son lenguajes de marcado (markup), los cuales se usan para presentar información) y escriben código de JavaScript para agregar funcionalidad e interactividad.

Si deseas aprender desarrollo web front-end, puedes aprender HTML y CSS con estos cursos gratuitos en los canales de YouTube de freeCodeCamp:

• Aprende HTML y CSS - Curso Desde Cero (en Español)
• Aprende React Desde Cero - Curso de React Con Proyectos (en Español)
• Learn HTML5 and CSS3 From Scratch - Full Course
• Learn HTML & CSS – Full Course for Beginners
• Frontend Web Development Bootcamp Course (JavaScript, HTML, CSS)
• Introduction To Responsive Web Design - HTML & CSS Tutorial

También puedes aprender JavaScript de forma gratuita con los siguientes cursos:

• Aprende JavaScript - Curso Completo desde Cero (en Español)
• Learn JavaScript - Full Course for Beginners
• JavaScript Programming - Full Course
• JavaScript DOM Manipulation – Full Course for Beginners
• Learn JavaScript by Building 7 Games - Full Course

💡 Dato: puedes obtener la certificación de Diseño Web Adaptativo aprendiendo con ejercicios interactivos en freeCodeCamp.  

Desarrollo web back-end

Las aplicaciones web más complejas y dinámicas que trabajan con información del usuario también requieren de un servidor. Un servidor es un programa de computadora que recibe solicitudes y y envía respuestas apropiadas. También necesitan una base de datos, una colección de valores almacenados de forma estructurada.

Los desarrolladores web back-end se encargan de desarrollar el código de los servidores. Deciden cómo manejar las distintas solicitudes, cómo enviar los recursos apropiados, cómo almacenar la información y básicamente cómo lograr que todo lo que se ejecuta detrás de escenas funcione correctamente y de forma eficiente.

Un ejemplo real de desarrollo back-end es lo que ocurre cuando creas una cuenta en freeCodeCamp y completas un reto de programación. Tu información se almacena en una base de datos y puedes acceder a ella luego cuando inicias sesión con tu correo electrónico y contraseña.  

Esta funcionalidad genial e interactiva fue implementada por desarrolladores web back-end.

💡 Dato: los desarrolladores web full-stack se encargan del desarrollo web front-end y back-end. Tienen conocimiento especializado sobre ambas áreas.

Todas las plataformas complejas que usas cada día, como las plataformas de redes sociales, plataformas de compras en línea y plataformas educativas, usan servidores y desarrollo web back-end para crear su funcionalidad.

Python es un ejemplo de un lenguaje de programación poderoso para este propósito. Es uno de los lenguajes de programación más populares que existen y su popularidad continúa aumentando cada año. Esto se debe, en parte, a que es sencillo y fácil de aprender y sin embargo, es lo suficientemente poderoso y versátil para ser usado en aplicaciones del mundo real.

💡 Dato: si tienes curiosidad sobre las aplicaciones específicas de Python, este es un artículo que escribí sobre el tema.

JavaScript también puede ser usado para desarrollo web back-end gracias a Node.js

Otros lenguajes de programación usados para desarrollar servidores web son PHP, Ruby, C# y Java.

Si deseas aprender desarrollo web back-end, puedes tomar estos cursos gratuitos en el canal de YouTube de freeCodeCamp:

• Introducción a Programación en Python (en Español)
• Aprende Node.js y Express - Curso desde Cero (en Español)
• Python Backend Web Development Course (with Django)
• Node.js and Express.js - Full Course
• Full Stack Web Development for Beginners (Full Course on HTML, CSS, JavaScript, Node.js, MongoDB)
• Node.js / Express Course - Build 4 Projects

💡 Tip: freeCodeCamp también tiene una certificación gratuita de Desarrollo Back End y APIs.

Desarrollo de aplicaciones móviles

Las aplicaciones móviles ya son parte de nuestra rutina diaria. Estoy segura de que no podrías imaginar la vida sin ellas.

Piensa en tu aplicación móvil favorita. ¿Por qué te gusta tanto?

Nuestras aplicaciones favoritas nos ayudan a realizar nuestras tareas diarias, nos entretienen, resuelven un problema y nos ayudan a alcanzar nuestras metas. Siempre están allí para nosotros.

Ese es el poder del desarrollo de aplicaciones móviles y tú puedes ser parte de este maravilloso mundo si aprender desarrollo de aplicaciones móviles.

Los desarrolladores enfocados en el desarrollo de aplicaciones móviles se encargan de planificar, diseñar y desarrollar la interfaz de usuario y la funcionalidad de las aplicaciones. Identifican un vacío en las aplicaciones existentes e intentan crear un producto funcional que mejore las vidas de las personas.

💡 Dato: independientemente del campo de escojas, tu meta como desarrollador siempre debe ser lograr mejorar la calidad de vida de las personas. Las aplicaciones no son solo aplicaciones, tienen el potencial de cambiar nuestras vidas. Siempre debes recordar esto cuando planifiques tus proyectos. Tu código puede mejorar la vida de alguien y esa es una gran responsabilidad.

Los desarrolladores de aplicaciones móviles usan lenguajes de programación como JavaScript, Java, Swift, Kotlin y Dart. Frameworks como Flutter y React Native son muy útiles para desarrollar aplicaciones multiplataforma (aplicaciones que funcionan correctamente en distintos sistemas operativos como Android y iOS).

Según la documentación oficial de Flutter:

Flutter es un framework de código abierto (open source) desarrollado por Google para desarrollar aplicaciones hermosas, compiladas de forma nativa y multiplataforma a partir de una misma base de código.  

Texto original en inglés:

Flutter is an open source framework by Google for building beautiful, natively compiled, multi-platform applications from a single codebase.

Si deseas aprender desarrollo de aplicaciones móviles, puedes tomar estos cursos gratuitos en el canal de YouTube de freeCodeCamp:

• Flutter Course for Beginners – 37-hour Cross Platform App Development Tutorial
• Flutter Course - Full Tutorial for Beginners (Build iOS and Android Apps)
• React Native - Intro Course for Beginners
• Learn React Native Gestures and Animations - Tutorial

Desarrollo de videojuegos

Los juegos crean recuerdos inolvidables. Estoy segura de que recuerdas tus juegos favoritos y por qué te gustaban (o te gustan) tanto. Ser desarrollador de juegos significa tener la oportunidad de traer alegría y entretenimiento a jugadores alrededor del mundo.

Los desarrolladores de videojuegos visualizan, planifican e implementan la funcionalidad de un videojuego. También deben encontrar o crear recursos como personajes, obstáculos, fondos, música, efectos de sonido y más.

💡 Dato: si aprendes a programar, puedes crear tus propios videojuegos. Imagina crear un juego genial que le fascine a los jugadores alrededor del mundo. Eso es exactamente lo que me encanta sobre programación. Solo necesitas una computadora, tu conocimiento y herramientas básicas para crear algo asombroso.

Lenguajes de programación populares usados para desarrollo de videojuegos incluyen JavaScript, C++, Python y C#.

Si estás interesado en aprender desarrollo de videojuegos, puedes tomar estos cursos gratuitos en el canal de YouTube de freeCodeCamp:

• JavaScript Game Development Course for Beginners
• Learn JavaScript by Building 7 Games - Full Course
• Learn Unity - Beginner's Game Development Tutorial
• Learn Python by Building Five Games - Full Course
• Code a 2D Game Using JavaScript, HTML, and CSS (w/ Free Game Assets) – Tutorial
• 2D Game Development with GDevelop - Crash Course
• Pokémon Coding Tutorial - CS50's Intro to Game Development

Biología, Física y Química

La programación puede aplicarse en todos los campos científicos que puedas imaginar, incluyendo biología, física, química e incluso astronomía. ¡Sí! Los científicos usan programación todo el tiempo para recolectar y analizar datos. Incluso pueden crear simulaciones para probar sus hipótesis.

Biología

En biología, los programas de computadora pueden simular genética de poblaciones y dinámica de poblaciones. Incluso existe un campo llamado bioinformática.

Según el artículo "Bioinformatics" de Ardeshir Bayat, miembro del Centro para la Investigación Médica sobre Genómica Integrada de la Universidad de Manchester:

La bioinformática se define como la aplicación de las herramientas de computación y análisis a la recolección e interpretación de datos biológicos.

Texto original en inglés:

Bioinformatics is defined as the application of tools of computation and analysis to the capture and interpretation of biological data.

El Dr. Bayat menciona que la bioinformática puede ser usada para secuenciar el genoma. También menciona que estos hallazgos pueden llevar al descubrimiento de nuevos medicamentos y terapias personalizadas.

Python, R, PHP, PERL y Java son lenguajes de programación usados comúnmente en el campo de la bioinformática.

💡 Dato: R es un "lenguaje y ambiente de programación para computación y gráficos estadísticos" (fuente).

Un ejemplo de una herramienta genial que los científicos pueden usar para biología es Biopython. Este es un framework de Python con "herramientas disponible de forma gratuita para computación biológica."

Si te gustaría aprender cómo puedes aplicar tus habilidades de programación en campos científicos, puedes tomar estos cursos gratuitos en el canal de YouTube de freeCodeCamp:

• Python for Bioinformatics - Drug Discovery Using Machine Learning and Data Analysis
• R Programming Tutorial - Learn the Basics of Statistical Computing
• Learn Python - Full Course for Beginners [Tutorial]

Física

La física requiere ejecutar simulaciones y programar es perfecto para hacer exactamente eso. Los científicos pueden programar y ejecutar simulaciones basadas en distintos escenarios que serían difíciles de replicar en la vida real. Esto es mucho más eficiente.

Los lenguajes de programación que se usan comúnmente para simulaciones de física incluyen C, Java, Python, MATLAB y JavaScript.

Química

La química también utiliza simulaciones y análisis de datos, así que es un campo en el cual la programación puede ser muy útil.

En este artículo científico del Dr. Ivar Ugi y sus colegas del Organisch-chemisches Institut der Technischen Universität München, mencionan que:

El diseño de síntesis completamente nuevas y la clasificación y documentación de estructuras, subestructuras y reacciones son ejemplos de nuevas aplicaciones de computadoras a la química.

Texto original en inglés:

The design of entirely new syntheses, and the classification and documentation of structures, substructures, and reactons are examples of new applications of computers to chemistry.

Los experimentos científicos también generan datos detallados y resultados que pueden ser analizados con programas de computadora desarrollados por científicos.

Piénsalo: escribir un programa para generar un diagrama de caja (box plot) o un diagrama de dispersión (scatter plot) o cualquier otro tipo de gráfico para visualizar tendencias en miles de valores puede ahorrar mucho tiempo y esfuerzo a los investigadores.

Esto les permite enfocarse en la parte más importante de su trabajo: analizar los resultados.

💡 Dato: si te interesa aprender más sobre este tema, esta es una lista de simulaciones de química de la American Chemical Society. Estas simulaciones fueron programadas por desarrolladores y están ayudando a miles de estudiantes y profesores alrededor del mundo.

Piénsalo... Tú podrías crear la próxima gran simulación. Si te interesa un campo científico, te recomiendo totalmente aprender a programar. Tu trabajo será mucho más productivo y tus resultados serán mucho más fáciles de analizar.

Si te interesa aprender programación para aplicaciones científicas, puedes tomar estos cursos gratuitos en el canal de YouTube de freeCodeCamp:

• Python for Bioinformatics - Drug Discovery Using Machine Learning and Data Analysis
• Python for Data Science - Course for Beginners (Learn Python, Pandas, NumPy, Matplotlib)

Ciencia de datos e ingeniería

Hablando de datos... programación también es esencial para un campo llamado ciencia de datos. Si te interesa responder preguntas a través de datos y estadísticas, este campo puede ser exactamente lo que estás buscando y tener habilidades de programación te ayudará a alcanzar tus metas.

Los científicos de datos recolectan y analizan datos para responder preguntas en distintas áreas. Según UC Berkeley en el artículo "What is Data Science?":

Los científicos de datos efectivos son capaces de identificar preguntas relevantes, recolectar datos de una amplia variedad de fuentes de datos, organizar información, traducir resultados a soluciones y comunicar sus hallazgos de una forma que afecta positivamente las decisiones de negocios.

Texto original en inglés:

Effective data scientists are able to identify relevant questions, collect data from a multitude of different data sources, organize the information, translate results into solutions, and communicate their findings in a way that positively affects business decisions.

Existen muchos lenguajes de programación para analizar y visualizar datos, pero quizás uno de los más usados para este propósito es Python.

Este es un ejemplo de las visualizaciones de datos que puedes crear con Python. Son muy útiles para analizar datos y puedes personalizarlos para que se ajusten a tus necesidades.

Si deseas aprender a programar para ciencia de datos, puedes tomar estos cursos gratuitos en el canal de YouTube de freeCodeCamp:

• Learn Data Science Tutorial - Full Course for Beginners
• Intro to Data Science - Crash Course for Beginners
• Python for Data Science - Course for Beginners (Learn Python, Pandas, NumPy, Matplotlib)
• Build 12 Data Science Apps with Python and Streamlit - Full Course
• Data Analysis with Python - Full Course for Beginners (Numpy, Pandas, Matplotlib, Seaborn)

💡 Dato: también puedes obtener las siguientes certificaciones en freeCodeCamp:

• Visualización de Datos
• Análisis de Datos con Python

Ingeniería

La ingeniería es otro campo en el cual programación te puede ayudar a tener éxito. Ser capaz de escribir tus propios programas de computadora puede lograr que tu trabajo sea mucho más eficiente.

Existen muchas herramientas creadas específicamente para ingenieros. Por ejemplo, el lenguaje de programación R está especializado en aplicaciones estadísticas y Python también es muy popular en este campo.

Otra herramienta genial para programar en ingeniería es MATLAB. De acuerdo a su sitio web oficial:

MATLAB es una plataforma de programación y computación numérica usada por millones de ingenieros y científicos para analizar datos, desarrollar algoritmos y crear modelos.

Texto original en inglés:

MATLAB is a programming and numeric computing platform used by millions of engineers and scientists to analyze data, develop algorithms, and create models.

Las posibilidades son realmente infinitas.

Puedes aprender MATLAB en este curso gratuito en el canal de YouTube de freeCodeCamp.

Si te interesa aprender herramientas de ingeniería relacionadas con programación, este es un curso gratuito en el canal de YouTube de freeCodeCamp sobre AutoCAD, un software de diseño computarizado en 2D y 3D usado por ingenieros.

• AutoCAD for Beginners - Full University Course

Medicina y farmacología

La medicina y la farmacología están evolucionando constantemente al desarrollar nuevos tratamientos y procedimientos. Veamos cómo puedes aplicar tus habilidades de programación en estos campos.

Medicina

La programación está en todas partes. Si te interesa el campo de la medicina, aprender a programar también puede ser muy útil para ti. Incluso si te gustaría enfocarte en ciencias de la computación y desarrollo de software, puedes aplicar tu conocimiento en ambos campos.

Desarrolladores especializados se encargan de desarrollar y escribir el código que permite que los dispositivos usados por la medicina moderna funcionen correctamente.

Piénsalo por un momento... todas estas máquinas y dispositivos están controlados por software y alguien tiene que escribir ese software. Los registros médicos también son almacenados y administrados por sistemas especializados creados por desarrolladores.

Ese podrías ser tú si decides seguir este camino. Suena genial, ¿no?

Según el artículo científico Application of Computer Techniques in Medicine:

Los usos principales de las computadoras en medicina incluyen sistemas informáticos de hospitales, análisis de datos en medicina, computación para imagenología médica, toma de decisiones asistida por computadoras, cuidado de pacientes en estado crítico, terapias asistidas por computadora, entre otros.

Texto original en inglés:

Major uses of computers in medicine include hospital information system, data analysis in medicine, medical imaging laboratory computing, computer assisted medical decision making, care of critically ill patients, computer assisted therapy and so on.

Farmacología

Programación y ciencias de la computación pueden ser aplicadas para desarrollar nuevos medicamentos en el campo de la farmacología.

Este artículo de MIT News presenta un ejemplo asombroso de lo que puedes lograr en este campo aprendiendo a programar. Describe cómo un MIT senior, Kristy Carpenter, usó ciencias de la computación en 2019 para desarrollar "medicamentos nuevos y más económicos." Kristy menciona que:

La inteligencia artificial, la cual puede ayudar a calcular la mejor combinación de compuestos para un medicamento en particular, puede reducir el tiempo de prueba y error e idealmente, puede acelerar el proceso de diseño de nuevos medicamentos.

Texto original en inglés:

Artificial intelligence, which can help compute the combinations of compounds that would be better for a particular drug, can reduce trial-and-error time and ideally quicken the process of designing new medicines.

Otro ejemplo de una aplicación del mundo real de programación en farmacología está relacionada con Python (¡sí, Python tiene muchas aplicaciones!). Entre sus historias de éxito, vemos que Python fue seleccionado por AstraZeneca para desarrollar técnicas y programas que pueden ayudar a los científicos a desarrollar nuevos medicamentos más rápido y más eficientemente.

La documentación de Python menciona que:

Para ahorrar tiempo y dinero en trabajo de laboratorio, los químicos experimentales usan modelos computacionales para reducir el conjunto de buenos candidatos para un medicamento. Además, se verifica que los candidatos a ser evaluados no son simples variaciones de la estructura química básica de otros.

Texto original en inglés:

To save time and money on laboratory work, experimental chemists use computational models to narrow the field of good drug candidates, while also verifying that the candidates to be tested are not simple variations of each other's basic chemical structure.

Si te interesa aprender programación para medicina o campos relacionados con ciencias de la salud, este es un curso gratuito en el canal de YouTube de freeCodeCamp sobre programación para imagenología médica:

• PyTorch and Monai for AI Healthcare Imaging - Python Machine Learning Course

Educación

¿Alguna vez pensaste que la programación podría ser útil para la educación? Bueno, permíteme decirte que sí lo es y que es muy importante. ¿Por qué? Porque las herramientas de aprendizaje digital que los estudiantes y profesores usan hoy en día son programadas por desarrolladores.

Cada vez que un estudiante abre una aplicación educativa, usa una plataforma educativa como freeCodeCamp, escribe en un pizarrón digital o asiste a una clase a través de una plataforma de reuniones en línea, la programación lo está haciendo posible.

Como un programador o como un profesor sabe programar, puedes crear la próxima gran aplicación que mejore la experiencia de aprendizaje de los estudiantes alrededor del mundo.

Quizás será una aplicación para tomar notas, una plataforma de educación en línea, una aplicación de presentaciones, un juego educativo o cualquier otra aplicación que pueda ser útil para los estudiantes.

Lo importante es crearla pensando en los estudiantes si tu meta es crear algo asombroso que cree recuerdos inolvidables.

Si tienes una visión clara de lo que quieres crear, puedes crearlo con código.

Los profesores también pueden enseñarle a sus estudiantes a programar para desarrollar sus habilidades de resolución de problemas y enseñarles habilidades importantes para su futuro.

💡 Dato: si estás enseñandole a tus alumnos a programar, Scratch es un lenguaje de programación genial para enseñar los fundamentos de programación. En particular, está enfocado en enseñarle a los niños cómo programar de forma interactiva.

De acuerdo al sitio web oficial de Scratch:

Scratch es la comunidad más grande de programación para niños del mundo y un lenguaje con una interfaz visual simple que le permite a los jóvenes crear historias digitales, juegos y animaciones.

Texto original en inglés:

Scratch is the world’s largest coding community for children and a coding language with a simple visual interface that allows young people to create digital stories, games, and animations.

Si te interesa aprender a programar con propósitos educativos, puedes tomar estos cursos gratuitos en el canal de YouTube de freeCodeCamp:

• Scratch Tutorial for Beginners - Make a Flappy Bird Game
• Computational Thinking & Scratch - Intro to Computer Science - Harvard's CS50 (2018)
• Android Development for Beginners - Full Course
• Flutter Course for Beginners – 37-hour Cross Platform App Development Tutorial
• Learn Unity - Beginner's Game Development Tutorial

Aprendizaje automático, inteligencia artificial y robótica

Algunos de los campos más asombrosos que están directamente relacionados con programación son el aprendizaje automático (machine learning), inteligencia artificial y robótica. Veamos por qué.

La inteligencia artificial está definida por Britannica como:

El proyecto de desarrollar sistemas dotados de los procesos intelectuales característicos de los humanos, tales como la habilidad de razonar, descubrir significado, generalizar o aprender de experiencia pasada.

Texto original en inglés:

The project of developing systems endowed with the intellectual processes characteristic of humans, such as the ability to reason, discover meaning, generalize, or learn from past experience.

El aprendizaje automático es una rama o subconjunto del campo de la inteligencia artificial en la cual los sistemas pueden aprender por sí mismos en base a datos. La meta de este proceso de aprendizaje es predecir el output esperado. Estos modelos aprenden continuamente cómo "pensar" y cómo analizar situaciones en base a su entrenamiento previo.

Los lenguajes de programación usados más comúnmente en estos campos son Python, C, C#, C++ y MATLAB.

La inteligencia artificial y el aprendizaje automático tienen aplicaciones asombrosas en diversas industrias, tales como:

• Detección de imágenes y objetos.
• Realizar predicciones en base a patrones.
• Reconocimiento de texto.
• Motores de recomendación (como cuando una plataforma de comercio en línea te muestra productos que te pueden gustar o cuando YouTube te muestra videos que te pueden interesar).
• Detección de spam para correos electrónicos.
• Detección de fraudes.
• Funcionalidad de las redes sociales como sugerencias personalizadas.
• Mucho más... existen literalmente millones de aplicaciones en cualquier industria.

Si te interesa aprender a programar para inteligencia artificial y aprendizaje automático, puedes tomar estos cursos gratuitos en el canal de YouTube de freeCodeCamp:

• Machine Learning for Everybody – Full Course
• Machine Learning Course for Beginners
• PyTorch for Deep Learning & Machine Learning – Full Course
• TensorFlow 2.0 Complete Course - Python Neural Networks for Beginners Tutorial
• Self-Driving Car with JavaScript Course – Neural Networks and Machine Learning
• Python TensorFlow for Machine Learning – Neural Network Text Classification Tutorial
• Practical Deep Learning for Coders - Full Course from fast.ai and Jeremy Howard
• Deep Learning Crash Course for Beginners
• Advanced Computer Vision with Python - Full Course

💡 Dato: también puedes obtener una certificación de Aprendizaje Automático con Python en freeCodeCamp.

Robótica

La programación también es muy importante para la robótica. ¡Sí! Los robots también se programan.

La robótica es definida por Britannica como:

El diseño, construcción y uso de máquinas (robots) para realizar tareas que eran realizadas tradicionalmente por seres humanos.

Texto original en inglés:

Design, construction, and use of machines (robots) to perform tasks done traditionally by human beings.

Los robots son como computadoras. No saben qué hacer hasta que les dices qué hacer escribiendo instrucciones en tus programas. Si aprendes a programar, puedes programar robots y maquinaria industrial en instalaciones de manufactura.

Si te interesa aprender programación para robótica, electrónica y campos relacionados, este es un curso gratuito sobre Arduino en el canal de YouTube de freeCodeCamp:

• Arduino Course for Beginners - Open-Source Electronics Platform

Otras aplicaciones

Existen muchas otras aplicaciones fascinantes de programación en cualquier campo que te imagines. Estos son algunos ejemplos:

• Agricultura: en este artículo de MIT News, un granjero aprendió a programar para desarrollar una aplicación para un tractor autónomo.
• Vehículos autónomos: los vehículos autónomos dependen de software que analiza los alrededores para tomar decisiones rápidas y precisas mientras están en movimiento. Si te interesa esta área, este es un curso sobre este tema en el canal de YouTube de freeCodeCamp en español.
• Finanzas: la programación también puede ser útil para desarrollar programas y modelos que predicen indicadores financieros y tendencias en los mercados. Por ejemplo, este es un curso de algorithmic trading en el canal de YouTube de freeCodeCamp.

Las posibilidades son infinitas. Espero que esta sección te dé una noción de por qué aprender a programar es tan importante para tu presente y para tu futuro. Será una habilidad valiosa en cualquier campo de escojas.

Genial. Ahora veamos las habilidades de personalidad (soft skills) que necesitas para tener éxito como programador.

🔹 Habilidades de un programador exitoso

Después de ver una amplia gama de aplicaciones de programación, debes tener curiosidad de las habilidades que necesitas para tener éxito en este campo.

Curiosidad

Un programador debe ser curioso. Independientemente de si estás comenzando a aprender a programar o si ya tienes 20 años de experiencia, los proyectos de programación siempre te presentarán nuevos retos y oportunidades de aprendizaje. Si aprovechas estas oportunidades, estarás mejorando tus habilidades continuamente y podrás tener éxito.

Entusiasmo

El entusiasmo es un rasgo clave de la personalidad de un programador pero esto también se aplica a cualquier campo si quieres tener éxito. El entusiasmo te mantendrá feliz y curioso sobre lo que estás creando y aprendiendo.

💡 Dato: si ya no tienes tanto entusiasmo como antes, es hora de encontrar o aprender algo nuevo que pueda encender la chispa en ti otra vez y llenarte de esperanza y sueños.

Paciencia

Un programador debe ser paciente porque transformar una idea inicial en un producto funcional puede tomar tiempo, esfuerzo y muchos pasos. La paciencia te mantendrá enfocado en la meta final.

Resiliencia

Programar puede ser retador. Eso es verdad. Pero lo que te define no es a cuántos retos te enfrentes, sino cómo los enfrentes. Si prosperas a pesar de estos retos te convertirás en un mejor programador y puedes crear algo que cambie al mundo.

Creatividad

Los programadores deben ser creativos porque aunque cada lenguaje de programación tiene un conjuntos de reglas en particular para escribir el código, programar es como usar LEGOs. Tienes los bloques pero debes decidir qué crear y cómo crearlo. El proceso de escribir el código requiere creatividad combinada con buenas prácticas establecidas para cada tecnología.

Resolución de problemas y análisis

La programación es básicamente analizar y resolver problemas con código. Dependiendo del campo que escojas, esos problemas serán más sencillos o más complejos pero todos requerirán cierto nivel de habilidades de resolución de problemas y un análisis detallado de la situación.

Preguntas como:

• ¿Qué debo desarrollar?
• ¿Cómo puedo desarrollarlo?
• ¿Cuál es la mejor forma de desarrollarlo?

Son parte de la rutina diaria de un programador.

Ser capaz de concentrarse por largos periodos de tiempo

Cuando estás trabajando en un proyecto de programación, deberás enfocarte en una tarea por largos periodos de tiempo. Desde crear el diseño, planificar y escribir el código, probar el resultado y corregir bugs (problemas en el código), dedicarás muchas horas a una tarea en particular. Por eso es esencial poder enfocarse y mantener la meta final en mente.

Tomar notas detalladas

Esta habilidad es muy importante para los programadores, especialmente cuando estás aprendiendo a programar. Tomar notas detalladas puede ayudarte a entender y a recordar los conceptos y las herramientas que aprendes. Esto también aplica para programadores con experiencia, ya que ser programador involucra aprender constantemente.

Comunicación

Inicialmente, puedes pensar que la programación es una actividad solitaria e imaginar que un programador pasa cientos de horas solo sentado en su escritorio.

Pero la realidad es que cuando encuentres tu primer trabajo, verás que la comunicación es super importante para coordinar tareas con otros miembros del equipo y para intercambiar ideas y sugerencias.

Estar abierto a sugerencias

En programación, generalmente hay más de una forma de implementar la misma funcionalidad. Distintas alternativas pueden funcionar de forma similar, pero algunas pueden ser más fáciles de leer o más eficientes en términos de tiempo o uso de recursos.

Cuando aprender a programar, siempre debes estar abierto a la crítica constructiva como una herramienta de aprendizaje. De igual forma, cuando trabajas en un equipo, toma las sugerencias de tus compañeros de forma positiva y siempre intenta mejorar.

Aprendizaje continuo

Escoger el campo de la programación equivale a escoger aprendizaje continuo. Si quieres aprender a programar, debes saber que siempre deberás aprender algo nuevo porque siempre surgen nuevas tecnologías y las tecnologías existentes se actualizan. Piénsalo... ¡Eso es genial porque siempre hay algo nuevo e interesante por aprender!

Estar abierto a cosas nuevas

Finalmente, una habilidad esencial para tener éxito como programador es siempre estar abierto a probar cosas nuevas. Debes salir de tu zona de confort y abrirte a nuevas tecnologías y productos. En la industria de la tecnología las cosas evolucionan muy rápidamente y adaptarse al cambio es esencial.

🔸 Tips para aprender a programar

Ahora que ya sabes más sobre programación, sobre lenguajes de programación y las habilidades que necesitas para ser un programador exitoso, veamos algunos tips (datos) para aprender a programar.

💡 Dato: estos datos están basados en mi experiencia y en mi opinión personal.

• Escoge un lenguaje de programación para aprender inicialmente. Cuando aprendes a programar, es fácil sentirse abrumado por el número de opciones y caminos iniciales. Mi consejo sería primero enfocarse en entender los conceptos básicos de ciencias de la computación y un lenguaje de programación. Python y JavaScript son opciones buenísimas para aprender los fundamentos.
• Toma notas detalladas. La habilidad de tomar notas detalladas es esencial para registrar y analizar los temas que estás aprendiendo. Puedes agregar comentarios personalizados y datos para explicar lo que estás aprendiendo.
• Practica constantemente. Solo puedes mejorar tus habilidades de resolución de problemas practicando y aprendiendo nuevas técnicas y herramientas. Intenta practicar todos los días.

💡 Dato: hay un reto llamado #100DaysOfCode (100 días de código) al cual puedes unirte para practicar cada día.

• Siempre inténtalo otra vez. Si no puedes resolver un problema en tu primer intento, toma un descanso y vuelve una y otra vez hasta que lo resuelvas. Esa es la única forma de aprender. Aprende de tus errores y aprende nuevos enfoques.  
• Aprende cómo investigar y encontrar respuestas. Los lenguajes de programación, las librerías y los frameworks normalmente tienen documentación oficial qué explica sus elementos y cómo usarlos. Este es un recurso muy valioso que definitivamente deberías usar.
• Visita Stack Overflow. Esta es una plataforma asombrosa. Es como una enciclopedia online de respuestas a preguntas comunes de programación. Puedes encontrar respuestas a preguntas que ya han sido publicadas y publicar nuevas preguntas para recibir ayuda de la comunidad.
• Define metas. La motivación es uno de los factores más importantes para el éxito. Definir metas es muy importante para mantenerse enfocado, motivado y con entusiasmo. Una vez que alcances tus metas, define nuevas metas que te parezcan retadoras y emocionantes.
• Crea proyectos. Cuando estás aprendiendo a programar, aplicar tus habilidades te ayudará a expandir tu conocimiento y a recordar mejor las cosas. Crear proyectos es una forma perfecta de practicar y de crear un portafolio que luego puedes mostrar a posibles empleadores.

🔹 Conceptos básicos de programación

Genial. Si leer este artículo te ha ayudado a confirmar que quieres aprender a programar, es hora de que des tus primeros pasos.

Estos son algunos conceptos básicos de programación que deberías conocer:

• Variable: una variable es un nombre que asignamos a un valor en un programa de computadora. Cuando definimos una variable, asignamos un valor a un nombre y reservamos un espacio en la memoria para almacenar ese valor. El valor de una variable puede ser actualizado durante la ejecución del programa.
• Constante: una constante es similar a una variable. Se usa para almacenar un valor pero no puede ser modificado. Una vez que asignas un valor a una constante, no puedes cambiarlo durante todo el programa.
• Condicional: un condicional es una estructura de programación que le permite a los desarrolladores escoger lo que la computadora debería hacer en base a una condición. Si la condición es verdadera, algo ocurrirá pero si es falsa, ocurrirá algo diferente.
• Ciclo: un ciclo es una estructura de programación que nos permite ejecutar un bloque de código (una secuencia de instrucciones) varias veces. Son muy útiles para evitar repetición y para implementar funcionalidad más compleja.
• Función: una función nos ayuda a evitar repetición de código y a reutilizar nuestro código. Es como un bloque de código al cual le asignamos un nombre, pero también tiene características especiales. Podemos escribir el nombre de la función para ejecutar esa secuencia de instrucciones sin escribirlas nuevamente.

💡 Dato: las funciones pueden comunicarse con el programa principal y el programa principal puede comunicarse con las funciones a través de parámetros, argumentos y sentencias return.

• Clase: una clase se usa como un plano de construcción para definir las características y funcionalidad de un tipo de objeto. De esta forma, podemos representar objetos de la vida real en nuestros programas.
• Bug: un bug es un error en la lógica o en la implementación de un programa que resulta en un output inesperado o incorrecto.
• Depuración (debugging): el proceso de debugging es el proceso de encontrar y corregir bugs en un programa.
• IDE: este acrónimo significa Integrated Development Environment (Entorno Integrado de Desarrollo). Es un ambiente creado para desarrollo de software que tiene las herramientas más útiles que necesitas para escribir programas, tales como un editor de archivos, un explorador, un terminal y un menú con opciones útiles.

💡 Dato: un IDE gratuito y comúnmente usado es Visual Studio Code, creado por Microsoft.

Genial. Ahora ya sabes algunos de los conceptos fundamentales de programación. Cada lenguaje de programación tiene una sintaxis diferente pero todos comparten la mayoría de estos conceptos y estructuras.

🔸 Tipos de lenguajes de programación

Los lenguajes de programación pueden ser clasificados en base a distintos criterios. Si quieres aprender a programar, es importante que conozcas estas clasificaciones básicas:

Complejidad

• Lenguajes de programación de alto nivel (High-level programming languages): están diseñados para que los seres humanos entiendan el código y deben ser convertidos a lenguaje de máquina para que las computadoras los puedan entender. Son los lenguajes de programación que usamos comúnmente. Por ejemplo: JavaScript, Python, Java, C#, C++ y Kotlin.
• Lenguajes de programación de bajo nivel (Low-level programming languages): son más difíciles de entender porque no están diseñados para seres humanos. Están diseñados para que las máquinas puedan entenderlos y procesarlos de forma eficiente.

Conversión a código de máquina

• Lenguajes de programación compilados: los programas escritos en este tipo de lenguaje de programación se convierten directamente a código de máquina gracias a un compiler (compilador). Algunos ejemplos son C, C++, Haskell y Go.
• Lenguajes de programación interpretados: los programas escritos en este tipo de lenguaje de programación necesitan otro programa llamado interpreter (intérprete), el cual se encarga de ejecutar el código línea por línea. Algunos ejemplos son Python, JavaScript, PHP y Ruby.

💡 Dato: según este artículo de la publicación de freeCodeCamp:

La mayoría de los lenguajes de programación pueden tener implementaciones compiladas e interpretadas - El lenguaje de programación por sí mismo no es necesariamente compilado o interpretado. Sin embargo, para fines de simplificar este concepto, normalmente nos referimos a ellos de esta forma.

Texto original en inglés:

Most programming languages can have both compiled and interpreted implementations – the language itself is not necessarily compiled or interpreted. However, for simplicity’s sake, they’re typically referred to as such.

Existen otros tipos de lenguajes de programación basados en distintos criterios, tales como:

• Lenguajes de programación procedimentales (Procedural programming languages).
• Lenguajes de programación funcionales (Functional programming languages).
• Lenguajes de programación orientados a objetos (Object-oriented programming languages).
• Lenguajes de programación para scripting (Scripting languages).
• Lenguajes de programación lógicos (Logic programming languages).

Y la lista de tipos de lenguajes de programación continúa. Esto es muy interesante porque puedes analizar las características de un lenguaje de programación para ayudarte a escoger el adecuado para tu proyecto.

🔹 Cómo contribuir a proyectos de código abierto (open source)

Finalmente, quizás pienses que programar implica sentarse en un escritorio durante muchas horas seguidas viendo tu código sin ninguna interacción humana. Pero permíteme decirte que esto no tiene que ser cierto en lo absoluto. Puedes ser parte de una comunidad de aprendizaje o de una comunidad de desarrolladores.

Inicialmente, cuando estás aprendiendo a programar, puedes participar en una comunidad de aprendizaje como freeCodeCamp. De esta forma, podrás compartir tu viaje con otras personas que están aprendiendo a programar, igual que tú.

Luego, cuando tengas suficientes habilidades y confianza en tu conocimiento, puedes practicar contribuyendo a proyectos de código abierto (open source) y unirte a comunidades de desarrolladores.

El software de código abierto (open source) es definido por Opensource.com como:

Software con código fuente que cualquier persona puede inspeccionar, modificar y mejorar.

Texto original en inglés:

Software with source code that anyone can inspect, modify, and enhance.

GitHub es una plataforma online que nos permite albergar proyectos creados con control de versiones. Allí puedes encontrar muchos proyectos open source (como freeCodeCamp), a los cuales puedes contribuir para practicar tus habilidades.

💡 Dato: muchos proyectos open source aceptan colaboración de desarrolladores de distintos niveles de experiencia e incluso primeras colaboraciones en GitHub. Estas son oportunidades excelentes para practicar tus habilidades y contribuir a proyectos reales de programación.

Contribuir a proyectos de código abierto (open source) en GitHub es genial para adquirir nueva experiencia trabajando y comunicándote con otros desarrolladores. Esta es una habilidad muy importante para trabajar en este campo.  

Trabajar en equipo es una experiencia genial. Te lo recomiendo totalmente una vez que te sientas más cómodo con tus habilidades y conocimiento.

¡Lo hiciste! Llegaste al final de este artículo. Muy buen trabajo. Ya sabes qué es programación. Ahora veamos un breve resumen.

🔸 En resumen

• Programar es una habilidad muy importante. Si aprendes a programar, puedes lograr que tu visión se vuelva realidad.
• Programación tiene muchas aplicaciones en campos muy diversos. Puedes encontrar una aplicación de programación en prácticamente cualquier campo que escojas.
• Los lenguajes de programación puedes ser clasificados en base a distintos criterios y comparten conceptos básicos tales como variables, condicionales, ciclos y funciones.
• Siempre define metas que quieras alcanzas y toma notas detalladas. Para tener éxito como programador, debes tener entusiasmo y consistencia.

Muchas gracias por leer mi artículo. Espero que te haya gustado y que te sea de utilidad. Ahora ya sabes por qué deberías aprender a programar.

🔅 Te invito a seguirme en Twitter (@EstefaniaCassN) y YouTube (Coding with Estefania) para encontrar tutoriales de programación.

Los Principios SOLID tienen cinco principios de diseño de clases Orientado a Objetos. Son un conjunto de reglas y mejores prácticas a seguir al diseñar una estructura de clase.

Estos cinco principios nos ayudan a comprender la necesidad de ciertos patrones de diseño y arquitectura de software en general. Así que creo que es un tema que todo desarrollador debería aprender.

Este artículo te enseñará todo lo que necesitas saber para aplicar los principios SOLID a tus proyectos.

Empezaremos echando un vistazo a la historia de este término. Luego vamos a entrar en los detalles esenciales, los por qué y cómo de cada principio, creando un diseño de clase y mejorándolo paso a paso.

¡Así que toma una taza de café, mate o té y empecemos!

Antecedentes

Los principios SOLID fueron introducidos por primera vez por el famoso científico informático Robert J. Martin (también conocido como el tío Bob) en uno de sus artículos en 2000. Pero el acrónimo SOLID fue introducido más tarde por Michael Feathers.

El tío Bob también es el autor de los libros best-sellers Clean Code y Clean Architecture, y es uno de los participantes de la "Alianza Agile".

Por lo tanto, no sorprende que todos estos conceptos de codificación limpia, arquitectura orientada a objetos y patrones de diseño estén de alguna manera conectados y se complementen entre sí.

Todos tienen el mismo propósito:

"Para crear código comprensible, legible y comprobable en el que muchos desarrolladores puedan trabajar en colaboración."

Veamos cada principio uno por uno. Siguiendo el acrónimo inglés SOLID, son:

• El Principio de responsabilidad única (Single Responsibility Principle)
• El Principio Abierto-Cerrado (Open-Closed Principle)
• El Principio de sustitución de Liskov (Liskov Substitution Principle)
• El Principio de segregación de interfaz (Interface Segregation Principle)
• El Principio de inversión de dependencia (Dependency Inversion Principle)

Principio de responsabilidad única

El Principio de Responsabilidad Única dice que una clase debe hacer una cosa y, por lo tanto, debe tener una sola razón para cambiar.

Para enunciar este principio más técnicamente: Solo un cambio potencial (lógica de base de datos, lógica de registro, etc.) en la especificación del software debería poder afectar la especificación de la clase.

Esto significa que si una clase es un contenedor de datos, como una clase Libro o una clase Estudiante, y tiene algunos campos relacionados con esa entidad, debería cambiar solo cuando cambiamos el modelo de datos.

Es importante seguir el principio de responsabilidad única. En primer lugar, debido a que muchos equipos diferentes pueden trabajar en el mismo proyecto y editar la misma clase por diferentes motivos, esto podría dar lugar a módulos incompatibles.

En segundo lugar, facilita el control de versiones. Por ejemplo, digamos que tenemos una clase de persistencia que maneja las operaciones de la base de datos y vemos un cambio en ese archivo en las confirmaciones de GitHub. Al seguir el PRU, sabremos que está relacionado con el almacenamiento o con cosas relacionadas con la base de datos.

Los conflictos de fusión son otro ejemplo. Aparecen cuando diferentes equipos modifican el mismo archivo. Pero si se sigue el PRU, aparecerán menos conflictos: los archivos tendrán una sola razón para cambiar y los conflictos que existen serán más fáciles de resolver.

Trampas comunes y Anti-patrones

En esta sección, veremos algunos errores comunes que violan el Principio de Responsabilidad Única. Luego hablaremos sobre algunas formas de solucionarlos.

Veremos el código de un programa simple de facturación de librería como ejemplo. Comencemos definiendo una clase de libro para usar en nuestra factura.

class Libro {
	String nombre;
	String nombreAutor;
	int anyo;
	int precio;
	String isbn;

	public Libro(String nombre, String nombreAutor, int anyo, int precio, String isbn) {
		this.nombre = nombre;
		this.nombreAutor = nombreAutor;
		this.anyo = anyo;
        this.precio = precio;
		this.isbn = isbn;
	}
}

Esta es una clase de libro simple con algunos campos. Nada sofisticado. No estoy haciendo que los campos sean privados para que no tengamos que lidiar con getters y setters y podamos centrarnos en la lógica.

Ahora vamos a crear la clase de factura que contendrá la lógica para crear la factura y calcular el precio total. Por ahora, suponga que nuestra librería solo vende libros y nada más.

public class Factura {

	private Libro libro;
	private int cantidad;
	private double tasaDescuento;
	private double tasaImpuesto;
	private double total;

	public Factura(Libro libro, int cantidad, double tasaDescuento, double tasaImpuesto) {
		this.libro = libro;
		this.cantidad = cantidad;
		this.tasaDescuento = tasaDescuento;
		this.tasaImpuesto = tasaImpuesto;
		this.total = this.calculaTotal();
	}

	public double calculaTotal() {
	        double precio = ((libro.precio - libro.precio * tasaDescuento) * this.cantidad);

		double precioConImpuestos = precio * (1 + tasaImpuesto);

		return precioConImpuestos;
	}

	public void imprimeFactura() {
            System.out.println(cantidad + "x " + libro.nombre + " " +          libro.precio + "$");
            System.out.println("Tasa de Descuento: " + tasaDescuento);
            System.out.println("Tasa de Impuesto: " + tasaImpuesto);
            System.out.println("Total: " + total);
	}

        public void guardarArchivo(String nombreArchivo) {
	// Crea un archivo con el nombre dado y escribe la factura.
	}

}

Aquí está nuestra clase de Factura. También contiene algunos campos sobre facturación y 3 métodos:

• calculaTotal método que calcula el precio total,
• imprimeFactura método que debería imprimir la factura por consola, y
• guardaArchivo método responsable de escribir la factura en un archivo.

Debe darse un segundo para pensar en lo que está mal con este diseño de clase antes de leer el siguiente párrafo.

Bien, entonces, ¿qué está pasando aquí? Nuestra clase viola el Principio de Responsabilidad Única de múltiples maneras.

La primera violación es el método imprimeFactura, el cual contiene nuestra lógica de impressión. El PRU establece que nuestra clase solo debería tener una única razón para cambiar, y esa razón debería ser un cambio en el cálculo de la factura para nuestra clase.

Pero en esta arquitectura, si queremos cambiar el formato de impresión, necesitaríamos cambiar la clase. Esta es la razón por la que no deberíamos tener lógica de impresión mezclada con lógica de negocios en la misma clase.

Hay otro método que viola el PRU en nuestra clase: el método guardarArchivo. También es un error extremadamente común mezclar la lógica de persistencia con la lógica de negocios.

No piense solo en términos de escribir en un archivo, podría ser guardarlo en una base de datos, hacer una llamada a la API u otras cosas relacionadas con la persistencia.

Entonces, ¿cómo podemos arreglar esta función de impresión?, puede preguntar.

Podemos crear nuevas clases para nuestra lógica de impresión y persistencia, por lo que ya no necesitaremos modificar la clase de factura para esos fines.

Creamos 2 clases, FacturaImpresion y FacturaPersistencia, y movemos los métodos.

public class FacturaImpresion {
    private Factura factura;

    public FacturaImpresion(Factura factura) {
        this.factura = factura;
    }

    public void imprimir() {
        System.out.println(factura.cantidad + "x " + factura.libro.nombre + " " + factura.libro.precio + " $");
        System.out.println("Tasa de Descuento: " + factura.tasaDescuento);
        System.out.println("Tasa de Impuesto: " + factura.tasaImpuesto);
        System.out.println("Total: " + factura.total + " $");
    }
}

public class FacturaPersistencia {
    Factura factura;

    public FacturaPersistencia(Factura factura) {
        this.factura = factura;
    }

    public void guardarArchivo(String nombreArchivo) {
        // Crea un archivo con el nombre dado y escribe la factura.
    }
}

Ahora nuestra estructura de clases obedece al principio de responsabilidad única y cada clase es responsable de un aspecto de nuestra aplicación. ¡Excelente!

Principio de apertura y cierre

El principio de apertura y cierre exige que las clases deban estar abiertas a la extensión y cerradas a la modificación.

Modificación significa cambiar el código de una clase existente y extensión significa agregar una nueva funcionalidad.

Entonces, lo que este principio quiere decir es: Deberíamos poder agregar nuevas funciones sin tocar el código existente para la clase. Esto se debe a que cada vez que modificamos el código existente, corremos el riesgo de crear errores potenciales. Por lo tanto, debemos evitar tocar el código de producción probado y confiable (en su mayoría) si es posible.

Pero, ¿cómo vamos a agregar una nueva funcionalidad sin tocar la clase?, puede preguntarse. Por lo general, se hace con la ayuda de interfaces y clases abstractas.

Ahora que hemos cubierto los conceptos básicos del principio, apliquémoslo a nuestra aplicación Factura.

Digamos que nuestro jefe vino a nosotros y dijo que quiere que las facturas se guarden en una base de datos para que podamos buscarlas fácilmente. Creemos que está bien, esto es fácil jefe, ¡solo dame un segundo!

Creamos la base de datos, nos conectamos a ella y agregamos un método de guardado a nuestra clase FacturaPersistencia:

public class FacturaPersistencia {
    Factura factura;

    public FacturaPersistencia(Factura factura) {
        this.factura = factura;
    }

    public void guardarArchivo(String nombreArchivo) {
        // Crea un archivo con el nombre dado y escribe la factura.
    }

    public void guardarEnBaseDatos() {
        // Guarda la factura en la base de datos
    }
}

Lamentablemente, nosotros, como desarrolladores perezosos de la librería, no diseñamos las clases para que fueran fácilmente ampliables en el futuro. Entonces, para agregar esta función, hemos modificado la clase FacturaPersistencia.

Si nuestro diseño de clase obedeciera al principio Abierto-Cerrado, no necesitaríamos cambiar esta clase.

Entonces, como el desarrollador perezoso pero inteligente de la librería, vemos el problema de diseño y decidimos refactorizar el código para obedecer el principio.

interface FacturaPersistencia {

    public void guardar(Factura factura);
}

Cambiamos el tipo de FacturaPersistencia a Interface y agregamos un método de guardado. Cada clase de persistencia implementará este método de guardado.

public class BaseDeDatosPersistencia implements FacturaPersistencia {

    @Override
    public void guardar(Factura factura) {
        // Guardar en la base de datos
    }
}

public class ArchivoPersistencia implements FacturaPersistencia {

    @Override
    public void guardar(Factura factura) {
        // Guardar en archivo
    }
}

Así que nuestra estructura de clases ahora se ve así:

Ahora nuestra lógica de persistencia es fácilmente extensible. Si nuestro jefe nos pide que agreguemos otra base de datos y tengamos 2 tipos diferentes de bases de datos como MySQL y MongoDB, podemos hacerlo fácilmente.

Puede pensar que podríamos simplemente crear múltiples clases sin una interfaz y agregar un método de guardado para todas ellas.

Pero supongamos que ampliamos nuestra aplicación y tenemos varias clases de persistencia como FacturaPersistencia, LibroPersistencia y creamos una clase AdministradorPersistencia que administra todas las clases de persistencia:

public class AdministradorPersistencia {
    FacturaPersistencia facturaPersistencia;
    LibroPersistencia libroPersistencia;
    
    public AdministradorPersistencia(FacturaPersistencia facturaPersistencia, LibroPersistencia libroPersistencia) {
        this.facturaPersistencia = facturaPersistencia;
        this.libroPersistencia = libroPersistencia;
    }
}

Ahora podemos pasar cualquier clase que implemente la interfaz FacturaPersistencia a esta clase con la ayuda del polimorfismo. Esta es la flexibilidad que proporcionan las interfaces.

Principio de sustitución de Liskov

El Principio de Sustitución de Liskov establece que las subclases deben ser sustituibles por sus clases base.

Esto significa que, dado que la clase B es una subclase de la clase A, deberíamos poder pasar un objeto de la clase B a cualquier método que espere un objeto de la clase A y el método no debería dar ningún resultado extraño en ese caso.

Este es el comportamiento esperado, porque cuando usamos la herencia asumimos que la clase secundaria hereda todo lo que tiene la superclase. La clase secundaria extiende el comportamiento pero nunca lo reduce.

Por lo tanto, cuando una clase no obedece este principio, genera algunos errores desagradables que son difíciles de detectar.

El principio de Liskov es fácil de entender, pero difícil de detectar en el código. Así que veamos un ejemplo.

class Rectangulo {
	protected int ancho, alto;

	public Rectangulo() {
	}

	public Rectangulo(int ancho, int alto) {
		this.ancho = ancho;
		this.alto = alto;
	}

	public int getAncho() {
		return ancho;
	}

	public void setAncho(int ancho) {
		this.ancho = ancho;
	}

	public int getAlto() {
		return alto;
	}

	public void setAlto(int alto) {
		this.alto = alto;
	}

	public int getArea() {
		return ancho * alto;
	}
}

Tenemos una clase Rectángulo simple y una función getArea que devuelve el área del rectángulo.

Ahora decidimos crear otra clase para Cuadrados. Como sabrás, un cuadrado es solo un tipo especial de rectángulo donde el ancho es igual a la altura.

class Cuadrado extends Rectangulo {
	public Cuadrado() {}

	public Cuadrado(int talla) {
		ancho = alto = talla;
	}

	@Override
	public void setAncho(int ancho) {
		super.setAncho(ancho);
		super.setAlto(ancho);
	}

	@Override
	public void setAlto(int alto) {
		super.setAlto(alto);
		super.setAncho(alto);
	}
}

Nuestra clase Cuadrado amplía la clase Rectángulo. Establecemos alto y ancho en el mismo valor en el constructor, pero no queremos que ningún cliente (alguien que use nuestra clase en su código) cambie el alto o el peso de una manera que pueda violar la propiedad cuadrada.

Por lo tanto, anulamos los setters para establecer ambas propiedades cada vez que se cambia una de ellas. Pero al hacerlo acabamos de violar el principio de sustitución de Liskov.

Vamos a crear una clase principal para realizar pruebas en la función getArea.

class Test {

   static void getAreaTest(Rectangulo r) {
      int ancho = r.getAncho();
      r.setAlto(10);
      System.out.println("Area esperada de " + (ancho * 10) + ", tiene " + r.getArea());
   }

   public static void main(String[] args) {
      Rectangulo rc = new Rectangulo(2, 3);
      getAreaTest(rc);

      Rectangulo sq = new Cuadrado();
      sq.setAncho(5);
      getAreaTest(sq);
   }
}

Al probador de su equipo se le ocurrió la función de prueba getAreaTest y le dice que su función getArea no pasa la prueba de objetos cuadrados.

En la primera prueba, creamos un rectángulo donde el ancho es 2 y la altura es 3 y llamamos a getAreaTest. La salida es 20 como se esperaba, pero las cosas salen mal cuando pasamos en la plaza. Esto se debe a que la llamada a la función setAlto en la prueba también establece el ancho y da como resultado un resultado inesperado.

Principio de segregación de interfaces

La segregación significa mantener las cosas separadas, y el Principio de Segregación de Interfaces se trata de separar las interfaces.

El principio establece que muchas interfaces específicas del cliente son mejores que una interfaz de propósito general. No se debe obligar a los clientes a implementar una función que no necesitan.

Este es un principio simple de entender y aplicar, así que veamos un ejemplo.

public interface Estacionamiento {

	void aparcarCoche(); // Reducir el recuento de puntos vacíos en 1
	void sacarCoche(); // Aumenta los espacios vacíos en 1
	void getCapacidad(); // Devuelve la capacidad del coche
	double calcularTarifa(Coche coche); // Devuelve el precio en función del número de horas.
	void hacerPago(Coche coche);
}

class Coche {

}

Modelamos un estacionamiento muy simplificado. Es el tipo de estacionamiento donde pagas una tarifa por hora. Ahora considere que queremos implementar un estacionamiento que sea gratuito.

public class EstacionamientoGratis implements Estacionamiento {

	@Override
	public void aparcarCoche() {
		
	}

	@Override
	public void sacarCoche() {

	}

	@Override
	public void getCapacidad() {

	}

	@Override
	public double calcularTarifa(Coche coche) {
		return 0;
	}

	@Override
	public void hacerPago(Coche coche) {
		throw new Exception("Estacionamiento es gratis");
	}
}

Nuestra interfaz de estacionamiento se componía de 2 cosas: lógica relacionada con el estacionamiento (aparcar coche, sacar automóvil, obtener capacidad) y lógica relacionada con el pago.

Pero es demasiado específico. Debido a eso, nuestra clase EstacionamientoGratis se vio obligada a implementar métodos relacionados con el pago que son irrelevantes. Separemos o segreguemos las interfaces.

Ahora hemos separado el estacionamiento. Con este nuevo modelo, incluso podemos ir más allá y dividir EstacionamientoPagado para admitir diferentes tipos de pago.

Ahora nuestro modelo es mucho más flexible, extensible y los clientes no necesitan implementar ninguna lógica irrelevante porque solo proporcionamos funcionalidad relacionada con el estacionamiento en la interfaz del estacionamiento.

Principio de inversión de dependencia

El principio de inversión de dependencia establece que nuestras clases deben depender de interfaces o clases abstractas en lugar de clases y funciones concretas.

En su artículo (2000), el tío Bob resume este principio de la siguiente manera:

"Si el PAC establece el objetivo de la arquitectura OO, el PID establece el mecanismo principal".

Estos dos principios están realmente relacionados y hemos aplicado este patrón antes mientras discutíamos el Principio Abierto-Cerrado.

Queremos que nuestras clases estén abiertas a la extensión, por lo que hemos reorganizado nuestras dependencias para que dependan de interfaces en lugar de clases concretas. Nuestra clase AdministradorPersistencia depende de FacturaPersistencia en lugar de las clases que implementan esa interfaz.

Conclusión

En este artículo, comenzamos con la historia de los principios SOLID y luego tratamos de adquirir una comprensión clara de los por qué y los cómo de cada principio. Incluso refactorizamos una aplicación de Factura simple para obedecer los principios de SOLID.

Quiero agradecerte por tomarte el tiempo de leer el artículo completo y espero que los conceptos anteriores sean claros.

Sugiero tener en cuenta estos principios al diseñar, escribir y refactorizar su código para que su código sea mucho más limpio, extensible y comprobable.

Si estás interesado en leer más artículos como este, puedes suscribirte a la lista de correo de mi blog para recibir una notificación cuando publique un nuevo artículo.

Muchos principiantes pueden sentirse intimidados cuando están aprendiendo a programar. Pero aprender jugando puede ser divertido y educativo.

De acuerdo a True Education Partnerships,

La gamificación en el aprendizaje implica el uso de elementos basados en el juego, como la puntuación, la competición entre compañeros, el trabajo en equipo y las tablas de puntuación, para impulsar el compromiso, ayudar a los estudiantes a asimilar nueva información y poner a prueba sus conocimientos.

En este blog se puede encontrar más información sobre gamificación en español.

He elaborado una lista de 12 juegos de codificación para principiantes.

Aquí está la lista completa. Una vez que encuentres un sitio web que te interese, haz clic en ese enlace y te llevará a una descripción más detallada de ese sitio web.

1. CodinGame
2. CSS Diner
3. Flexbox Froggy
4. Flexbox Defense
5. Grid Garden
6. CodeCombat
7. Scratch
8. Tynker
9. SQL Murder Mystery
10. Untrusted
11. Elevator Saga
12. CheckiO

CodinGame

CodinGame es un sitio que te ayuda a trabajar en habilidades de resolución de problemas y aprender conceptos básicos de programación a través de un juego por turnos.

Esta plataforma es compatible con más de 25 lenguajes de programación diferentes y brinda a los jugadores la oportunidad de practicar, aprender y competir en concursos de codificación.

Una vez que crees una cuenta, puedes empezar con la sección de orientación de nivel principiante. Se te presentarán los conceptos de programación estándar y resolverás mini-retos.

CSS Diner

En CSS Diner, puedes practicar los conceptos básicos de CSS a través de una serie de 32 desafíos. Esta es una buena manera de familiarizarse con el idioma y divertirse aprendiéndolo.

Los primeros desafíos son cortos y se enfocan en trabajar con clases e ids. Pero a medida que avanza por los niveles, conocerás los pseudo-selectores, el selector first-of-type, el selector last-of-type y el selector universal.

La comunidad ha hecho traducciones en varios idiomas como esta versión en español: Cena CSS.

Flexbox Froggy

En Flexbox Froggy, aprenderá Flexbox CSS colocando las ranas en los nenúfares correctos. Cuando termines el nivel 24, deberías tener la suficiente confianza como para usar Flexbox en tu próximo proyecto.

Cada desafío proporciona una descripción de las propiedades de Flexbox. Los primeros desafíos comienzan con facilidad, pero a medida que avanzas en el juego, las cosas se complican.

Flexbox Defense

Flexbox Defense es un juego de defensa de torres que te ayuda a fortalecer tus habilidades de CSS. Coloca las torres para mantener alejados a tus enemigos usando Flexbox CSS.

Los desafíos te proporcionarán definiciones de las propiedades de Flexbox. Una vez que escribas tu código, presiona el botón Start Wave (Iniciar oleada) y verás si has logrado detener a tus enemigos.

Grid Garden

Aprende CSS Grid pasando por los 28 niveles de Grid Garden. Se recomienda cierto conocimiento previo de CSS Grid, pero no es necesario para empezar con el juego.

Cada desafío proporciona una descripción de las propiedades de CSS Grid. Los primeros desafíos comienzan siendo fáciles, pero a medida que se avanza en el juego las cosas se complican.

CodeCombat

CodeCombat funciona bien tanto para niños como para adultos. Puedes crear una cuenta gratuita y aprender fundamentos de la programación como bucles, funciones, condicionales y variables.

Puedes elegir el lenguaje de programación con el que quieras empezar y trabajar a través de los juegos.

También tienes la opción de pasar a la cuenta premium si te interesa tener acceso a más niveles.

Scratch

Scratch creado por el Instituto de Tecnología de Massachusetts (MIT, por sus siglas en inglés) es un lenguaje de programación basado en bloques en el que puedes aprender sobre eventos, condicionales, variables y más, creando tus propios juegos y animaciones.

Elije entre docenas de sprites (gráficos), sonidos y fondos para codificar tus propias creaciones y comenzar a comprender los conceptos básicos de programación.

Scratch también es el lenguaje utilizado durante la primera semana del curso de Harvard CS50: Introduction to Computer Science (CS50: Introducción a ciencias de la computación).

Tynker

Tynker es un sitio donde puedes construir proyectos y jugar juegos usando HTML, CSS, JavaScript, Python y Java. Tienen una extensa lista de proyectos, algoritmos y desafíos de estructura de datos.

Puedes crear proyectos en el editor en linea y compartir tus creaciones con la comunidad. Este sitio está dirigido a niños y niñas de entre 5 y 18 años.

SQL Murder Mystery

SQL Murder Mystery es ideal tanto para principiantes como para desarrolladores experimentados de SQL. Fortalece tu SQl y tus habilidades de resolución de problemas tratando de rastrear al asesino en esta historia policíaca de misterio.

El juego usa SQLite y  antes de comenzar el juego, tendrás que familiarizarte con la estructura de la base de datos .

Si estás dado tus primeros pasos con SQL, hay un recorrido detallado para principiantes. De lo contrario, si tienes más experiencia con SQL, puedes sumergirse directamente en el juego.

Untrusted

Untrusted es un juego de aventuras en el que puedes poner a prueba tu JavaScript y tus habilidades para resolver problemas. Guía al Dr. Eval a través de una serie de niveles resolviendo desafíos de JavaScript.

Si no tienes mucha experiencia en JavaScript, este juego puede ser un poco avanzado para ti. Pero si has pasado algún tiempo programando en JavaScript, los desafíos son factibles.

Elevator Saga

Elevator Saga es un juego de JavaScript en el que atravesarás una serie de desafíos tratando de transportar personas en ascensores de la manera más eficiente posible dentro del tiempo dado.

Una vez que modifiques el código, puedes probar la eficiencia de tu solución haciendo clic en el botón de Start (Inicio), en la esquina superior derecha. Cuando el programa se está ejecutando, puedes consultar las estadísticas para ver si pasas el desafío o no.

CheckiO

CheckiO es un juego de estrategia en el que puedes aprender TypeScript o Python a través de una serie de desafíos. Una vez que creas una cuenta gratuita, comenzarás con los desafíos para principiantes y te abrirás camino hasta los avanzados.

El juego te dará acceso a sugerencias y soluciones de otros jugadores si necesitas ayuda. Resolverás cada uno de los desafíos en el editor en línea y pasarás a la siguiente misión cuando la tarea esté resuelta.

Cada programa es un conjunto de instrucciones, ya sea sumar dos números o enviar una petición a través de internet. Los compiladores e intérpretes toman código legible por los humanos y lo convierten en código máquina legible por computadoras.

En un lenguaje compilado, la máquina de destino traduce directamente el programa. En un lenguaje interpretado, el código fuente no es directamente traducido por la máquina de destino. En cambio, un distinto programa, mejor conocido como intérprete, lee el código y lo ejecuta.

Okay… ¿Pero qué significa eso realmente?

Imagina que tienes una receta de hummus y la quieres preparar, pero está escrita en griego antiguo. Hay dos maneras en que tú, alguien que no habla griego antiguo, podrías seguir dichas instrucciones.

La primera es si alguien ya lo ha traducido al español para ti. Tú (y cualquiera que hable el idioma) podrías leer la versión en español de la receta y hacer el hummus. Piensa en esta receta traducida como la versión compilada.

La segunda manera es si tienes un amigo que sabe griego antiguo. Cuando estés listo para hacer hummus, tu amigo se sienta junto a ti y traduce la receta al español mientras avanzas, línea por línea. En este caso, tu amigo es el intérprete de la versión interpretada de la receta.

Lenguajes compilados

Los lenguajes compilados son convertidos directamente a código máquina que el procesador puede ejecutar. Como resultado, suelen ser más rápidos y más eficientes al ejecutarse en comparación con los lenguajes interpretados. También le dan al desarrollador más control sobre aspectos del hardware, como la gestión de memoria y el uso del CPU.

Los lenguajes compilados necesitan un paso de compilación (build) - primero necesitan compilarse manualmente. Necesitas "recompilar" el programa cada vez que necesites hacer un cambio. En nuestro ejemplo del hummus, la traducción completa está escrita antes de que la tengas. Si el autor original decide que quiere usar un distinto aceite de oliva, toda la receta necesitaría ser traducida de nuevo y reenviada a ti.

Algunos ejemplos de lenguajes compilados puros son C, C++, Erlang, Haskell, Rust y Go.

Lenguajes interpretados

Estos lenguajes ejecutan línea por línea el programa y a la vez ejecutan cada comando. Aquí, si el autor decide que quiere usar un distinto aceite de oliva, podría borrar el anterior y agregar el nuevo. Tu amigo traductor puede decirte ese cambio a medida que sucede.

Los lenguajes interpretados alguna vez fueron significativamente más lentos que los lenguajes compilados. Pero, con el desarrollo de la compilación justo a tiempo, esa diferencia se está reduciendo.

Ejemplos comunes de lenguajes interpretados son PHP, Ruby, Python y JavaScript.

Una pequeña advertencia

La mayoría de lenguajes de programación pueden tener implementaciones tanto compiladas como interpretadas, el lenguaje en sí mismo no es necesariamente compilado o interpretado. Sin embargo, por cuestiones de simplicidad, normalmente se les conoce de tal manera.

Python, por ejemplo, puede ser ejecutado ya sea como programa compilado o como un lenguaje interpretado en modo interactivo. Por el otro lado, la mayoría de las herramientas de línea de comandos, CLIs y shells pueden ser teóricamente clasificadas como lenguajes interpretados.

Ventajas y desventajas

Ventajas de los lenguajes compilados

Los programas que son compilados a un código máquina nativo suelen ser más rápidos que los lenguajes interpretados. Esto es debido a que el proceso de traducción del código en tiempo de ejecución aumenta la sobrecarga y puede ocasionar que el programa sea más lento en general.

Desventajas de los lenguajes compilados

Las desventajas más notables son:

• Tiempo extra necesario para completar la compilación completa antes de la prueba
• Dependencia de la plataforma del código binario generado

Ventajas de los lenguajes interpretados

Los lenguajes interpretados suelen ser más flexibles, y a menudo ofrecen características como escritura dinámica y tamaño de programa más pequeño. Además, ya que los intérpretes ejecutan el código fuente del programa ellos mismos, el código en sí es independiente de la plataforma.

Desventajas de los lenguajes interpretados

La desventaja más notable es la velocidad de ejecución típica comparada con los lenguajes compilados.

Los programadores usan el operador ternario para tomar decisiones en lugar de sentencias condicionales if y else más largas.

El operador ternario toma tres argumentos:

1. Un argumento de comparación
2. El resultado si esa comparación devuelve true
3. El resultado si esa comparación devuelve false

Es de ayuda pensar en el operador ternario como una forma corta de escribir una sentencia if-else. A continuación un ejemplo simple de toma de decisiones usando if y else:

int a = 10, b = 20, c;

if (a < b) {
    c = a;
}
else {
    c = b;
}

printf("%d", c);

Este ejemplo tiene más de 10 líneas, pero eso no es necesario. El programa puede escribirse en 3 líneas de código usando un operador ternario.

Sintaxis

condición ? valor_true : valor_false

Esta sentencia se evalúa a valor_true si se cumple la condición, y a valor_false en caso contrario.

Este es el ejemplo de arriba usando el operador ternario:

int a = 10, b = 20, c;

c = (a < b) ? a : b;

printf("%d", c);

El output del ejemplo de arriba es:

10

c toma el valor de a, porque se cumplió la condición a < b.

Recordemos que los argumentos de valor_true y valor_false deben tener el mismo tipo, y deben ser expresiones simples en lugar de sentencias completas.

Los operadores ternarios pueden anidarse al igual que las sentencias if-else. Consideremos el siguiente código:

int a = 1, b = 2, ans;
if (a == 1) {
    if (b == 2) {
        ans = 3;
    } else {
        ans = 5;
    }
} else {
    ans = 0;
}
printf ("%d\n", ans);

Este es el código de arriba escrito con operadores ternarios anidados:

int a = 1, b = 2, ans;
ans = (a == 1 ? (b == 2 ? 3 : 5) : 0);
printf ("%d\n", ans);

El output de ambos programas debería ser:

3

Las bases de datos relacionales manejan los datos sin problemas, ya sea trabajando con volúmenes pequeños o procesando millones de filas. Veremos cómo podemos utilizar las bases de datos relacionales de acuerdo con nuestras necesidades y sacarles el máximo partido.

MySQL ha sido una opción popular para empresas grandes y pequeñas debido a su capacidad de escalabilidad. De manera similar, PostgreSQL también ha experimentado un aumento en popularidad.

Según la encuesta de Stack Overflow 2018, MySQL es la base de datos más popular entre todos los usuarios.

Los ejemplos descritos anteriormente utilizan InnoDB como motor de almacenamiento para MySQL. No son solamente relevantes en MySQL sino también en otras bases de datos relacionales como PostgreSQL.  Todas las comparativas se realizan en una computadora con 8GB de RAM y con un procesador i5 a 2.7 GHz.

Comencemos con los conceptos básicos de cómo la base de datos relacional almacena los datos.

Entendiendo las bases de datos relacionales

Almacenamiento

MySQL es una base de datos relacional donde los datos (data) estan representados en tuplas o lista de registros (tuples), agrupadas en relaciones (relations). Un tupla se representa por sus atributos (attributes).

Supongamos que tenemos una aplicación en la que las personas pueden prestar libros. Necesitaremos almacenar todas las transacciones de préstamo de libros. Para almacenarlos, hemos diseñado una tabla relacional simple con el siguiente comando:

> CREATE TABLE libro_transacciones ( id INTEGER NOT NULL   AUTO_INCREMENT, libro_id INTEGER, prestatario_id INTEGER, prestador_id INTEGER, retorno_fecha DATE, PRIMARY KEY (id));

La tabla es:

libro_transacciones
------------------------------------------------
id  prestatario_id  prestador_id  libro_id  retorno_fecha

El id es la clave principal y prestatario_id, prestador_id, libro_id son las claves foráneas. Después de lanzar nuestra aplicación, hay registradas pocas transacciones:

libro_transacciones
----------------------------------------------------------
id  prestatario_id  prestador_id  libro_id  retorno_fecha
----------------------------------------------------------
1                1             1          1    2018-01-13
2                2             3          2    2018-01-13
3                1             2          1    2018-01-13

Obteniendo los datos

Tenemos una página de tablero para cada usuario donde pueden ver las transacciones de sus libros prestados. Busquemos las transacciones de libros para un usuario:

> SELECT * FROM libro_transacciones WHERE prestatario_id = 1;
libro_transacciones
---------------------------------------------------------
id  prestatario_id  prestador_id  libro_id  retorno_fecha
---------------------------------------------------------
1                1             1          1    2018-01-13
2                1             2          1    2018-01-13

Esto escanea la relación secuencialmente y nos da los datos para el usuario. Esto es muy rápido, ya que hay muy pocos datos en la relación. Para ver la hora exacta de ejecución de la consulta, configura profiling a true (verdadero) ejecutando lo siguiente:

> set profiling=1;

Una vez que profiling está configurado, ejecuta la misma consulta nuevamente y luego ejecuta esto para ver el tiempo de ejecución:

> show profiles;

Esto devolverá la duración de la consulta que hemos ejecutado.

Query_ID | Duration   | Query
       1 | 0.00254000 | SELECT * FROM libro_transacciones ...

La ejecución parece muy buena (rápida).

Poco a poco, la tabla libro_transacciones se empieza a llenar de datos, a medida que aumentan las transacciones.

El problema

Esto incrementa el número de tuplas de la relación. Con esto, el tiempo que lleva recuperar las transacciones del libro para el usuario comenzará a tomar más y más tiempo.  MySQL necesita pasar por todas las tuplas para encontrar el resultado.

Para insertar muchos datos en la tabla, he escrito el siguiente procedimiento almacenado:

DELIMITER //
 CREATE PROCEDURE insertarMuchos()
   BEGIN
   DECLARE i INT DEFAULT 1;
   WHILE (i <= 100000) DO
    INSERT INTO libro_transacciones (prestatario_id, prestador_id, libro_id,   retorno_fecha) VALUES ((FLOOR(1 + RAND() * 60)), (FLOOR(1 + RAND() * 60)), (FLOOR(1 + RAND() * 60)), CURDATE());
    SET i = i+1;
   END WHILE;
 END //
 DELIMITER ;
* Ha tardado 7 minutos en insertar 1.5 millines de datos

Esto inserta 100,000 registros aleatorios en la tabla libro_transacciones. Al ejecutar esto, el profiler muestra un ligero aumento en el tiempo de ejecución:

Query_ID | Duration   | Query
       1 | 0.07151000 | SELECT * FROM libro_transacciones ...

Agreguemos algunos datos más ejecutando el procedimiento anterior y veamos qué sucede. Con más y más datos agregados, la duración de la consulta aumenta. Con 1,5 millones de datos insertados en la tabla, ahora el tiempo de respuesta aumenta.

Query_ID | Duration   | Query
       1 | 0.36795200 | SELECT * FROM libro_transacciones ...

Esta es solamente una consulta simple con un valor integer (entero).

Con más consultas compuestas, consultas ordenadas y consultas con recuento, el tiempo de ejecución empeora aún más.

Esto no parece ser mucho tiempo para una consulta, pero cuando tenemos miles o incluso millones de consultas ejecutándose cada minuto, esto hace una gran diferencia.

Habrá mucho más tiempo de espera y esto obstaculizará el rendimiento general de la aplicación. El tiempo de ejecución para la misma consulta aumentó de 2 ms a 370 ms.

Recuperando la velocidad

Index

MySQL, y otras bases de datos proporcionan indexación, una estructura de datos que ayuda a recuperar datos más rápido.

Hay diferentes tipos de indexación en MySQL:

• Clave primaria — Index agregado a la clave primaria. Por defecto, las claves primarias siempre están indexadas. Esto también asegura que las dos filas no tengan el mismo valor de clave principal.
• Unique — El index (índice) de Unique key index asegura que no haya dos filas en una relación que tengan el mismo valor. Se pueden almacenar varios valores nulos con un index de Unique Key .
• Index — Adición a cualquier otro campo que no sea la clave principal.
• Full Text — el index de Full text ayuda a las consultas de datos basados en caracteres.

Hay dos formas principales de almacenar un índice:

Hash — esto se usa principalmente para una coincidencia exacta (=), y no funciona con comparaciones (≥, ≤)

B-Tree — Esta es la forma más común en la que se almacenan los tipos de índices (indexes) mencionados anteriormente.

MySQL utiliza un B-Tree como formato de indexación por defecto. Los datos se almacenan en un árbol binario(binary tree) lo que hace que la recuperación de datos sea rápida.

La organización de datos realizada por el B-tree ayuda a omitir el escaneo completo de la tabla en todas las tuplas de nuestra relación.

Hay un total de 16 nodos en el árbol (B-Tree) anterior. Si necesitamos encontrar el número 6, solamente necesitamos hacer un número total de 3 escaneos para obtenerlo. Esto ayuda a mejorar el rendimiento de la búsqueda.

Para mejorar el rendimiento en libro_transacciones, agreguemos el index en el campo prestador_id.

> CREATE INDEX prestadorId ON libro_transaccciones(prestador_id)
----------------------------------------------------
* Ha tardado unos 6.18sec

El comando anterior agrega un index al campo prestador_id. Veamos cómo esto afecta el rendimiento de los 1,5 millones de datos que tenemos al ejecutar la misma consulta nuevamente.

> SELECT * FROM libro_transacciones WHERE prestador_id = 1;
Query_ID | Duration   | Query
       1 | 0.00787600 | SELECT * FROM libro_transacciones ...

Woohoo! Ya hemos vuelto.

Es tan rápido como cuando solo había 3 registros en nuestra relación. Con el índice (index) correcto agregado, podemos ver una mejora dramática en la duración.

Índice compuesto y único

El índice que hemos agregado es un índice de campo único. Los índices también se pueden agregar a un campo compuesto.

Si nuestra consulta involucrara varios campos, un índice compuesto nos ayudaría. Podemos agregar un índice compuesto de la siguiente forma:

> CREATE INDEX prestadorRetornoFecha ON libro_transacciones(pretador_id, retorno_fecha);

Otro uso para los índices

Las consultas no son para lo único que sirven los índices. Además se puedan usar para la cláusula ORDER BY. Ordenemos los registros en base a prestador_id.

> SELECT * FROM libro_transacciones ORDER BY prestador_id;
1517185 rows in set (4.08 sec)

4.08 sec, ¡es mucho! ¿qué ha pasado? Tenemos el índice. Profundicemos en cómo se ejecuta la consulta con la ayuda de la cláusula EXPLAIN.

Usando Explain

Podemos agregar una cláusula explain para ver cómo se ejecutará la consulta en nuestro conjunto de datos actual.

> EXPLAIN SELECT * FROM libro_transacciones ORDER BY prestador_id;

El resultado es:

Hay varios campos que explican las devoluciones. Veamos la tabla anterior e identifiquemos el problema.

rows (filas): Número total de filas que se analizarán

filtered (filtrado): El porcentaje de fila que se escaneará para obtener los datos.

type (tipo): Se da si se está utilizando el índice. ALL significa que no está usando index.

possible_keys, key, key_len son NULL, lo que significa que no se está utilizando ningún índice.

Entonces, ¿por qué la consulta no usa el índice?

Es porque tenemos select * en la consulta, lo que significa que estamos seleccionando todos los campos de nuestra relación.

El índice solo tiene información sobre los campos que están indexados y no sobre otros campos. Esto significa que MySQL deberá ir a la tabla principal para recuperar datos nuevamente.

Entonces, ¿cómo deberíamos escribir la consulta?

Selecciona solo el campo requerido

Para eliminar la necesidad de ir a la tabla principal para la consulta, necesitamos seleccionar solo el valor que está presente en la tabla de índice. Así que cambiemos la consulta a:

> SELECT prestador_id FROM libro_transacciones ORDER BY prestador_id;

Esto devolverá el resultado en 0,46 segundos, que es mucho más rápido. Pero todavía hay margen de mejora.

Como esta consulta se realiza en todos los 1,5 millones de registros que tenemos, está tomando un poco más de tiempo, ya que necesita cargar datos en la memoria.

Usa Limit

Es posible que no necesitemos todos los 1,5 millones de datos al mismo tiempo. Entonces, en lugar de obtener todos los datos, usar LIMIT y obtener datos en lotes es una manera  mejor de hacerlo.

> SELECT prestador_id
  FROM libro_transacciones
  ORDER BY prestador_id LIMIT 1000;

Con un límite establecido, el tiempo de respuesta mejora drásticamente y se ejecuta en 0,0025 segundos. Ahora podemos buscar el siguiente lote con OFFSET.

> SELECT prestador_id
  FROM libro_transacciones
  ORDER BY prestador_id LIMIT 1000 OFFSET 1000;

Esto buscará el siguiente lote de 1000 filas. Con esto podemos aumentar el desplazamiento y el límite para obtener todos los datos. ¡Pero hay un "te pillé"! Con un aumento en la compensación, el rendimiento de la consulta disminuye.

Esto se debe a que MySQL escaneará todos los datos para alcanzar el punto de compensación. Por lo tanto, es mejor no utilizar un desplazamiento más alto.

¿Qué pasa con la consulta Count (recuento)?

El motor InnoDB tiene la capacidad de escribir simultáneamente. Esto lo hace altamente escalable y mejora el rendimiento por segundo.

Pero esto tiene un precio. InnoDB no puede agregar un contador de caché para el número de registros en ninguna tabla. Por lo tanto, el recuento debe realizarse en tiempo real escaneando todos los datos filtrados. Esto hace que la consulta COUNT sea lenta.

Por lo tanto, se recomienda calcular los datos de recuento resumidos en la lógica de la aplicación cuando se trata de una gran cantidad de datos.

¿Por qué no agregar un índice a todos los campos?

Agregar índice ayuda a mejorar mucho el rendimiento, pero también tiene un precio. Debe utilizarse de forma eficaz. Agregar un índice a más campos tiene los siguientes problemas:

• Necesita mucha memoria, una computadora más grande
• Cuando eliminamos, hay una reindexación (eliminaciones intensivas de CPU y más lentas)
• Cuando agregamos algo, hay reindexación (inserciones intensivas de CPU y más lentas)
• Los cambios a un registro no reindexan por completo, por lo que la actualización es más rápida y eficiente en la CPU.

Ahora tenemos claro que agregar un índice ayuda mucho. Pero no podemos seleccionar todos los datos, excepto los que están indexados para un rendimiento rápido.

¿cómo podemos seleccionar todos los atributos y seguir obteniendo un rendimiento rápido?

Particionamiento (partitioning)

Cuando creamos índices, solamente tenemos información sobre el campo que está indexado. Pero no tenemos datos de los campos que no están presentes en el índice.

Entonces, como dijimos anteriormente, MySQL necesita mirar hacia atrás en la tabla principal para obtener los datos de otros campos. Esto puede ralentizar el tiempo de ejecución.

La forma en que podemos resolver esto es mediante particiones.

El particionamiento es una técnica en la que MySQL divide los datos de una tabla en varias tablas, pero los administra como una sola tabla.

Al realizar cualquier tipo de operación en la tabla, necesitamos especificar qué partición se está utilizando. Con los datos desglosados, MySQL tiene un conjunto de datos más pequeño para consultar. Determinar la partición correcta de acuerdo con las necesidades es clave para un alto rendimiento.

Pero si seguimos usando la misma máquina, ¿escalará?

Fragmentación (Sharding)

Con un gran conjunto de datos, almacenar todos sus datos en la misma máquina puede resultar problemático.

Una partición específica puede ser muy grande y necesitar más consultas, mientras que otras menos. Entonces uno afectará a otro. No pueden escalarse por separado.

Supongamos que los datos de los últimos tres meses son los más utilizados, mientras que los más antiguos se utilizan menos. Quizás los datos recientes en su mayoría se actualizan / crean, mientras que los datos antiguos en su mayoría solo se leen.

Para resolver este problema, podemos mover la partición de los últimos tres meses a otra máquina. La fragmentación es una forma en la que dividimos un gran conjunto de datos en fragmentos más pequeños y lo pasamos a RDBMS separados. En otras palabras, la fragmentación también se puede llamar "partición horizontal".

Las bases de datos relacionales tienen la capacidad de escalar a medida que crece la aplicación. Es necesario encontrar el índice correcto y ajustar la infraestructura según las necesidades.

Cuando se trata del ancho y el alto de la página ¿Sabes qué configurar del elemento html? ¿Y del elemento body? ¿Simplemente colocas los estilos en ambos elementos y esperas lo mejor? Si lo haces, no estás solo.

Las respuestas a esas preguntas no son intuitivas, Soy culpable de aplicar estilos a ambos elementos en el pasado sin considerar exactamente cuál propiedad debe ser aplicada a qué elemento ?‍. No es raro ver las propiedades CSS aplicadas tanto al elemento html como al elemento body de la siguiente manera:

html, body {
     min-height: 100%;
}

¿Acaso importa?

Si, si importa.

La definición de estilos anterior crea un problema:

Establece la altura mínima al 100% en ambos elementos, y esto no permite que el bodyllene la página como se esperaría. Cuando verificamos los estilos en las herramientas del desarrollador, el body tiene una altura cero. Mientras tanto, el elemento html tiene una altura igual a la parte visible de la página del navegador.

Miremos la siguiente captura de pantalla de herramientas del desarrollador de Chrome:

El body tiene por defecto un margen de 8px indicado por la barra en la parte superior, pero la altura tiene de valor 0.

¿Por qué esto ocurre?

El uso de un porcentaje como tamaño necesita usar como referencia el elemento padre en el que basar el porcentaje. El elemento html hace referencia a la ventana gráfica que tiene un valor de altura igual a la altura de la ventana gráfica visible. Sin embargo, nosotros solo establecemos el min-value del elemento html... NO un valor a la propiedad height. Por lo tanto, el elemento bodyno tiene un elemento padre al que hacer referencia cuando establece la propiedad igual al 100%.

El problema puede estar oculto

Si comenzamos con suficiente contenido para el cuerpo de la página web, es posible que no notemos el problema. Y para hacerlo más difícil de observar, si establecemos background-color en ambos elementos o incluso en uno solo de ellos, la ventana gráfica estará llena de ese color. Esto da la impresión que el elemento body es tan grande como la ventana gráfica. Pero no, todavía está en cero.

La imagen anterior fue tomada de una página con el siguiente CSS:

html, body {
    min-height: 100%;
}
body { background-color: dodgerblue; }

¿Herencia inversa?

En un giro extraño, el elemento htmlasume el background-colordel elemento bodysi no se establece un background-color separado para el elemento html.

Entonces, ¿cuál es la configuración de altura ideal para una página full responsive?

Por años, la respuesta fue la siguiente:

html {
    height: 100%;
}
body {
    min-height: 100%;
}

Esto permite al elemento html hacer referencia a la ventana gráfica y tenga un valor de altura igual al 100%. Con el elemento html recibiendo un valor de altura, el min-height asignado al elemento body le da una altura inicial que coincide con el elemento html. Esto también permite que el bodycrezca más alto si el contenido supera el tamaño de lo visible de la página.

El único inconveniente es que el elemento html no crezca más allá de la altura de la ventana gráfica visible. Sin embargo, se ha permitido que el elemento bodysupere el elemento html.

La solución actual está simplificada

body { min-height: 100vh; }

En este ejemplo usamos como unidad vh(altura de la ventana gráfica) para permitir que el body establezca una altura mínima basada en la altura completa de la ventana gráfica.

Al igual que la discusión anterior de background-color, si nosotros no seteamos el valor de la altura máxima del elemento html, asumirá el mismo valor de la altura del elemento body.

Por lo tanto, esta solución evita el desbordamiento del elemento htmlpresente en la solución anterior y ambos elementos crecen con su contenido.

El uso de la unidad vh causó algunos problemas con el navegador móvil en el pasado, pero parece que Chrome y Safary son consistentes con las unidades de visualización ahora.

Tamaño de página puede causar un scroll horizontal

Espera... ¿qué? ¿No debería decir "Ancho de página?
¡No!

En otra extraña serie de eventos, la altura de tu página puede activar el scroll horizontal en tu navegador. Cuando el contenido de tu página web es más alto que la altura de la ventana gráfica, se activa la barra del scroll vertical a la derecha. Esto puede causar que tu página tenga instantáneamente una barra de scroll horizontal.

¿Cómo podemos solucionar esté problema?

Podemos dormir mejor sabiendo que comenzamos con una configuración del ancho de la página. Este problema surge cuando cualquier elemento, no solo los elementos html o body- se establecen con 100vw (ancho de la ventana gráfica).

Las unidades de la ventana gráfica no tienen en cuenta los 10 píxeles aproximados que ocupa la barra de desplazamiento vertical. Por lo tanto, cuando se activa la barra de desplazamiento vertical, también se obtiene una barra de desplazamiento horizontal.

¿Cómo configuramos la página para el tamaño completo?

Si no establecemos un ancho en los elementos htmly body, el tamaño predeterminado de la pantalla será el tamaño completo de la pantalla. Si establecemos un valor de ancho que no sea automático, consideremos restablecer primero el CSS. Recordemos, por defecto el elemento bodytiene 8 píxeles de margen en todos los lados.

Reestablecer el CSS elimina esto. De lo contrario, establecer el ancho al 100% antes de eliminar los márgenes hará que el elemento del body desborde. Aquí está el restablecimiento de CSS que uso:

* { 
    margin: 0;
    padding: 0;
    box-sizing: border-box;
}

¿Cómo establecemos el ancho de nuestra preferencia?

Si bien puede que no siempre sea necesario establecer un ancho, generalmente lo hago. Puede ser simplemente un hábito.

Si establecemos el ancho al 100% en el elemento body, tendrá un ancho de página completo. Esto es equivalente a no establecer un valor de ancho y permitir el valor predeterminado.

Si deseamos utilizar el elemento del body como un contenedor más pequeño y dejar que el elemento HTML llene la página, podemos establecer un valor de ancho máximo en el body.

Aquí un ejemplo:

html { background-color: #000; } 
body {
    min-height: 100vh;
    max-width: 400px;
    background-color: papayawhip; 
    margin: 0 auto;
}

Conclusión

Sin una altura proporcionada para el elemento html, establecer height y/o min-height del elemento body no da como resultado la altura (antes de agregar el contenido). Sin embargo, sin un ancho para el elemento html, establecer el ancho del elemento body en 100% da como resultado el ancho de la página completa. Esto puede parecer contra intuitivo y confuso.

Para una página responsive, establezca el min-height del elemento body en 100vh. Si estableces el ancho de página, elije el 100% sobre 100vw para evitar el scroll horizontal.

Les dejo un tutorial de mi canal de YouTube demostrando como configurar el ancho y el alto para una página web que crece con el contenido que contiene:

HTML Page Width and Height Settings | CSS Full Screen Size

¿Tienes una manera diferente de establecer el ancho y el alto que te guste más?

¡Dejame saber tu método!

Traduccion del articulo - HTML vs Body: How to Set Width and Height for Full Page Size por Dave Gray

Herramientas como Travis CI y Netlify ofrecen algunas características bastante ingeniosas, como el despliegue sin problemas de tu sitio de GitHub Pages cuando los cambios son empujados a su repositorio. Junto con un generador de sitios estáticos como Hugo, el mantenimiento de un blog al día es bastante sencillo.

He utilizado Hugo para construir mi sitio durante años, pero hasta esta semana pasada nunca había conectado mi repositorio de Pages a ningún servicio de despliegue. ¿Por qué? Porque usar una herramienta que construya mi sitio antes de desplegarlo parecía requerir tener toda la receta en un solo lugar - y si estás usando GitHub Pages con la versión gratuita de GitHub, ese lugar es público. Eso significa que todas mis ideas brillantes de las tres de la mañana y los borradores desordenados sin terminar (y sin gracia) estarían disponibles públicamente - y ninguna conveniencia profunda iba a convencerme de hacer eso.

Así que mantuve las cosas separadas, con el desorden de Hugo detrás la escena en un repositorio Git local, y la carpeta generada public/ empujando a mi repositorio remoto GitHub Pages. Cada vez que quería desplegar mi sitio, tenía que ir a mi portátil y a Hugo para construir mi sitio, luego cd public/ && git add . && git commit... etc etc. Y todo estaba bien, excepto por la persistente sensación de que había una mejor manera de hacer esto.

Hace poco escribí otro artículo sobre el uso de GitHub y Working Copy para hacer cambios en mis repositorios en mi iPad cuando estoy fuera de casa. Me parecía que no podía hacer todo excepto desplegar mi sitio desde mi iPad, así que me propuse cambiar eso.

Un par de ideas brillantes a las tres de la mañana y un token de acceso revocado (oops), ahora tengo no una, sino dos maneras de desplegar a mi repositorio público de GitHub Pages desde un repositorio de GitHub completamente separado y privado. En este post, te mostraré cómo lograr esto con Travis CI o usando Netlify y Make.

No hay nada de hacking en ello: mi repositorio público de GitHub Pages sigue teniendo el mismo aspecto que cuando lo empujo localmente desde mi terminal. Sólo que ahora puedo aprovechar un par de grandes herramientas de despliegue para que el sitio se actualice cada vez que empujo a mi repositorio privado, ya sea que esté en mi computadora portátil o fuera de casa con mi iPad.

Este artículo asume que tienes conocimientos de Git y GitHub Pages. Si no es así, es posible que quieras abrir algunas páginas de mis artículos sobre el uso de GitHub y Working Copy y la construcción de un sitio con Hugo y GitHub Pages primero.

¡Vamos a hacerlo!

Despliegue de GitHub Pages de privado a público con Travis CI

Travis CI tiene la capacidad incorporada (♪) para desplegar a GitHub Pages después de una compilación exitosa. Estos hacen un trabajo decente en la documentación explicando cómo añadir esta funcionalidad, especialmente si has usado Travis CI antes... lo que yo no he hecho. No te preocupes, he realizado la mayor parte de las cosas por ti.

• Travis CI obtiene todas sus instrucciones de un archivo de configuración en la raíz de tu repositorio llamado .travis.yml
• Necesitas proporcionar un token de acceso personal de GitHub como una variable encriptada segura, que puedes generar usando travis en la línea de comandos
• Una vez que tu script termine de hacer con éxito lo que le has dicho que haga (no necesariamente lo que quieres que haga, pero eso es otra entrada del blog), Travis desplegará tu directorio de compilación en un repositorio que puedes especificar con la variable de configuración repo.

Preparación del archivo de configuración de Travis

Cree un nuevo archivo de configuración para Travis con el nombre de archivo .travis.yml (tenga en cuenta el "." inicial). Estos scripts son muy personalizables y me costó encontrar un ejemplo relevante para usar como punto de partida - ¡por suerte, no tienes ese problema!

Aquí está mi .travis.yml básico::

git:
 depth: false

env:
 global:
 - HUGO_VERSION="0.54.0"
 matrix:
 - YOUR_ENCRYPTED_VARIABLE

install:
 - wget -q https://github.com/gohugoio/hugo/releases/download/v${HUGO_VERSION}/hugo_${HUGO_VERSION}_Linux-64bit.tar.gz
 - tar xf hugo_${HUGO_VERSION}_Linux-64bit.tar.gz
 - mv hugo ~/bin/

script:
 - hugo --gc --minify

deploy:
 provider: pages
 skip-cleanup: true
 github-token: $GITHUB_TOKEN
 keep-history: true
 local-dir: public
 repo: gh-username/gh-username.github.io
 target-branch: master
 verbose: true
 on:
 branch: master

Este script descarga e instala Hugo, construye el sitio con el garbage collection y las instrucciones de minimificación, y luego despliega el directorio public/ en el repo especificado - en este ejemplo, tu repositorio público de GitHub Pages. Puedes leer sobre cada una de las opciones de configuración de deploy aquí.

Para añadir el token de acceso personal de GitHub como una variable encriptada, no necesitas editar manualmente tu .travis.yml. Los comandos de la gema travis que aparecen a continuación cifrarán y añadirán la variable por ti cuando los ejecutes en el directorio de tu repositorio.

Primero, instala travis con sudo gem install travis.

A continuación, genera tu token de acceso personal de GitHub, cópialo (¡sólo aparece una vez!) y ejecuta los siguientes comandos en la raíz de tu repositorio, sustituyendo los asteriscos por tu token:

travis login --pro --github-token xxxxxxxxxxxxxxxxxxxxxxxxxxx
travis encrypt GITHUB_TOKEN=xxxxxxxxxxxxxxxxxxxxxxxxxxx --add env.matrix

Tu token encriptado aparece mágicamente en el archivo. Una vez que hayas incluido el archivo .travis.yml en tu repositorio privado de Hugo, Travis CI ejecutará el script y, si la compilación tiene éxito, desplegará tu sitio en tu repositorio público de GitHub Pages. ¡Magia!

Travis siempre ejecutará una compilación cada vez que empuje a su repositorio privado. Si no quiere desencadenar este comportamiento con un commit en particular, añada el comando skip a su mensaje de commit.

Oye, eso es genial, pero me gusta Netlify.

Está bien.

Desplegar a un repositorio distinto con Netlify y Make

Podemos hacer que Netlify haga nuestro trabajo utilizando un Makefile, que ejecutaremos con el comando de compilación de Netlify.

Este es el aspecto de nuestro Makefile:

SHELL:=/bin/bash
BASEDIR=$(CURDIR)
OUTPUTDIR=public
.PHONY: all
all: clean get_repository build deploy
.PHONY: clean
clean:
@echo "Removing public directory"
rm -rf $(BASEDIR)/$(OUTPUTDIR)
.PHONY: get_repository
get_repository:
@echo "Getting public repository"
git clone https://github.com/gh-username/gh-username.github.io.git public
.PHONY: build
build:
@echo "Generating site"
hugo --gc --minify
.PHONY: deploy
deploy:
@echo "Preparing commit"
@cd $(OUTPUTDIR) \
 && git config user.email "you@youremail.com" \
 && git config user.name "Your Name" \
 && git add . \
 && git status \
 && git commit -m "Deploy via Makefile" \
 && git push -f -q https://$(GITHUB_TOKEN)@github.com/gh-username/gh-username.github.io.git master
@echo "Pushed to remote"

Para preservar el historial Git de nuestro repositorio separado de GitHub Pages, primero lo clonaremos, construiremos nuestro nuevo sitio Hugo en él, y luego lo empujaremos de nuevo al repositorio de Pages. Este script primero elimina cualquier carpeta public/ existente que pueda contener archivos o un historial Git. Luego clona nuestro repositorio de Pages a public/, construye nuestro sitio Hugo (esencialmente actualizando los archivos en public/), y luego se encarga de confirmar el nuevo sitio al repositorio de Pages.

En la sección de deploy (despliegue), verás que hay líneas que empiezan por &&. Estos son comandos encadenados. Dado que Make invoca un nuevo sub-shell para cada línea, comienza de nuevo con cada nueva línea de nuestro directorio raíz. Para conseguir que nuestro cd se mantenga y evitar la ejecución de nuestros comandos Git en el directorio raíz del proyecto, estamos encadenando los comandos y utilizando el carácter de barra invertida para romper las líneas largas para la legibilidad.

Encadenando nuestros comandos, somos capaces de configurar nuestra identidad Git, añadir todos nuestros archivos actualizados, y crear un commit para nuestro repositorio Pages.

Al igual que con Travis CI, tendremos que pasar un token de acceso personal de GitHub para empujar a nuestro repositorio público de GitHub Pages - sólo que Netlify no proporciona una forma directa de cifrar el token en nuestro Makefile.

En su lugar, utilizaremos las variables de entorno de construcción de Netlify, que viven de forma segura en la configuración de nuestro sitio en la aplicación Netlify. Podemos entonces llamar a nuestra variable token en el Makefile. Lo usamos para empujar (silenciosamente, para evitar imprimir el token en los registros) a nuestro repositorio de Pages pasándolo en la URL remota.

Para evitar la impresión del token en los registros de Netlify, suprimimos la impresión de la receta para esa línea con el carácter @ inicial.

Con tu Makefile en la raíz de tu repositorio privado de GitHub, puedes configurar Netlify para que lo ejecute por ti.

Configuración de Netlify

La configuración de Netlify a través de la interfaz web es sencilla. Una vez que te registres en GitHub, elige el repositorio privado de GitHub donde vive tu sitio Hugo. La siguiente página a la que te lleva Netlify te permite introducir los ajustes de despliegue:

Puedes especificar el comando de construcción que ejecutará tu Makefile (make all para este ejemplo). La rama a desplegar y el directorio de publicación no importan demasiado en nuestro caso específico, ya que sólo nos preocupa empujar a un repositorio separado. Puede introducir la típica rama master de despliegue y el directorio public de publicación.

En "Advanced build settings" haz clic en "New variable" para añadir tu token de acceso personal de GitHub como una variable de entorno de construcción. En nuestro ejemplo, el nombre de la variable es GITHUB_TOKEN. Haz clic en "Deploy site" para que se produzca la magia.

Si ya has configurado previamente tu repositorio con Netlify, encuentra la configuración para el Despliegue Continuo en Settings > Build & deploy.

Netlify compilará su sitio cada vez que empuje al repositorio privado. Si no quiere que una confirmación en particular active una compilación, añada [skip ci] en su mensaje de confirmación Git.

Lo mismo pero diferente

Uno de los efectos de usar Netlify de esta manera es que tu sitio se construirá en dos lugares: uno es el repositorio público de GitHub Pages al que el Makefile empuja, y el otro es tu sitio de Netlify que se despliega en su CDN desde tu repositorio privado de GitHub vinculado. Esto último es útil si vas a jugar con Deploy Previews y otras características de Netlify, pero eso está fuera del alcance de este post.

Salir y desplegar sin miedo

Espero que el efecto de esta nueva información sea que te sientas más capaz de actualizar tus sitios, estés donde estés. Las posibilidades son infinitas: en casa, en el sofá, con el portátil, en un café con el iPad o en medio de una primera cita con el teléfono. No hay límites.

Traducido del artículo Two ways to deploy a public GitHub Pages site from a private Hugo repository de Victoria Drake

¿Quieres omitir el "qué" y el "por qué"? ¡Salta directo al "cómo"!

El impacto de las imágenes en las redes sociales

Cualquier feed de red social es una ráfaga de contenido que puede ser difícil de digerir por completo. A medida que deslizas o te desplazas a través de los feeds, te encontrarás con contenido basado en texto y otros diferentes medios.

¡Y esto es por una buena razón! Al analizar el ejemplo anterior, ¿qué se destaca? No el retweet sobre Dust Particle de CodePen a la izquierda, sino el de AWS en el medio, la nariz de perro en la parte superior izquierda y Al Pacino en la parte superior derecha entre las otras publicaciones mediáticas grandes.

Las imágenes, los gifs y los videos son una buena forma de proporcionar contenido llamativo. Como beneficio adicional, por lo general ocupan mucho más espacio en el feed, por lo que es aún más probable que tengas la oportunidad de verlo.

Lo mínimo en GitHub

Al compartir tus proyectos de GitHub en las redes sociales, la opción predeterminada es bastante insulsa. Toma este tweet como ejemplo:

GitHub nos brinda una simple tarjeta de redes sociales que consta de nuestro avatar de GitHub, la ruta de nuestro proyecto y una breve descripción de la parte superior de la página.

Ahora, es genial que al menos muestren una tarjeta, y para ser justos, ¿Que más podrían mostrar?. Pero este tweet se saltará con bastante facilidad en los feeds de las personas entre las imágenes más grandes y llamativas.

Imágenes de red social en GitHub

Afortunadamente, GitHub nos provee una forma fácil de agregar una imagen a cada repositorio que puede ayudar a que el contenido que compartamos funcione de mejor manera.

Con un poco de creatividad, podemos subir una imagen que aprovechará el espacio en los feeds de las personas y conseguirá que tu trabajo reciba la atención que se merece.

Antes de entrar en detalle, debes saber que para cambiar la imagen del repositorio es necesario tener el acceso adecuado a la configuración del mismo. Si creaste el repositorio, lo más probable es que tengas este acceso.

Buscar o crear una imagen

Antes de cargar una imagen, necesitamos una imagen en primer lugar. Puedes escoger una de estas dos alternativas: buscar una imagen o crear una nueva.

Si escoges la alternativa simple, puedes buscar imágenes gratuitas para usar, son bastante fáciles de encontrar en la web. Uno de mis sitios favoritos es Unsplash, ya que normalmente encontrarás imágenes de alta calidad, pero hay un montón de otras que puedes encontrar con una simple búsqueda. Sin embargo, agregar fotos suele ser mejor para publicaciones de blog y publicaciones basadas en contenido.

La mejor alternativa es crear la tuya propia. Una ventaja de crear una imagen es que puedes personalizarla con un texto más grande para captar más atención en el feed.

Hay un montón de herramientas gratuitas disponibles que te permiten crear una imagen comenzando con una plantilla específica para redes sociales, por lo que no necesitas gastar dinero en Photoshop para lograrlo.

El único requisito para tu imagen es que su tamaño debe ser de al menos 640×320px. De ser posible, céntrate en obtener al menos 1280×640px para asegurarte de que la imagen se muestre en alta resolución en los feeds.

Agregar una imagen a tu repositorio de Github

Una vez que tenemos nuestra imagen, solo nos queda agregarla a nuestro repositorio, que posiblemente sea la parte más simple.

Primero, navega a la configuración (settings) de tu repositorio usando la pestaña de navegación en la parte superior de la página. Como recordatorio, debes poder modificar la configuración para cambiar la imagen.

A continuación, desplaza hacia abajo hasta la sección vista previa Social (Social preview), donde si actualmente no tienes ninguna imagen, encontrarás un gran rectángulo vacío con el botón Edit (Editar) en la esquina inferior izquierda.

Has clic en el botón Edit (Editar), selecciona Upload an image (Cargar una imagen), luego busca la imagen en tu ordenador y selecciona el archivo.

Una vez seleccionado, el archivo de imagen se cargará en GitHub y se establecerá como imagen social del repositorio.

Pre-visualizar tu nueva imagen

Cuando hayas terminado de cargar tu imagen, puedes dirigirte a tu plataforma social favorita y probarla. Por ejemplo, al publicar en Twitter, se mostrará una bonita y grande imagen en lugar de tu pequeño avatar de GitHub.

Como puedes ver, este tweet maximiza el espacio disponible y hace entender de qué se trata el proyecto.

Algunos consejos al crear imágenes

Texto grande y sencillo

Puede ser fácil quedarse atrapado sobre-diseñando un gráfico en exceso o no prestar suficiente atención al tamaño de la fuente. Asegúrate de usar letras grandes con una fuente que sea fácil de leer, de modo que cuando alguien se desplace sobre tu publicación, pueda entenderla y no simplemente omitirla.

Agregar un logo

¿Tienes un logo para tu proyecto? ¿O es un complemento para una herramienta específica? ¡Intenta agregar un logotipo para dar contexto de inmediato sobre el tema del proyecto!

Maximizar la resolución

A nadie le gusta mirar imágenes de mala calidad. Aprovecha todos esos valiosos píxeles y carga una imagen que se traduzca con alta calidad en cualquier feed. GitHub recomienda particularmente un tamaño de imagen de al menos 1280×640px.

¿Tienes otros trucos para maximizar el intercambio en las redes sociales?

¡Comparte tus consejos favoritos conmigo en Twitter !

• ? Sigueme en Twitter
• ? ️ Suscríbete a mi Youtube
• ✉️ Suscríbete a mi boletín

Traducido del artículo de Colby Fayock - How to Add a Social Media Image to Your Github Project Repository.