Tag Archives: experiencias

Comentarios

¿Estamos jugando Jenga con nuestros sistemas?

Leave a comment

Si trabajamos en el mundo de la tecnología, ya nos debe haber pasado –o escuchado– de que el sistema se cayó por un cambio mal realizado. A veces nos pasa que mientras arreglamos una cosa malogramos otras. Mucho cuidado con los círculos viciosos.

Estas situaciones me recuerdan las veces que juego [Jenga] con mis amigos. Y es que, de empezar con una mala estrategia, llegado un punto, cada turno se vuelve emocionante pues nadie quiere tumbar la torre de madera.

Fuente: [Wikimedia]

Si en los proyectos de tecnología empezamos sin una estrategia técnica adecuada, muchas veces tendremos dolores de cabeza en el futuro. Sin ir muy lejos, muchas decisiones técnicas son pasadas por alto a consecuencia de “ahorrar”, “lo arreglamos después”, “las cosas siempre fueron así” o la necesidad de solucionar problemas rápidamente sin entender por completo las implicancias del mismo o incluso sin entender la solución.

Sinceramente creo que pasar por este tipo de situaciones nos hacen crecer profesionalmente. Sin ir muy lejos, con el paso del tiempo he descubierto que ya no me gustan algunas soluciones que hice en proyectos anteriores, la idea es ir descubriendo nuevas formas y cuestionar nuestro trabajo. Creo que deberíamos ser los primeros en hacerlo.

Regresando a la analogía, les cuento que conversando con muchos amigos o con las personas que me entrevistaban mientras buscaba trabajo, he confirmado mi teoría; todos hemos tenido una torre de Jenga que se ha derrumbado al menos una vez en nuestros sistemas. A veces nos reímos de eso y otras nos avergüenza, pero lo más importante es que hemos tenido la capacidad de aprender y jugar sabiamente.

Fuente: [The world’s biggest game of Jenga]

¿Qué síntomas tienen los sistemas Jenga?

  1. Los pases a producción tienen correcciones de última hora. O bueno, las correcciones del día siguiente.
  1. Es común hacer rollback pues las correcciones tardarán demasiado.
  1. Es común escuchar el [por favor, no toques ese código]
  1. Hay una persona que puede resolver los problemas “difíciles” y algunas veces ese es su trabajo principal. En algunos casos su rol o título es “el especialista”
  1. La gestión de versiones es pobre o nula.
  1. Los pases a producción se ejecutan manualmente.
  1. Las pruebas se hacen “a mano”
  1. La documentación no está actualizada o bueno, no existe.

Tal como dije al empezar con este post, puede que nos hayan pasado estas cosas y no hay problema con ello. Lo que sí creo es que sería irresponsable no hacer algo al respecto para que esto no nos vuelva a ocurrir.

¿Qué es lo que podemos hacer?

Puede que este sea –o suene– un trabajo complicado pero no es imposible. Los factores de éxito más importante tienen que ver con la determinación para resolver los problemas y el tiempo necesario para empezar con este tipo de trabajos.

A pesar de ello, he dividido esta estrategia en tres etapas.

#1: Orden

  1. Si no cuentan con una gestión de versiones adecuada o no han explorado ese camino, pues Git sobre GitHub es un excelente punto de partida. No se compliquen la vida pensando en qué archivos agregar al gestor de versiones, la depuración será parte del trabajo a realizar. Si no están familiarizados, aquí algunas referencias a tener en cuenta:
  1. Identifiquen el código innecesario, para no perder mucho tiempo en este paso, tienen que trabajar con herramientas como [SonarQube]. En mi publicación de [código muerto] encontrarán más detalle al respecto.
  1. Limpien su código fuente aprovechando la información encontrada en el paso anterior. Como mencioné en [código muerto], un buen calentamiento es comenzar por esas carpetas y archivos que nadie usa. Descubrirán que es un trabajo divertido y que en el tiempo resulta motivador ver cómo el código se va limpiando de a pocos y claro, los indicadores de SonarQube van reflejando el resultado de nuestro esfuerzo.
  1. Busquen que los especialistas en resolver problemas sean los primeros candidatos a ser referentes técnicos. Estoy seguro de que encontrarán de que hay experiencia que no está correctamente enfocada. Los especialistas podrán ayudar a identificar y/o eliminar esos elementos muertos y mejor aún, cumplir con labores más interesantes.
    • Ojo que esta actividad también nos servirá para confirmar si nuestros especialistas están preparados para dar el próximo paso o quizá es que no están interesados en hacerlo.
  1. Hablemos de automatizando. Un paso muy importante es engranar el desarrollo con un servidor de automatización y uno de los más populares es [Jenkins]. Lo mínimo necesario es implementar un flujo de [Integración Continua] y si todo marcha bien, ir pensando en la [Entrega Continua]. No se apuren en cumplir todas las recomendaciones que puedan encontrar en la web, con el paso de cada de actividad descubrirán qué paso agregar u omitir en el flujo de automatización.
  1. Identifiquen el código de las funcionalidades más importantes para el negocio. Aquí es donde los referentes técnicos nos darán una mano o en el peor de los casos, confirmarán que alguno de ellos solo se había orientado a resolver problema sin entender las causas o impacto en el negocio. Si esto ocurre no se preocupen, siempre habrán cosas por mejorar pero dependeremos mucho de la actitud de los involucrados.
  1. Automaticen sus pruebas. Es posible que hayan escuchado que es un trabajo interminable o que pone en riesgo las fechas comprometidas pero hay que sincerar las cosas, en un primer intento no podremos automatizar todo. Aquí es donde veremos la importancia de haber identificado las funcionalidades más importantes. La primera versión de esta automatización no tiene que ser perfecta pero debe existir alguna forma sencilla de validar las más importantes. Lo más importante radica en que el equipo decida el número mínimo de pruebas a automatizar. Aquí dos consideraciones a tener en cuenta:
    • Si no tienen el tiempo necesario, pueden empezar con [pruebas unitarias], cuya tecnología dependerá del stack tecnológico con el que cuenten.
    • Si quieren dar un paso más adelante y están trabajando sobre una plataforma web o servicios REST, pueden realizar pruebas usando [cypress]
  1. Refactoricen, sigan limpiando, midan el avance. Herramientas como [SonarQube] o [New Relic] les darán una serie de pistas que los ayudarán a seguir limpiando el código. No tienen que seguir todas las recomendaciones, la idea es ir mejorando la calidad del código mientras van construyendo nuevas funcionalidades, siempre recordando que las pruebas automatizadas nos indicarán si estamos rompiendo algo que ya funcionaba.

#2: Equipo

  1. Busquen alinear los conocimientos del equipo. Si bien es cierto este es un ideal, lo mínimo esperado es que los especialistas compartan lo necesario para ir cortando dependencias. Lo que necesitamos es tener más jugadores de equipo y de paso confirmar si los especialistas se pueden afirmar como referentes técnicos (una forma de hacerlo es creando espacios donde puedan compartir lo que saben)
  1. Promuevan más reuniones técnicas. La temática puede estar relacionada a un problema, una solución, una técnica de programación, un sistema o una tecnología en particular. Consideren que también podrían invitar a personas de otros equipos o empresas (para compartir algún tema como los mencionados)
  1. Promuevan la capacitación del equipo. Ser autodidactas es bueno, pero si está a nuestro alcance gestionar o solicitar ese capacitaciones para el equipo, es nuestra responsabilidad hacerlo. Estas sesiones deben considerar aspectos prácticos. Para ser claros, toda teoría debe complementarse con un ejemplo que empuje al equipo a escribir código. Aquí unos tópicos que sugiero regularmente:
    • Programación orientada a objetos
    • Algoritmos de búsqueda
    • Teoría de complejidad
    • Pruebas unitarias
    • Refactorización
    • Test Driven Development
    • Automatización de pruebas
    • Servidores o servicios de automatización
  1. Evalúen. Esto se debe realizar de manera continua mientras se vaya realizando la capacitación y debe confirmarse con una evaluación final, la cual debe ser con computadora en mano. Con esto confirmarán si el objetivo de la capacitación se ha cumplido.
  1. Definan con el equipo las nuevas reglas del juego. El equipo seguirá desarrollando las funcionalidades requeridas por el negocio pero en adelante debería haber apertura para:
    • Refactorizar el código existente sin romper las pruebas unitarias ya construidas
    • Implementar nuevas pruebas unitarias, además de la relacionada a la nueva funcionalidad a construir
    • Eliminar código muerto
    • Gestionar la deuda técnica sin ser perfeccionistas

#3: Visión

Hay que tener en cuenta de que estamos trabajando sobre la practica de ir mejorando lo existente mientras seguimos atendiendo la misión del negocio. Esto es lo que ocurre normalmente, no debemos olvidar la visión del negocio y que además esta nos sirve como referencia principal de nuestra visión tecnológica. Lo que he encontrado en algunas situaciones es que también hay mucho trabajo por realizar, aquí algunas consideraciones:

  1. ¿Tenemos un diagrama de situación actual? No se preocupen, lo normal es que ese diagrama no exista. La buena noticia dependerá de qué tan bien hayamos seguido la práctica de realizar reuniones técnicas. Si la respuesta es positiva, lo que debe hacer el equipo es dibujar el primer diagrama AS-IS de los sistemas de la empresa. Estas sesiones también servirán para crear una lista de aquellas cosas por refactorizar/mejorar, la cual debe estar relacionada con cada elemento identificado en el diagrama.
  1. Es momento de definir nuestros compromisos técnicos. Lo normal es tener objetivos técnicos (p.e. reducir los errores en 25%) mientras que los compromisos muchas veces se omiten o se consideran implícitos. Lo mejor es aclarar en conjunto aquellos compromisos que en adelante se respetarán por la salud técnica de nuestros sistemas. Aquí una propuesta:
    • Funcional: Fácil de usar (perspectiva del usuario)
    • Flexible: Fácil de entender y modificar (perspectiva del desarrollador)
    • Extensible: Fácil de conectar con otros sistemas (perspectiva del desarrollador y del sistema)
    • Automatizable: Lo necesario para poder compilar, probar, desplegar y diagnosticar fácilmente.
  1. ¿A dónde queremos llegar? El objetivo de esta actividad es obtener un diagrama TO-BE teniendo en cuenta lo siguiente:
    • Podemos soñar
    • Debemos considerar que tenemos al menos dos inputs técnicos, el diagrama AS-IS y la lista de cosas por refactorizar/mejorar
    • Un input adicional –y que no es técnico– es la visión del negocio ¿qué es lo que se está buscando en 3, 5, 10 años? Mientras más información tengamos, mucho mejor
    • ¿Podemos soñar? Claro que sí pero tampoco creamos que de un día a otro conseguiremos arquitecturas como las que promueven Amazon, Netflix, Uber o tantas grandes empresas.
    • Debemos considerar que en el tiempo nuestra torre se debe transformar en una fortaleza. Lo ideal es derrumbar todo y empezar de nuevo pero eso sí sería soñar en grande.
  1. Seamos realistas. No me malinterpreten, lo que quiero decir es que debemos hacer una comparación entre lo que tenemos y lo que buscamos y sobre eso hagamos un plan que busque eliminar ese gap poco a poco.
    • Tengamos en cuenta de que cada paso se debe convertir en al menos una meta a cumplir y que cada meta debe ser fácil de medir en un tiempo determinado.
    • Por otro lado si es que no tenemos opción a reemplazar todo un sistema. Lo que podemos hacer es hacer el reemplazo de aquellos componentes que a veces vale la pena reemplazar por un nuevo desarrollo o por algo que podríamos comprar y modificar. Si esto se puede hacer para varios elementos de un sistema, es un proceso que le he llamado “reemplazo silencioso del sistema”
    • La deuda siempre existirá y sigamos trabajando con eso. No tenemos que ser perfeccionistas, [la regla del 80-20] siempre ayuda.

Comentarios finales

Lo que he encontrado en algunos equipos es que con el paso del tiempo nos volvemos jugadores expertos de Jenga y la verdad es que eso es algo que no deberíamos buscar. No es saludable.

Lo que también he encontrado es que una definición incorrecta del trabajo a realizar –para atacar la torre de Jenga– hará que no se encuentre o vea el valor de lo que estamos buscando. Parte de esto lo menciono en [la importancia de la arquitectura de un sistema]

Algo muy importante –y obvio para algunos– es que necesitarán más jugadores de equipo y menos jugadores de Jenga.

Un abrazo,

Comentarios

Código Muerto 💀

2 Comments

Una de las anécdotas más comunes de un proyecto de software es que siempre hay una clase o una función que será recordada por el número de líneas que esta tuvo. Estoy seguro de que al menos una vez hemos escuchado:

“No toques esa clase, tiene como 1000 líneas de código”

Developer anónimo

Este es un dato particular de acuerdo a los proyectos en los que estuve y conversaciones entre amigos. Lo que es menos común, es saber cuántas líneas de código tiene el proyecto en el que estamos trabajando.

Si en este momento nos hacemos esa pregunta o se la hacemos a otro miembro del equipo, es posible de que no consigan una respuesta concreta. Si bien es cierto no considero necesario ser 100% precisos, he notado que pocas personas se preocupan de esa métrica, a menos claro, de que haya algún costo asociado.

Si no les ha pasado, les comento que casos como este se dan desde hace mucho en proyectos donde se audita código. Sin ir muy lejos, Amazon liberó [CodeGuru], un servicio (aún en preview) que analiza el código fuente. Como es de esperar, el costo está asociado al número de líneas y no es el único producto o servicio que hace este [tipo de trabajos]

Fuente: [Amazon CodeGuru]

¿Qué es lo que regularmente encontraremos?

He participado en proyectos donde el análisis o auditoría de calidad de software era uno de los objetivos más importantes. Muchas veces el costo de servicios adquiridos –u ofrecidos– estaba relacionado al número de líneas de código (o LoC por [Lines of Code]).

En cada trabajo era común confirmar lo encontrado en proyectos anteriores:

  1. Pocas personas conocían el número de LoC o la importancia de este indicador
  1. Una práctica conocida –y en algunos casos, aceptada– era “agregar código de ejemplo, ir cambiando y probando pero guardar la versión original por si algo se malograba”
  1. Muchas veces se mantenían las carpetas de plantillas y ejemplos de las librerías y componentes de terceros que en algunos casos ya no se utilizaban

Ya en un caso concreto, estuve en un proyecto donde el desarrollo tenía más de un millón de LoC y estaba seguro de que eso no podía ser posible pues las funcionalidades del sistema no reflejaban dicha realidad.

Sabía que estaba frente a un caso de Código Muerto, pero tenía que demostrarlo.

¿Qué es Código Muerto?

Sin entrar en detalles (pues es posible que encuentren discrepancias y hasta [una canción]), el código muerto o “Dead Code” es aquel que no aporta valor al negocio.

El código muerto se puede clasificar de la siguiente manera:

  • Código que no se usa: Muy usual en los proyectos de software, algunas veces no se recuerda su objetivo inicial y por lo general ocurre pues las necesidades van cambiando y el código no se depura adecuadamente luego de cada cambio (mucho cuidado con las frases “es que no hay tiempo” o “lo vemos después”)
  • Código que se ejecuta pero que no se usa: Aquí entran los casos como los de variables asignadas o llamadas a funciones cuyo resultado no es utilizado. Esto es nocivo pues además ser código inútil, consume recursos del sistema.
Fuente: [Refactoring Guru]

¿Cómo identificar Código Muerto?

Con el paso del tiempo preparé una secuencia de análisis que me sirvió para encontrar casos de código muerto bajo la premisa de que si algo se define en el programa, este debe ser utilizado de manera efectiva. La lista puede parecer obvia, pero ya está demostrado que en tecnología no debemos confiar en las obviedades 🙂

  • Variables
  • Funciones
  • Clases
  • Comentarios (sean redundantes o código que fue comentado para ser utilizado “más adelante”)
  • Elementos de archivos de configuración (por ejemplo, secciones comentads o que ya no se utilizan)
  • Archivos de configuración
  • Librerías (componentes de terceros)
  • Elementos idénticos (funciones, clases archivos, librerías o carpetas distribuidos en ubicaciones distintas)
  • Elementos parecidos (librerías con versiones diferentes, funciones o clases que inicialmente eran una copia de la otra)
  • Carpetas y archivos varios que poco a poco quedan relegados hasta el olvido

Un hecho común en todos los casos, es que el código muerto existe debido al temor a perder código o a malograr el sistema construido. Esto tiene relación directa con el desconocimiento de que los gestores de versiones permiten volver al pasado si es que se necesita ver algo que ha sido borrado.

Otra consecuencia es que a más código muerto, más complejo será el entendimiento de nuestro sistema, la mantenibilidad será afectada y a su vez generará dependencias con un programador en particular (a veces pueden ser más personas). Recuerden, el código es de todos los miembros del equipo y mientras menos dependencias, mejor.

¿Qué herramientas debemos usar?

Puede que parezca una broma, pero un elemento muy importante es la inspección visual. A pesar de ello, esta debe pasar a segundo plano pues debemos evitar confiar totalmente de los presentimientos o “literalmente” de puntos de vista.

De acuerdo a esta premisa, lo primero que debemos hacer es trabajar con [herramientas de análisis estático] que nos brinden un enfoque acertado de lo que está ocurriendo.

A pesar de ello, hasta el momento no he encontrado una herramienta que brinde un indicador de código muerto bajo un enfoque holístico. Es así que utilizo principalmente [SonarQube] como base del trabajo a realizar.

Regresando al caso del millón de LoC, encontré pistas que me ayudaron a confirmar la existencia del temible código muerto.

Si queremos empezar con estas prácticas, algo que nos podría ayudar está incluido en las herramientas del navegador web. Una de las que ha llamado mi atención es la utilizada para analizar la cobertura de los archivos JavaScript y CSS. Esta viene en [Chrome] y no es complicado de usar/entender.

¿Qué conseguí luego de presentar lo encontrado?

El objetivo de mi trabajo en dicho proyecto, fue preparar un informe sobre lo que se estaba construyendo y sobre eso un plan de trabajo para implementar una nueva arquitectura. No me parecía adecuado llegar con una presentación llena de indicadores ni menos señalar responsables (aunque en algunos casos ese ha sido mi trabajo), así que gracias al apoyo y explicaciones que el equipo dio cuando estaba analizando el código, tenía el conocimiento necesario para “limpiarlo”, al menos en casos que parecían obvios o donde veía que complejidad baja o media.

Como este tipo de trabajos me gustan, no paré hasta eliminar 95% del código del sistema. No esperaba llegar a ese número pero más de un millón líneas era código muerto que se podía limpiar fácilmente.

Nada mejor que llegar con un informe que tenga un entregable como ese 🙂

La buena noticias es que el equipo quedó sorprendido. Cuándo me preguntaron cómo lo hice, les comenté que empecé por las obviedades (y ya saben lo que pienso de ellas :)) creo que eso los animó a seguir limpiando (luego de una segunda limpieza el código no superaba las 30 mil LoC)

¿Qué es lo que aprendí?

  • Es posible que este tipo de trabajos sea incomprendido al principio, pero se consigue mucho enseñando con el ejemplo. En dicho proyecto tenía que preparar una arquitectura que aproveche lo que ya estaba construido, pero ante las sospechas de código muerto, decidí detenerme un momento y evaluar cómo eliminarlo, primero por mi cuenta y luego con el equipo.
  • Lo que he encontrado en muchos casos, es que hay pocas intenciones de refactorización que a veces no se dan por el uso desmedido de frameworks y herramientas. Lo que creo que se debe hacer es sentar una base medible de lo que está sucediendo sin olvidar que lo más se hace en un proyecto de software es la construcción del mismo. Si es así ¿por qué no saber cómo va creciendo nuestro código?
  • La automatización de pruebas es muy importante pero esta se debe postergar si hay casos obvios de código muerto, he comprobado que a veces resulta más rápido borrar (sin miedo) que ponermos a programar un caso de prueba.
  • Siempre debemos utilizar un gestor de versiones (personalmente prefiero Git sobre GitHub) y tenerlo enlazado a un motor de automatización (como [Jenkins] o [Azure DevOps], ambos me parecen buenos y Azure DevOps es más sencillo de configurar) que ayude a tener visibilidad de la integración continua.
  • El equipo de desarrollo pasa a otro nivel de conocimiento, pues además de entender la importancia de prácticas de limpieza de código muerto se abre una nueva puerta hacia la calidad del producto.
  • Si la confianza y comunicación son las adecuadas, este tipo de situaciones se convierten en anécdotas del equipo.

¿Cuál fue mi reflexión final?

Antes de refactorizar o hacer lo que sea en el sistema, eliminen el Código Muerto, no teman.

Un abrazo,

Fuente imagen cabecera: [Finding Dead Code]

Comentarios

Mi aventura en 42 Silicon Valley

Leave a comment

Hace unos meses me animé a postular a [42 Silicon Valley] y creo que tuve suerte para ser aceptado (pues no tuve que dar examen de ingreso) o para conseguir un dormitorio gratis (aquí si tuve que esperar confirmación luego de casi dos meses)

El punto de inicio era participar en [The Piscine], el bootcamp para demostrar luego de un mes que tienes las habilidades necesarias para ingresar [al programa] que además de ser gratuito, tiene una duración de cinco años.

¿En qué consistió el bootcamp?

  • Estudiar todos los días de la semana, la mayor cantidad de horas posibles. Podías usar el material disponible o buscar en internet el material de estudio requerido para cada día.
  • Resolver las asignaciones diarias respetando el orden de cada pregunta (es decir, no puedes continuar si no terminas con una pregunta)
  • Respetar reglas de programación sobre el uso de librerías (muchas no se podían usar, te pedían construir tus propias librerías), número de líneas (25 líneas por programa), número de variables (4 por programa), sentencias (el “for” estaba prohibido) y así…
  • Terminar de programar antes de la hora límite (11.42 de la noche)
  • Tener en cuenta que cada línea de código escrita debería ser fácil de entender
  • Recibir diariamente 2 evaluaciones aleatorias que se hacían de manera presencial, lo cual te obligaba entre otras cosas a defender tu código en inglés (sí o sí tenías que hablar)
  • Realizar diariamente 2 evaluaciones (como dije, sí o sí tenías que hablar)
  • Participar en los trabajos grupales, que si bien es cierto no eran aleatorios, requerían mucha coordinación.
  • Participar en los exámenes semanales, en los que cada viernes te asignaban una computadora que no tenía acceso a internet ni a herramientas como Visual Studio Code, así que si no sabías como usar vim o comandos en Linux, estabas muerto 🙂
  • Tener en cuenta que los tres primeros exámenes durarían 4 horas y el último sería de 8 horas
  • Programar en C
  • No hacer trampa, pues si bien es cierto los problemas se pueden conseguir fácilmente, si no puedes explicarlos o se descubre que ese no es tu código, cosas malas pueden ocurrir (además de que queda en tu registro y te podrían invitarte a salir del programa)

Pues bien, fueron cuatro semanas en las que además de compartir dormitorio con dos amigos de China y uno de Kazajistán, conocí amigos de Rusia, Francia, Argentina, Brasil, China, Korea y USA. Además, en todo ese tiempo aprendí de todo un poco, inclusive como ahorrar tiempo y dinero pues a pesar de vivir gratis en el campus, necesitabas dinero para comer y allá todo era caro :O

Sí, hay una bandera de Perú 😀 y como datos anecdóticos, era el único peruano y la foto muestra a los que quedamos hasta el final pues más del 50% se retiró

¿Qué aprendí?

Además de respirar programación, encontré cosas muy interesantes:

  1. Resiliencia: Si hay una palabra para definir a las personas que conocí en el bootcamp, esa es la primera que podría decir. Muchos amigos tenían unas ganas de superación increibles, algunos trabajaban por las tardes o noches. Otros no lograron conseguir dormitorio, así que viajaban una o dos horas (algunos manejando) para llegar diariamente al campus. Todo por estudiar.
  1. Colaboración: Si bien es cierto encontré casos de segregación de acuerdo al país de origen o similitud de conocimientos, cuando había problemas nadie dudaba en ayudar si te acercabas a preguntar. Algunos lo hacían con muchas más ganas que otros, pero todos terminaban respondiendo al pedido de ayuda.
  1. Empatía: Algunas veces mi evaluador no sabía como decirme que me había equivocado pues le daba pena que eso afectara a mi promedio. Esto lo supe pues me puse a conversar con ellos pidiendo más detalle ya que al igual que todos, quería aprender.
  1. Humildad: Algunas personas sabían lo suficiente como para terminar el trabajo en la mitad del tiempo o menos, pero a pesar de ello ni alardeaban, ni lo demostraban cuando te tocaba evaluar su código o cuando ellos evaluaban el tuyo. Me pasó más de una vez que hubo personas que me para preguntaban como había resuelto un problema y a veces descubrían un error en su lógica o algo por mejorar en ella. Nunca se molestaban, siempre agradecían.
  1. Optimismo: Una frase con la que siempre me encontraba cuando cometía un error era “no te preocupes, es solo un test, mañana lo haremos mejor” Lo genial es que a veces ocurría con personas que acababa de conocer.
  1. Competencia sana: Si bien es cierto todos sabíamos que cada examen semanal era determinante para ser aceptado en el programa oficial y que no todos seríamos aceptados, todos nos animábamos antes de empezar cada evaluación. Al finalizar nos preguntábamos comos fue y hubo casos en los que comparábamos soluciones. En mi caso prefería ir a dormir –pues terminaba muy cansado– pero al día siguiente la conversación seguía 🙂
  1. Comunicación: Si me preguntan cuál es diferenciador con respecto a lo que he visto en el medio local (es decir, Perú), este es un elemento muy importante. Teniendo en cuenta de que los programadores no hablamos mucho, eso también ocurre fuera del país, pero la diferencia es que estando allá, me encontré con personas que además de escribir buen código, explicaban muy bien lo que hacían o en todo caso, sabían vender muy bien sus ideas. Cosa que humildemente tenemos que seguir mejorando.

¿Qué pasó después?

Como mencioné anteriormente, el examen final fue un viernes y tenía una duración de 8 horas, en mi caso terminé de programar en la séptima hora. No recuerdo el número de problemas que resolví pero sí que había programado sin descanso alguno, así que cuando sentí que necesitaba salir de ahí, fue lo que hice. La verdad es que, cuando tu cabeza no da para más, lo mejor es dejar de programar.

A las dos semanas de dar el examen estaba de viaje y con poco acceso a internet, recuerdo que cuando pude conectarme, recibí con mucha sorpresa el correo de aceptación al programa, podía irme a estudiar por tres años y si no tenía donde vivir, podía postular nuevamente para conseguir un dormitorio.

¿Qué es lo que haré?

En esta época de mi vida me gustaría volver a enseñar, mientras tanto estoy retomando mi práctica de escribir y reforzar mis conocimientos en [arquitectura] (es por eso que mi blog ha renacido), además estoy presentando una tesis para conseguir mi maestría en administración y en paralelo a esto, me puse a estudiar mi segunda maestría mientras busco un nuevo empleo.

Creo que estoy algo ocupado por el momento (o quizá algo loco), pero bueno, nunca se sabe 🙂

Un abrazo,

Comentarios

10 aspectos a considerar si te interesa la arquitectura de software

2 Comments

Hace mucho que esta idea ronda por mi cabeza:

¿Qué necesito para ser un arquitecto?

Creo que es la consecuencia de tantas conversaciones con mis amigos o conocidos en eventos de tecnología.

Por mi parte –como apreciación personal– les comparto que he tenido la suerte de haber trabajado como arquitecto en más de un proyecto de tecnología y que este tipo de experiencias me ha ayudado a diferenciar entre las funciones que debería realizar un arquitecto y encontrarme con algunos malosentendidos a consecuencia del rol.

Consecuencias de una mala arquitectura
[Code Complete, Steve McConnell, 2004]

Con “malentendidos” me refiero a que me he topado con frases como “nuestro proyecto no necesita un arquitecto” o “ese rol no debería existir” o “los arquitectos no saben programar”, y la verdad es que, así como hay buenos profesionales, también los hay de aquellos que no saben hacer bien su trabajo y que por lo general son los responsables de muchos inconvenientes.

Lo bueno de estas experiencias es que –casi siempre– logramos conseguir –gracias a la apertura del equipo con el que estaba– que el trabajo se pueda realizar de manera exitosa.

En fin, desde mi perspectiva, creo que cada rol existe gracias a una necesidad en particular y de ser así, debería cumplir con algunos criterios fundamentales. El rol del arquitecto no es una excepción, así que he preparado algunos aspectos que me gustaría compartir con ustedes:

1. Saber programar: No hay que ser un experto en programación pero es importante contar con la experiencia suficiente para entender el código del equipo de trabajo, hablar su idioma y claro, participar en los code review.

2. Enseñar con el ejemplo: Si bien es cierto este es un criterio básico de liderazgo, aquí se debe reforzar a nivel técnico, pues todo diseño o presentación debe ir acompañado con código de ejemplo. Sí, con esto me refiero a “la demo” y claro está, no tiene que ser algo completamente funcional pero debe demostrar la factibilidad de nuestra propuesta.

3. Conceptualizar: Esta capacidad será complicada de adquirir si creemos que un arquitecto tiene que ser un programador con mucha experiencia. La clave para acortar el camino, es dejar dejar de pensar en líneas de programación para hacerle un espacio a los componentes y sus tipos de integración.

4. Ser estratégico: Lo “fácil” de esto, es diseñar soluciones flexibles (fáciles de modificar o extender). Lo complicado viene cuando olvidamos los objetivos del negocio y sus respectivas restricciones. Esto implica que tengamos la facilidad de conversar tanto técnicamente, como en términos del giro del negocio. Luego de superar esta barrera, debemos proyectar lo que podría ocurrir en el futuro.

5. Presentar efectivamente: Como regla general, toda propuesta de arquitectura debe ser concreta, de fácil entendimiento y claro, con una “demo” que evidencie la factibilidad de nuestro trabajo. Esto pasa a segundo plano cuando tenemos que enfocarnos en ser concretos y convincentes al momento de explicar nuestras ideas.

6. Ser humilde: Debemos eliminar cualquier tipo de barrera a consecuencia del “poder que llevas por tener este rol”. Una forma de acortar distancias es dejar el ego a un lado para escuchar sugerencias, aceptar nuestros errores y si se da el caso, pedir disculpas de la única forma en la que se deberían pedir, con honestidad y sin condiciones.

7. Estudiar y poner en práctica: Además de reforzar nuestros soft skills, necesitamos entender la importancia de la [construcción de software], la [programación orientada a objetos], los beneficios del [código limpio], comprender los [patrones de diseño], averiguar sobre los [tipos de arquitectura] que existen en el mercado, las [nuevas tendencias de arquitectura] y claro, debemos [programar] en nuestros ratos libres.

8. Leer: Los líbros técnicos tienen que ser algo normal en nuestras vidas, pero también debemos incluir cualquier otro tipo de lecturas. El tópico queda a nuestra elección.

9. Preguntarnos ¿qué más podríamos hacer? Esto aplica al diseño en el que estamos trabajando, pero tiene más sentido cuando lo revisamos en nuestra vida profesional (pues lo natural es que evolucionemos a arquitectos empresariales) y ¿por qué no? también deberíanos hacernos la pregunta a nivel personal.

10. Sentido común: Yo creo que esto es algo que se puede entrenar y que podría tomar más tiempo del que pensamos, no por algo dicen que termina siendo “el menos común de los sentidos”. Pero no nos desanimemos, tomemos un momento para respirar y revisar si estamos construyendo un [homeromóvil] cuando lo que realmente necesitamos es algo tan simple como un skate.

Desde un punto de vista netamente personal, creo que cada aspecto tiene muchos requisitos y restricciones que se deben ir superando en el camino y si llega el momento en el que te das cuenta de que no te estás divirtiendo, pues es posible que tengas revisar otra vez si te gusta lo que estás buscando, o mejor aún, no presionarte pues nadie es perfecto y menos, un excelente arquitecto.

Un abrazo, JD