spinner

Cinco claves para que tu código sea más legible

Si estás leyendo este post es probablemente por dos razones. Una porque el título te ha llamado la atención y dos, porque te interesa que tu código sea legible. Pues bien, en mi caso he estado en varios proyectos, principalmente J2EE y C, y en una grandísima parte del código con el que me encuentro, observo que no se cuida como se debería la legibilidad del mismo.

Es por ello que he visto la necesidad de escribir este pequeño artículo y recordar (o informar) algunas prácticas de estilo de programación que son básicas y que he observado que no se suelen seguir. En el blog de BBVA Next Technologies siempre procuramos compartir nuestra experiencia en diferentes ámbitos tech, desde dar consejos para que tus retrospectivas Agile sean más útiles, hasta contar qué cinco buenas prácticas pueden evitarte contactar con soporte técnico, con idea de que estos consejos puedan ser útiles día a día. Por eso, en este post nos centraremos en compartir unos sencillos tips para hacer que tu código sea más legible.

Algunos errores de partida

Es algo muy común pensar que debido a las prisas de nuestro día a día no es posible cuidar la legibilidad como se debería ya que no se puede comentar todo lo que se codifica, pero esta es una idea errónea. Los comentarios son un complemento a un código legible y no un método para lograrlo. Podríamos resumir el concepto de un código legible en dos frases:
1. “Un buen código legible no necesita comentarios”
2.”Un código legible es cuestión de estilo y no de tiempo”

A continuación se describen algunas prácticas de estilo que facilitan la legibilidad del código, son independientes del lenguaje, y no requieren de un tiempo extra para aplicarlas. ¡De verdad que es muy fácil!

Cinco prácticas en…3,2,1 ¡ya!

1. Espaciado entre bloques de código

Al desarrollar es importante que se use una correcta separación entre líneas, algo que será de gran utilidad para identificar de forma rápida bloques (o conjuntos) de código, compuestos de líneas que deberían estar relacionadas entre sí por una dependencia funcional. Debemos tener en cuenta que para el cerebro humano es más fácil recordar y aprender ideas si estas están asociadas a esquemas o formas visuales y la agrupación de líneas genera formas que, junto con el hecho anterior, de forma inconsciente facilita la comprensión del código al lector.

El factor que debe determinar la separación entre líneas de código es su interdependencia funcional: a mayor independencia mayor separación. De esta forma se intenta conseguir que un bloque de líneas contiguas genere una “forma” y el cerebro pueda asociarla fácilmente a una idea o concepto.

Un buen criterio de separación entre bloques de código es, por ejemplo, dar mayor separación entre funciones que entre líneas dentro de las propias funciones, por el simple hecho de que las líneas que componen una función siempre van a tener mayor dependencia entre sí que con líneas de otra función. Veamos un ejemplo:

En el ejemplo de la izquierda podemos ver que se deja una línea de separación entre diferentes bloques de código dentro de una misma función, y dos entre funciones. En el código de la derecha vemos que no hay una separación correcta entre líneas y como se puede observar, este segundo ejemplo resulta a primera vista menos legible que el de la izquierda.

2. Uso correcto de tabulaciones

Al igual que sucede con los espacios entre bloques de código, debido al mismo principio de generación de “formas”, el uso correcto de tabulaciones facilita la comprensión del código al lector. En este caso, cabe resaltar el ejemplo de Python, un lenguaje que en vez de usar usa llaves para delimitar contextos usa las tabulaciones.

Las tabulaciones deben ser uniformes en todo el código, de tal forma que si en el editor o el IDE usado para escribir el código está configurado para que las tabulaciones sean, por ejemplo, cuatro espacios, se debe mantener de esta forma en todo el código.
Estas deben deben venir determinadas por el nivel de anidación de un código: cada vez que se escriba una condición/bucle que englobe un código, este debe tener una tabulación adicional al de la condición/bucle al que está sometido. Un código correctamente tabulado no necesitaría llaves de delimitación de contexto. Veamos un ejemplo para entender el concepto:

ejemplos correcto tabulaciones

3. Evitar anidaciones

Es evidente que un código con muchas anidaciones resulta complejo de seguir y es por eso que siempre se debe intentar, dentro de lo posible, eliminar niveles de anidación. Veamos algunos ejemplos de cómo eliminar fácilmente anidaciones.

  • Caso 1. El caso más sencillo y típico es el de realizar comprobaciones para poder ejecutar determinado código:

buenas prácticas código anidaciones

En muchos casos puede quedar simplificarse cambiando el punto de vista tal que “para continuar con la ejecución deben cumplirse las comprobaciones” de la siguiente forma:

ejemplo anidaciones código

Tal como vemos, de esta forma se consigue eliminar un nivel de anidación.

  • Caso 2. Otro caso típico es el uso de comprobaciones dentro de bucles:

anidaciones dentro bucles código

De forma similar al caso anterior se puede eliminar un nivel de anidación de forma sencilla:

eliminar anidaciones código

  • strong>Caso 3. Otro caso bastante común es el uso excesivo e innecesario de sentencias “else” usadas con condicionales de distinto nivel y con distinta tabulación. Veamos:

sentencias else anidación código

Esto podría escribirse de la siguiente forma, en mi opinión, de manera más correcta:
uso correcto sentencias else codigo

Ahora veamos un ejemplo de pseudocódigo que mezcla todas las casuísticas para ver cómo aplicar todo lo descrito puede tener un impacto significativo en la simplificación del código:

Aplicando las medidas vistas anteriormente se mejora significativamente la legibilidad:
ejemplo codigo mejorado

4. La extensión de las funciones

Cuando hablamos de funciones es importante tener en cuenta su extensión. Una función de 200 líneas resulta complicada de seguir por muy legible que sea su código interno. La longitud ideal y la extensión máxima de una función deben venir determinadas (aproximadamente) por la media de altura del monitor de un PC. La finalidad de esto es reducir el número de páginas que será necesario visitar para consultar las primeras líneas de una función y las últimas.

  •  La extensión ideal de una función es aquella que nos permita ver toda la función en nuestra pantalla sin necesidad de usar el scroll.
  • La extensión máxima de una función debería ser aproximadamente dos veces el alto del monitor. De esta forma para poder consultar cualquier línea de la misma solo será necesario usar un salto de página.

5. La extensión de las líneas de código

De forma similar a lo que ocurre con la longitud de las funciones, la extensión de las líneas de código debe venir determinada por el ancho del monitor. Una línea de código debería poder verse entera sin necesidad de usar el scroll. En caso que la línea no quepa por muchos caracteres es recomendable partirla en los fragmentos que sean necesarios.

¡Haz tu código más legible!

Pues bien, con estos cinco consejos creo que se puede mejorar bastante la legibilidad del código, una de las claves para facilitar que los demás lo entiendan. Espero que puedan servirte y que te ayuden a la hora de programar.

Imagen de portada: pexels.com

Las opiniones vertidas por el autor son enteramente suyas y no siempre representan la opinión de BBVA Next Technologies.

Do you want to know what else we do in BBVA Next Technologies?

We use our own and third-party cookies to improve our services, offer you a pleasant experience and show users advertising related to your preferences by analyzing your browsing habits. If you continue browsing this website, we consider that you accept its use. You can change the configuration or obtain more information by accessing our cookies policy here.