Pleonasmos booleanos

A veces es bueno escribir más código del necesario para que sea fácil de leer. Para que la persona que le de mantenimiento pueda entender de forma clara y rápida lo que hace el código. Esa persona en el futuro puedes ser tú mismo. Hay otras veces que el código redúndate no ayuda, al contrario es ruido que no dejar ver lo que realmente está pasando. Puede esconder bugs difícil de ver a simple vista.

Al escribir código debemos tomar en cuenta que no solo escribimos para la maquina. A la computadora no el importa como escribamos las cosas, para ella es lo mismo el nombre de las variables, el estilo de programación, el lenguaje, paradigma, etc. El código fuente que escribimos debemos pensar que es para las personas que van a leerlo. Escribimos para personas, no para maquinas. Por lo tanto debemos de ser claros con lo que tratamos de expresar en el código. Tampoco es una novela a la que le debemos dar suspenso o drama. Deben ser una serie de instrucciones concretas sin palabras de más.

Los pleonasmos en el código son esas palabras que no es necesario escribir, que están de más. He visto que pasa con los booleanos.

Tomemos por ejemplo algo en JavasScript: supongamos que tenemos un formulario en una página web y necesitamos que el usuario verifique una casilla antes de continuar (¿suena raro eso en español? el usuario necesitar hacer check en un checkbox).

var approveCheckbox = document.GetElementById("approve");
var continueButton = document.GetElementById("continue");

if (approveCheckbox.checked == true)
  continueButton.disabled = false;
else
  continueButton.disabled = true;

El fragmento de código tiene pleonasmos, palabras de más. En una condición donde esperas un valor booleano, verificar la igualdad a true siempre está de más. Ese es el trabajo de la sentencia condicional (el if). Por lo tanto siempre que veamos == true en un if lo podemos quitar y el código hace lo mismo.

var approveCheckbox = document.GetElementById("approve");
var continueButton = document.GetElementById("continue");

if (approveCheckbox.checked)
  continueButton.disabled = false;
else
  continueButton.disabled = true;

Otra cosa que podemos notar es que el código en el then y en else ambos son asignaciones. Cuando tenemos una asignación en ambos casos y solo cambia según la condición podemos usar el operador ternario "?". Esto es un cambio opcional que a veces ayuda a reducir el ruido en el código. Es importante no abusar de esto.

var approveCheckbox = document.GetElementById("approve");
var continueButton = document.GetElementById("continue");

continueButton.disabled =
    approveCheckbox.checked ? false : true;

Ahora es fácil ver que cuando tenemos una asignación a un booleano que depende de otro booleano (condición) podemos simplemente asignar la condición a la variable

var approveCheckbox = document.GetElementById("approve");var continueButton = document.GetElementById("continue");

continueButton.disabled = !approveCheckbox.checked;

Tenemos menos código y es más fácil comprenderlo, darse cuenta que: la propiedad disabled del botón depende de la propiedad checked del checkbox.

Entonces en resumen, lo que podemos hacer para reducir algunos de los pleonasmos en el código son:

1. Piensa que escribir "== true" es como escribir "subir para arriba". Simplemente bórralo, no es necesario.
2. Si asignas un valor en el then y otro en el else puedes usar el operador ternario, con moderación.
3. Si lo que asignas es un booleano que depende de la condición, asigna directamente la condición a la variable. Esto también aplica si comparas valores, algo como: var enable = list.lenght > 0;

Hay otros ejemplos de redundancias en el código o pleonasmos, estos son algunos comunes y "fáciles" de evitar.

No hagamos repositorios para el acceso a datos

Este artículo está pensado sobre todo para el desarrollo usando el .NET Framework. Quizás aplique para los demás también, ya que casi cada Framework tiene su ORM.

Hace ya varios años que leí la opinión de Ayende Rahien acerca de que el patrón repository era el nuevo singleton. Tiempo después Jimmy Bogard también escribió sobre alternativas.

A mi entender el patrón repository consiste en abstraer el acceso a datos para que el resto del código no tenga que lidiar con los detalles del acceso a datos (conexiones, consultas, SQL, etc) al momento de acceder a colecciones de datos.

Con  el creciente uso de ORMs el patrón repository ya no es necesario. Ahora podemos usar algo como Entity Framework y dejar que se encargue de esos detalles para los que construíamos un repositorio. Entity Framework (o cualquier ORM) hacen eso y más sin que tengamos que escribir tanto código de "plomería". Escribo este post porque aun veo a programadores que intentan usar el patrón repositorio aún y cuando están usando un ORM.

No veo la utilidad de abstraer la abstracción del ORM (como EF) bajo el patrón repository. No es necesario, es querer apegarse a un patrón de diseño solo porque antes se usaba. Sí, se usaba porque era necesario; pero ya no lo es. La meta no es usar patrones, la meta es tener software funcionando que sea fácil de modificar.

Escribí un poco sobre esto cuando traté el tema de la arquitectura en capas, aunque el artículo no se trataba precisamente del patrón repositorio.

El código no es lo más importante

Aunque me gusta mucho trabajar en el código, debo reconocer que no es lo más importante. No es para lo que nos contratan. Lo usamos como una herramienta para lograr un objetivo: tener software funcionando. Eso es lo que espera el usuario o cliente de nosotros. De nada sirve el código "elegante" si no hay software resolviendo problemas.

En ocasiones olvidamos que la meta no es lograr cierta arquitectura,  poder utilizar ese framework,  lenguaje que está de moda o familiarizarnos con cierta tecnología. La meta es resolver un problema. Y hacerlo de la manera más eficiente, es decir, que no vaya a generar otro problema después.

Tampoco se trata de no darle importancia al código y hacer un cochinero

Aunque el código no es la meta y no es lo más importante, es necesario escribir código de calidad y evitar la deuda técnica. En ocasiones, por tratar de dar una solución "rápida" al negocio, escribimos código que resuelve el problema de momento; pero que si lo dejamos así sería difícil darle mantenimiento, sería complicado modificarlo o adaptarlo a nuevas necesidades. A esto le llamamos "Deuda Técnica", ya que como toda deuda, al principio te saca del apuro; pero tarde o temprano tendremos que pagarla y eso nos va a costar más entre más tiempo pase.

Aunque el código no es para lo que nos contratan, al ser nuestra herramienta principal de trabajo debemos mantenerlo limpio y fácil de modificar. Pero no perdamos de vista el objetivo: tener software funcionando, resolviendo problemas del mundo real.

Errores al Realizar Estimaciones

Casi siempre antes de iniciar un proyecto, es necesario saber cuanto tiempo nos vamos a tardar. Esto es para saber si realmente vale la pena hacerlo o no. Cuando el proyecto es personal no es tan complicado calcular, bueno por lo menos no es un riesgo; pero cuando es un proyecto que se va a cobrar y el cliente o jefe quiere saber si vale la pena realizarlo, a veces esa presión no nos deja estimarlo bien. Muchas veces los errores son cosas que pasan seguido y se pueden evitar si las identificamos.

El primer error es no querer estimar, es común escuchar o pensar "yo no sé estimar" y ese es nuestro pretexto para no ser responsables del estimado. Es normal no atinarle al tiempo que se lleva una tarea, sobre todo si es la primera vez que estimamos cuanto tiempo se lleva algo. Estimar es una habilidad que se obtiene practicando. Si queremos ser mejores estimando, debemos estimar más. Entre más lo evitemos, menos aprendemos a realizarlo.

Otro error al estimar es el ser muy optimista. Esto es pensar que todo va a salir bien a la primera. O que las cosas no van a cambiar. Cuando estamos trabajando en un proyecto de software, las cosas "nunca" van de acuerdo al diseño original (por algo lo llamamos desarrollo). Cuando estimamos debemos tomar en cuenta que lo más probable es que nuestra primera propuesta de solución no sea la adecuada. Siempre hay que agregar el "colchón" por si las dudas.

Ser muy pesimista es un error también, generalmente pasa después de que tuvimos problemas en proyectos anteriores por ser muy optimistas. Aquí el síntoma es que le ponemos tanto "colchón" a las tareas que puede parecer que el proyecto no vale la pena desarrollarlo por todo el tiempo que se llevaría. Encontrar el balance viene con la práctica.

Para poder saber el tiempo que nos lleva realizar un proyecto debemos poder definir las tareas  necesarias para completarlo. Otro error frecuente es no descomponer el proyecto en tareas concretas. A veces por no ponernos a pensar un momento a que se refiere cada tarea, podemos llevarnos una sorpresa al momento de realizarla y darnos cuenta que en realidad se lleva menos o más tiempo del que habíamos pensado. Es importante estimar cada parte del proyecto.

El último error de mi lista es no revisar que tan cerca estuvimos del estimado original una vez que terminemos cada tarea y el proyecto. Para poder aprender necesitamos saber que tan cerca o lejos estuvimos y entender el porqué. Esto nos va a ayudar a tomar esos factores en cuenta la próxima vez.

Enseñar menos para que aprendan más

Hace años empecé a dar clases de programación por las noches. El sistema que utilizan en la universidad donde trabajo es por cuatrimestres. Es decir, en lugar de dos cursos por año (semestres). Los alumnos toman tres cursos por año de cuatro meses cada uno. Esto provoca que los temas tengan que verse con cierta urgencia, porque "siempre" estamos contra reloj.

Una crítica constante de los estudiantes había sido que voy muy rápido, lo cual yo justificaba por el hecho de que en cuatro meses debía enseñarles muchos conceptos.  Eso sí, terminaba el curso a tiempo; pero muchos conceptos apenas y los tocaba. Los conceptos básicos no los practicábamos lo suficiente.

Para algunas personas esta forma exprés funciona, ya que practican por su cuenta y llegan a conocer los conceptos a detalle una vez que llega la necesidad. Sentía que parte de mi función era solo dárselos a conocer, exponerlos a las técnicas o tecnologías y después ellos/ellas vieran por su cuenta que partes tomar. Aplicar lo nuevo lleva su tiempo y en un cuatrimestre tiempo es lo que no tenemos.

Ahora lo que me ha funcionado es enseñar menos y repetirlo varias veces. Escribiendo varios ejercicios que ejecutan los mismos conceptos una y otra vez. Ya que estos se dominan, entonces empezar a introducir nuevos conceptos. Esto hace que algunos conceptos no alcance a enseñarles, lo cual no me gusta del todo. Quizás a alguien le podría haber servido conocer que existe cierta técnica; pero he notado que aunque estoy enseñando menos la mayoría está aprendiendo más. Por lo menos los grupos van más parejos. Al ser más repetitivo, los alumnos más avanzados pueden aburrirse un poco; aunque también les ayuda a su confianza poder realizar los ejercicios con facilidad en lugar de ir apresurados con los nuevos temas.

Ahora enseño menos, con más repeticiones (en forma de ejercicios) para aprender más.