El complejo del programador valiente
Hacía mucho tiempo que no escribía en mi blog con opiniones personales, pero hoy me he levantado con ganas de hacerlo para tratar un tema que he discutido muchas veces y que recientemente hablando con un amigo que estaba que se subía por las paredes, ha vuelto a surgir.
Si bien creía que el problema que voy a detallar a continuación lo encontraba más en España que en otros países, resulta que mi amigo que vive en otro país europeo algo alejado del mío y con un arraigo cultural diferente, me ha descrito la misma situación por la que he pasado no pocas veces, y que para colmo, no es un problema geográfico o cultural de un pais determinado, sino que ocurre con más frecuencia de lo que desearíamos todos en nuestra profesión.
A esto lo he llamado el complejo del programador valiente.
En realidad se trata de un problema recurrente en el que algunos programadores tienen la costumbre de complicarse la vida (muchos de ellos sin saberlo o sin ser conscientes de ello) programando de forma valiente, intentando demostrarse así mismos y a quienes les rodean, que saben mucho y tratando de que los demás los vean de igual modo a como se ve o se quieren ver así mismos (de ahí lo del complejo).
Dicho de otro modo:
- Es bastante habitual, más de lo que pensamos, encontrarnos en nuestra profesión soluciones complejas a problemas sencillos.
- Es también habitual, ver mucha «reingeniería» en proyectos, queriendo dar así la sensación de que quién los programa controla y sabe mucho, además de querer hacerse imprescindible en el proyecto debido a que menos gente sabrá mantener o resolver futuros problemas en el código.
- Es frecuente igualmente, encontrar a programadores que hablan todo el tiempo de patrones y los intenta aplicar a sus proyectos a discreción como si de esa manera mostrara al resto un alto dominio del campo y del mundo de la programación.
- Es también constante ver a programadores que utilizan frameworks en sus proyectos como el que respira el aire fresco de cada mañana.
- Y ya no digamos el hecho de meter frameworks o librerías similares dentro de un mismo proyecto que hacen cosas muy parecidas.
Pero, ¿todo esto es malo o bueno?.
Personalmente creo que el principio KISS (Keep It Simple, Stupid!) o la Navaja de Ockham son aquí claves de cara a entender la raiz de la solución de lo que muchos programadores obvian y del problema que comento.
Precisamente creo que un programador no acomplejado, es aquel que hace simple lo difícil, sencillo lo complejo, y por ende, resuelve consistente y satisfactoriamente los problemas de forma que cualquier otro programador pueda entender el problema de forma ágil.
No diré que es mejor o peor programador. Hay excelentes programadores que sufren del complejo de programador valiente, pero sí diré que a la larga es más sano para el equipo y para el proyecto evitar caer en el complejo del programador valiente.
Pero es más, no sólo se trata de resolver problemas, sino también de modificar, actualizar y mantener de forma eficiente los problemas, es decir, que una solución compleja resuelta de forma sencilla va a ser siempre más mantenible que una resolución enrevesada de la misma, al igual que los tests que podamos hacer sobre dicha solución sencilla, serán siempre a la larga, más fáciles de entender y mantener que otros más complejos y costosos.
Por eso, para mí un programador valiente es precisamente el que es capaz de simplificar al máximo el problema aportando la mejor solución posible, minimizando los riesgos y problemas dentro de esa solución.
Aparte de esto, están luego otros supuestos que aquí no estoy abordando, como por ejemplo:
- Que un cliente nos «obligue» a utilizar una tecnología, librería, framework, etc concreta.
- O que las pruebas de carga, rendimiento, etc. (que no debemos obviar) no estén dando los resultados que esperábamos pese a haber resuelto de forma simple un problema complejo. Porque aunque la solución a un problema complejo sea simple, no significa eso que a efectos de carga, concurrencia, rendimiento, etc., sea la mejor de las soluciones. Por eso creo, debemos siempre tener en mente a KISS y a la Navaja de Ockham o Principio de Ockham.
Esto de la programación es un arte en el que siempre tenemos que buscar el equilibrio de múltiples factores, y entre esos factores, tratar de huir siempre del complejo del programador valiente.
Lo que sí tengo claro es que un programador que hace complejo lo simple, no tiene porqué ser el mejor programador del mundo aunque pueda parecer demostrar poseer muchos conocimientos y que así lo crea mucha gente que lo rodea o él mismo. Pero sí lo es en mi opinión, aquel que de un problema complejo, aporta una solución funcional, robusta, elegante y simple.
Si cualquier programador es capaz de coger un código y leerlo y entenderlo a la primera, es que has aplicado el Principio KISS y el Principio de Ockham de forma correcta. Sino es así, es muy probable que quizás hayas caído en alguna parte de tu código en el complejo del programador valiente.
Como dice Richard Branson: «La complejidad es tu enemiga. Cualquier tonto puede hacer algo complicado. Lo difícil es hacer algo simple»
Como decía Albert Einstein: «Si no lo puedes explicar de manera simple, no lo entiendes lo suficientemente bien».