sábado, 23 de diciembre de 2017

Acerca del uso de las metodologías de desarrollo en la empresa

Hace unos días un lector del blog me hizo la siguiente pregunta:

Me he estado preguntando que metodologias del desarrollo de software utilizas? Sería interesante conocer ese tipo de detalles para los ingenieros que apenas estamos comenzando nuestra etapa profesional
Me he estado preguntando que metodologías del desarrollo de software utilizas? Sería interesante conocer ese tipo de detalles para los ingenieros que apenas estamos comenzando nuestra etapa profesional

La verdad es que de manera inadvertida, la respuesta a esa pregunta creció mucho y decidí convertirlo a una entrada del blog sobre el uso de metodologías en el empresa, para ofrecer un opinión desde un punto de vista personal a la vez que profesional. En los siguientes párrafos esta mi respuesta.

Es una pregunta muy interesante la que planteas. Aquí hay un tema importante; no siempre vas a poder usar la metodología que quieras o incluso la adecuada para el tipo de problema planteado, porque a veces viene establecida por la empresa encargada del desarrollo directamente.

Cuando comencé a trabajar formalmente dentro de equipos de desarrollo de software, teníamos que usar metodologías tradicionales y pesadas, en las que pasábamos por cada fase en estricta secuencia y había que documentar cada paso (c-a-d-a p-a-s-o). Las metodologías agiles estaban todavía muy verdes (en implantación) y no ofrecían confiabilidad con respecto a la forma de desarrollar software que llevaban vigente durante décadas.

En lo personal a mi no me gustaba mucho esa forma de trabajo, era algo bastante frustrante, que enaltecía el análisis y el diseño frente a la codificación, a la que prácticamente nulificaba en cuanto a importancia.

He de decir que no creo que ningún problema pueda ser comprendido en su totalidad hasta que no está resuelto y eso quedaba patente en el desarrollo de software, cuando muchos elementos deben volver al análisis (una y otra vez), porque su conclusión es insatisfactoria. Aquí comienzan los problemas, porque siempre hay una fecha de entrega, y muchas veces no definida por el tamaño y complejidad del sistema, sino por cuestiones de mercado y contractuales. En este punto lo más frecuente es que se empiecen a saltar partes del proceso para llegar cuanto antes a la finalizaciones. Pero saltarse partes de la metodología de desarrollo, sea la que fuera, solo lleva el desastre.

Recuerdo como anécdota ir a una serie de conferencias de PMI (Project Management Institute ) y pensar "Esta gente debe ser genial construyendo edificios, pero no han hecho un software en la vida". Mi comentario no es del todo objetivo y justo, incluso se pudiera decir "erróneo", pero realmente es lo que sentí en ese preciso momento.

Afortunadamente ya mediados de los 2000, se comenzaron a aceptar de forma empresarial a las metodologías agiles (aunque existan desde muchos antes).

Ahora intento usar Programación Extrema (XP) y Scrum.

  • XP nos da una pauta para poder desarrollar (programar) software con calidad y rapidez, valorando las capacidad del software frente al cambio (si un software puede cambiar fácilmente, es que está bien construido), que el seguir un plan cerrado sobre el producto.
  • Scrum abarca otras partes del proceso de manera más global, ya considerando iteraciones con diversos elementos del equipo de una forma adecuada.
En lo que posible, fomento la comunicación verbal, y disminuyo a lo mínimo necesario la documentación y la comunicación por escrito, sobre todo cuando no aportan ningún al sistema.

Aquí es importante la situación real por la que pase el equipo de trabajo. Comentaba en otro post, que cuando mas maduro y capaz de comunicarse sea el equipo (de desarrollo) más éxito tendrá una metodología ágil, mientras que si el equipo es "novato", o tiene fricciones es mejor una metodología mas pesada y documental.

No hay que confundir la falta de documentación, con el desorden y el caos. Scrum propone mecanismos muy claros sobre cómo tiene que ser la comunicación en el equipo, el seguimiento y la asignación de tareas.

Comentar que igual que he tenido éxitos, también he tenido fracasos por aplicar determinadas metodologías en momento y con equipos inadecuados (para dichas metodologías). Hay que considerar que el éxito no es que un software llegue a estar productivo (cosa que siempre suele llega a pasar, porque es raro que se deje una necesidad de negocio sin suplir), sino que se haya desarrollado en el tiempo y la calidad requerida, además de al le equipo haya quedado satisfecho con el resultado y no exhausto después de hare maratónicas sesiones de codificación.

En cualquier caso es posible que otras áreas que no tengan que ver con el desarrollo de sistemas tengan procesos más pesados y documentales, generalmente es porque su proyectos son (en cuanto tiempo) de más corto alcance, con lo que no tiene la necesidad de "agilidad" propia de un desarrollo software. En este caso puede haber "rozamiento" entre áreas, por las diferentes metodologías. En este punto hay que llegar a la forma correcta de comunicación entre una área y otra, afectando lo mismo posible la metodología de desarrollo "de puertas para adentro".

Algunos artículos relativos a este tema son:

sábado, 16 de diciembre de 2017

Regla N°14 de la Ingeniería de Software: Evita la ceguera voluntaria


La ceguera voluntaria es ignorar de forma deliberada situaciones que si bien son perjudiciales, no suponen un daño inmediato, con lo que no se hace nada para corregirlas, convirtiéndose en una posible situación catastrófica a futuro.


Ejemplo de ceguera voluntaria en la serie Silicon Valley, Capítulo 03x05.

Aunque pudiera parecer absurdo intentar ignorar o omitir posibles problemas dentro del desarrollo de software (o realmente en cualquier tipo de proyecto) es algo bastante común.

Cuando aparecen problemas en mitad de un desarrollo y no son atacados y mitigados cuando son pequeños, aumentaran de forma progresiva hasta ser de tal tamaño que afecte al tiempo, calidad o costo del proyecto.

Lo elementos que más se suelen ignorar son:

  • Retrasos en el desarrollo del software: El producto saldrá claramente después de la fecha estimada, sin embargo ninguna alerta es disparada, haciendo creer al cliente que tendrá su sistema cuando se le indico. Aparentemente nadie quiere decir la palabra "retraso" en voz alta, aunque es algo claramente palpable.

  • Problemas tecnológicos: El equipo no tiene la capacidad técnica suficiente para llevar a buen término el sistema, ya sea por una sobreestimación de sus posibilidades, o porque directamente se construyo un equipo sin la preparación necesaria.

  • Problemas de recursos: No hay algún factor tal como dinero, tecnología necesaria (teléfonos, tablet o computadores) o gente disponible.

  • Problemas de integración de equipos: Aquí simplemente el equipo (de personas), no puede trabajar juntos, ya sea porque no tiene una buena relación o porque tienen una idea del trabajo tan individualizada que no son capaces de entender el concepto de trabajo en equipo.


Hay que entender que la ceguera temporal es algo que se da en todos los niveles, el programador puede omitir datos críticos, pero un buen líder de proyecto debe detectar omisiones y faltas al plan de desarrollo y buscar la forma de mitigarlos y sobretodo que emerjan a la luz, y estén claros, es decir asegurarse que hayan sido comprendidos (al nivel jerárquico que corresponda). Un líder de proyecto que ignora lo que ocurre en su equipo y en la construcción de un sistema, es un mal líder de proyecto y posiblemente un irresponsable que echarla la culpa del fracaso de "su" sistema a otras personas.

sábado, 25 de noviembre de 2017

Recomendaciones: El libro negro del programador

Es bastante sencillo encontrar libros sobre cualquier tipo de tecnología, herramienta o lenguaje de programación, pero al momento de localizar literatura sobre desarrollo profesional (o empresarial) de software dentro de un ambiente “real” (es decir no académico), es bastante más complicado y si además, estamos hablando de materiales en español, se vuelve una tarea completamente imposible.

El libro negro del programador, de Rafael Gomez Blanes, es una obra que nos ofrece una visión práctica, profesional y realista del desarrollo de software en un ambiente laboral. El libro no profundiza en ningún aspecto tecnológico en particular, si no en las buenas y malas prácticas en la construcción de sistemas.




Al leer el libro del programador, cualquier desarrollador, con un mínimo de experiencia laboral, se sentirá identificado con los problemas tratados allí. Generalmente la parte difícil no es reconocer que hay un problema en la forma de desarrollar sistemas en nuestra empresa o equipo, eso es bastante obvio cuando se acumulan las horas extras, el software de baja calidad, y la tensión palpable en el ambiente, el acierto del libro es listar las circunstancias que nos llevan a dichos problemas. Es necesario leer sobre nuestros problemas y escenarios laborales para poder comprenderlos completamente, aunque los estemos viviendo en primera persona.

El libro hace hincapié, entre otras cosas, en los siguientes temas:

  • La importancia del refactoring y la creación de software que pueda ser mantenible.
  • La capacidad de un sistema para ser probado y depurado.
  • Que el éxito no es tener un sistema que funcione en producción, sino un sistema de calidad, que además permita evolucionar con las necesidades de nuestro cliente.
  • Que no hay que trabajar muchas horas, sino ser productivo.

Por todo esto considero que El libro Negro del Programador es un texto que todos los desarrolladores debieran tener en su escritorio, para que no les olvide como hacer buen software.

Puedes obtener más información en http://mybook.to/elndp.

viernes, 10 de noviembre de 2017

Regla N°13 de la Ingeniería de Software: Simplifica las cosas


Cuanto te enfrentes a un problema grande, simplifícalo en problemas más pequeños. Si estos problemas siguen siendo demasiado grandes repite el proceso hasta que tengas un problema lo suficientemente pequeño para poderlo resolver.

Lo anterior parece un consejo bastante razonable, no solo para la ingeniería de software, sino para cualquier circunstancia en general. Sin embargo parece que es difícil entenderlo al momento de enfrentar un nuevo desarrollo software.




Es común que caigamos en el error de ver los sistemas como un todo unido de enormes dimensiones, pero como ingenieros debemos ver las partes que componen un sistema, y centrarnos en el diseño y la construcción de dichas partes, de forma unitaria, además de en su correcta interacción.

Para simplificar partimos siempre de un problema grande que es irresoluble en su tamaño actual, e identificamos las partes que lo componen. Lo dividimos en pequeños problemas que son más fáciles de resolver, repitiendo el proceso hasta que podémonos identificar dichos problemas con una solución clara y sencilla, y además que solo sirva para resolver exclusivamente una necesidad.

En la medida que las “mini-soluciones” estén bien diseñadas será más fácil juntarlas, para resolver nuestros problema de origen (Curiosamente cuando más “desacopladas” sean, más fácil será unirlas).


Las ventajas de la simplificación son las siguientes:

  • Nos obliga a ser ordenados y metódicos a la hora de resolver un problema.

  • Con la simplificación es más fácil distribuir el trabajo dentro de un equipo de trabajo con varios recursos.

  • Cuando comenzamos a resolver los problemas identificados, estos, por su tamaño nos permiten concentrar nuestro esfuerzo en un solo “tema” a la vez, y son además lo suficientemente pequeños para ser manejables.

  • Cada solución aportar una funcionalidad concreta y finalizada al sistema.

  • Las soluciones se deberían poder probar de forma individual. Las pruebas unitarias nos garantizan que todo funciona correctamente antes de integrarlo al conjunto global. Igualmente el sistema es modificado nos permite probar los elementos por separado, evitándonos realizar un complicado flujo hasta llegar al punto que deseamos probar.

  • Simplificar nos permite desarrollar un sistema más desacoplado. Un sistema desacoplado permite que se cambien los componentes por otros que agreguen funcionalidad o la mejoren, sin afectar al resto de los componentes. Cuando más desacoplado e un sistema más mantenible es.

jueves, 12 de octubre de 2017

CapicuaGen, Generador automático de Código Empresarial


Hace aproximadamente un año presente la tesis de mi máster en investigación en ingeniera de software, la cual base en la creación de un sistema generador automático de código llamado CapicuaGen. Durante todo este año decide tomarme un descanso del proyecto, al haberle delicado, en su momento, mucho tiempo y esfuerzo. Sin embargo he decido que ya es hora de continuarlo, para establecerlo como una buena herramienta de generación de código empresarial.

Mi tesis puede encontrarse en el siguiente enlace:


Con una pequeña presentación:


También puede encontrarse más información sobre los fuentes y compilados del proyecto en:


Contexto


CapicuaGen se ubica dentro de los tipos de herramientas conocidas como "Generadores de código", siendo su especialidad la generación de código con enfoques empresariales.

Los "Generadores de código" son sistemas (o partes de sistemas) cuya funcionalidad, como dice su mismo nombre, es crear el código fuente de un sistema destino a través de una configuración o especificación de una necesidad establecida previamente.

El cómo se especifica dicha necesidad puede variar entre distintos enfoques para cada generador en particular, pudiendo ser mediante un diseño en UML, un lenguaje específico del domino (DSL) o cualquier otro mecanismo, pero teniendo todos ellos en común que son más afines a características y elementos de negocio que a temas de índole técnicos en concreto. Esto es porque intentan llevar la abstracción de la construcción de sistema a un nivel más elevado que la programación directa en un lenguaje en particular.



Ilustración 1. Ejemplo de generador de código.


CapicuaGen nace dentro de un contexto empresarial basándose en dos principios, por los que se considera que es beneficioso el uso de generadores de código.
  • El software va a cambiar: Los cambios son necesarios para el negocio , además se dan de forma cada vez más frecuente, lo cual tiene un alto impacto en las empresas. Debemos poder responder a la necesidad de dicho cambio para que nuestra empresa siga vigente en el mercado de la forma adecuada. Los generadores de código nos pueden ayudar a gestionar dichos cambios de una manera más sencilla y rápida.
  • El software se parece entre sí: Casi todo el software empresarial se parece entre sí. La mayoría de las compañías gestionan recursos de algún tipo (humano, económico, etc.) y generan un producto (dinero, servicios, o bienes de alguna naturaleza). Técnicamente hablando, casi todos los sistemas tienen características como acceso a datos, seguridad, interacción con el usuario o trazabilidad. Los generadores de código nos ayudarán a crear apropiadamente todos estos elementos comunes, disminuyendo el tiempo y los recursos dedicados a tal efecto.

Acerca de CapicuaGen


CapicuaGen es un proyecto de código abierto, bajo licencia LGPL, que puede ser usado tanto para crear software comercial, como software libre.

Es un proyecto modular, basado en un generador central, que delega en elementos más pequeños conocidos como "Generadores de características", cuya misión es generar un aspecto en particular de un software destino, como puede ser la interfaz gráfica, la capa de acceso a datos, o la exposición de servicios y funcionalidades a través de una red corporativa o pública.

Los generadores de características son intercambiables e independientes, pudiendo elegir los que sean más convenientes para un escenario en particular, y cambiándolos cuando sea necesario. Igualmente pueden organizarse en repositorios públicos o privados (empresariales) y ser de fácil acceso para su uso, implementación y ampliación.

El uso del generador y la contracción de los repositorios se sustentan sobre lenguajes y tecnologías ampliamente adoptados por la industria, como Git, Ruby o repositorios públicos como GitHub, o RubyGems, con lo que su curva de aprendizaje es corta y sus capacidades de distribución y ampliación son altas.

El funcionamiento general de CapicuaGen es representado por el siguiente diagrama:




Ilustración 2. Diagrama de funcionamiento de CapicuaGen.

CapicuaGen es, a la fecha, un proyecto personal construido durante un periodo de seis meses, que contiene una serie de generadores de características sencillas expuestas a nivel didáctico, pero plenamente funcionales. Debido a su naturaleza de índole abierta, y su escalabilidad, es de desear que pronto pueda ampliarse con nuevas e interesantes características, aumentando cada vez más su potencia y utilidad.

Las capacidades generadoras que posee en la actualidad son las siguientes:

  •  Generación de proyectos para Visual Studio 2015.
  •  Creación de proyectos de escritorio.
  •  Creación de proyectos para exposición de servicios Web.
  • Generación de proyectos para Android Studio 2.0.

No hay ninguna restricción en cuanto a la tecnología o lenguajes para los que es posible generar código fuente, siempre que exista un generador adecuado para tal efecto. En los ejemplos anteriores generamos elementos para Windows, Web, Android, y en C#, Java o XML.

Igualmente y tal como se verá en la descripción específica de la solución desarrollada, CapicuaGen está pensado para ser parte del ciclo de trabajo del desarrollo de un sistema, permitiendo ampliar su funcionalidad y reciclándola para nuevos proyectos según se muestra en el siguiente diagrama:



Ilustración 3. Diagrama de flujo de trabajo de CapicuaGen.

Objetivos de CapicuaGen


Los objetivos a conseguir son los siguientes:

  • Agilizar la construcción de un sistema a partir del uso de generadores de código que creen de manera adecuada las características comunes ensamblándolas apropiadamente.
  • Reducir la programación manual de un sistema a los elementos particulares que así lo requieran, esto es, a aquellas partes que son exclusivas de dicho sistema y por lo tanto no están incluidas en otros.

Con el cumplimiento de estos dos objetivos se espera satisfacer las siguientes necesidades:

  • Aumento de la calidad del software al generarse en parte de forma automática. Los fallos detectados se podrían corregir en los elementos generadores y aplicar, por ende, al código de los sistemas.
  • Los codificadores no perderían tiempo realizando tareas repetitivas y se concentrarían en las que realmente dan valor al sistema y no en aquellas que se duplican desarrollo tras desarrollo.
  • Reducción de tiempo de desarrollo , con base en la generación de código automático.


domingo, 24 de septiembre de 2017

Roles principales en el desarrollo de software, una comparación tradicional-ágil.


Un “rol”, es una figura que adquiere una persona y que conlleva ciertas responsabilidades o comportamientos asociados. En el desarrollo de software, los integrantes de un equipo adquieren rol o roles según la función que desempeñen. El rol es independiente del puesto (o por lo menos no hay ningún motivo para que dependa de él) y una misma persona puede desempeñar varios roles al mismo tiempo.

En el desarrollo de software tradicional hay una serie de roles bien marcados. los analizaremos uno a uno y compararemos su función en metodologías tradicionales con el desarrollo de software ágil. Los roles a considerar son: Cliente, Líder de proyecto, Analista, Arquitecto, Diseñador, Programador y Tester.




Cliente


Es la entidad (o persona representante) que tiene la necesidad de un sistema o software nuevo (o de la modificación de uno ya existente). Una parte importante relativa al cliente es el usuario operador, que es la persona concreta que va a utilizar el sistema. Puede, y es además bastante probable, que el cliente o dueño final del sistema a construir no sea la misma persona que el usuario.

Líder de proyecto


Es el responsable (directo) de llevar a buen término el proyecto, por lo menos de parte de la empresa constructora del software. Debe coordinar al resto del equipo para que trabajen en armonía y eficientemente, también es el responsable de concretar las fechas de entregar de cada fase y garantizar que son cumplidas. El resto de personas del equipo trabajan bajo su dirección

Analista


Es rol encargado de analizar las necesidades del cliente en cuanto a su futuro sistema. Debe tener la capacidad de concretar todo lo expuesto por dicho cliente en una colección de requisitos a construir, además debe entender el negocio del cliente (que seguramente le es ajeno) y poder hablar su mismo "idioma". Una de las partes mas complicadas del rol de analista, es poder asumir que el mismo cliente no comprende completamente sus necesidades, ni las múltiples soluciones software a este. El cliente generalmente solo va a querer automatizar el trabajo que ha estado haciendo hasta ahora y va a mostrar una gran resistencia al cambio y a su forma de trabajar. Pero el problema es que cambio es realmente necesario, sino no necesitaría un nuevo sistema software. Si el analista no es capaz de comprender esto, el desarrollo se alargara mucho más tiempo del calculado, y creara una sensación de insatisfacción tanto del cliente, como del equipo constructor, que sentirá esta andando en círculos y sin sentido durante todo el proyecto.

Arquitecto


El rol de arquitecto es uno de los mas confusos que existen (asumiendo a veces roles de programador o diseñador), pero en esencia debe encargarse del sistema a un nivel "macro". Debe asegurar que el sistema encaja perfectamente en el resto de sistema de la empresa, que se esta construyen con las patrones, metodólogas y herramientas adecuadas, garantizando que el sistema presenta una continuidad de negocio con el escenario actual de la empresa y que está preparado para adaptarse a los futuros , y posiblemente desconocidos, cambios venideros. Además debe detectar los componentes reutilizables de un sistema (que son mas de los que a priori se cree) y asegurase que son creados, utilizados y conocidos, por el resto del equipo.

Diseñador


Es el responsable de convertir los requisitos obtenidos por el analista, en "algo" que se pueda traducir en software, mediante las guías e indicaciones de la arquitectura de software. Se encarga de definir el sistema en un nivel detallado y concreto. El diseñador indicara que componentes y de qué forma se relacionan dentro del sistema y en la lógica de negocio.

Programador


Es el constructor efectivo del sistema, resolviendo los requisitos mediante código fuente, que a su vez es convertirlo en dicho sistema. Debe ser experto en las tecnologías es las que está trabajando, aunque es frecuente que a veces se auto capacite según las necesidades del sistema, con éxito disparejo. Debe tener capacidad de participar en un escenario colaborativo con el resto de los codificadores

Tester


Es el encargado de validar que el software cumpla con los criterios de calidad establecidos, es decir que el software funcione. Se puede considerar que un software sea de “calidad”, en diversos aspectos incluyendo el aspecto el grafico (interacción con el usuario), el funcional (que cumpla lo requerido), o el operativo (que siga funcionando en determinadas circunstancias como carga excesivas o situaciones de uso “anormales”).

Roles en metodologías de desarrollo de software tradicionales


En las metodologías de software tradiciones, se sigue una secuencia de fases más o menos estricta (que puede repetirse en varias vueltas o ciclos). Cada fase tiene una entrada y una salida, en las primeras fases (análisis y diseño), se convierte las requisitos de usuarios, en documentación, en las fases de construcción, se “convierte” la documentación en software.

Cliente


Curiosamente el cliente no tiene gran relevancia en las metodologías tradicionales, interviene al principio de la fase de desarrollo (en la que es entrevistado), y al final al recibir el sistema construido. Pocas veces se le considera como parte del flujo de desarrollo de software, salvo por reuniones puntuales que no tienen más objetivo que garantizar que el software se sigue construyendo.

Líder de proyecto


Uno de los roles más importantes. De su capacidad de organización y gestión dependerá el éxito del proyecto. Debe coordinar al equipo para llevar a cabo el objetivo, que es la generación del sistemas en tiempo y forma.

Analista


Debido a que es el iniciador del proceso y es el que extraerá los requisitos directamente del cliente, su importancia es alta. Una mala interpretación del analista puede ocasionara una desviación importante en el proyecto. El análisis es una fase que suele alargarse bastante puesto que el cliente no suele estar presente en otras fases del desarrollo.

Arquitecto de software


En las metodologías pesadas el papel del arquitecto de software no es tan relevante, no porque la arquitectura no lo sea sino porque generalmente el sistema está pensando más como un elemento único y no se tiene un enfoque parecido a una fábrica de software. En este escenario el diseñador toma parte de las responsabilidades del arquitecto.

Diseñador


El diseñador es el puente entre el analista y los programadores, traducirá los "requisitos", en definiciones y diagramas, para que posteriormente sean convertidos en código fuente. La coherencia de sus diseños, se trasladara al sistema final, si sus diseños no son coherentes, se acara teniendo un motón de código fuente que tiene sentido como piezas individuales, pero no como un sistema integral.

Programador


Como mencionamos el programador convertirá la documentación obtenida hasta este punto en código fuente, aquí tomara decisiones relativas a la optimización, la estructuración, o a la resolución de problemas concretos relacionados con el lenguaje o la tecnologías seleccionadas.

Tester


Es parte de las secuencias de fases del desarrollo. una vez construido el sistema se pasa a pruebas y se devuelve si no son satisfechas.

Roles en metodologías de desarrollo de software agiles


Para la resolución de metodologías agiles hay varios enfoques, pero todos alzan el valor del software productivo (ya construido), y las iteraciones humanas, frente a los procesos y la documentación.

Cliente


El cliente es el elemento más importante y se considera como parte del equipo del trabajo. Hay que tener en cuenta que todo el significado y motivo de creación del sistema, es la resolución de una necesidad el cliente. El cliente interactúa de diversas formas y frecuentemente en todas las fases del proyecto

Líder de proyecto


Las responsabilidades dentro de un modelo ágil están distribuidas en un modelo mas "plano", dividiendo dichas responsabilidades entre todos los participantes del proyecto. Si bien es necesario alguien que se encargue de llevar el seguimiento y control, no suele tener un puesto diferente al del resto de sus compañeros.

Arquitecto de software


Es el que define las políticas técnicas en cuento a la creación de software, aunque más que políticas son una caja de “herramientas” de soluciones que funcionaron en determinadas circunstancias y son reusables en el futuro, para otros proyectos. Aquí se incluye el uso de patrones de software, librerías y framework. El arquitecto debe vigilas que se apliquen las políticas adecuadas en cada momento, pero con la flexibilidad necesaria para adaptar, crear o derogar políticas según sea necesario.

Analista


El contacto con el cliente es, con diferencia, mucho más frecuente en las metodologías Ágil, lo cual hace que el rol de analista sea menos crítico. A diferencia de las metodologías pesadas, se asumen una incapacidad inicial de comprender la necesidad del cliente, dicha capacidad es suplida con entregas realizadas en corto tiempo, que aportan cada vez más funcionalidad a la solución fácil, hasta que tanto cliente como desarrolladores están conformes con el resultado.

Diseñador


La formalización del diseño (en documentación) no es tan importante, debido a que si hay una buena colección de estándares, guías y arquitecturas, debiera quedar implícitamente la forma de resolver un problema. En las metodologías agiles se asumen que los requisitos van a cambiar con lo que cualquier propuesta de software debe asumir ese cambio y estar preparado. Es decir en lugar de crear un software que solucione un problema, hay que enfocarse en un software cuyo cambio no tengan un impacto excesivo en el sistema.

Programador


Los programadores son la parte más relevante en las metodologías agiles, en la que frecuentemente suele complementar su roles de programador, con los de analista y diseñador. Esto es debido a que como no hay una excesiva documentación, la necesidades de comunicación son más directas e inmediatas. Es esencial la comunicación oral y el trabajo en equipo. De igual forma se necesita que los desarrolladores tenga experiencia, sean respetuoso de los estándares y que conozcan todo las herramientas reutilizables que tienen a su disposición .

Tester


Las pruebas en las metodologías agiles de hacen de forma más frecuente y continuada, no es necesario que esté terminado el sistema para comenzar pruebas. El software está diseñado de forma que se pueda probar unitariamente e incluso podría usarse un desarrollo orientado a pruebas, esto es crear primero las pruebas y dar por satisfecha la construcción del sistema cuando todas las pruebas tengan existo. Como vemos las pruebas pueden comenzar desde muy temprano en un desarrollo ágil.

¿Cual usar?


Frecuente se dice que si tu proyecto es grande uses una metodología pesada, y si es pequeño una ágil. En lo personal no estoy de acuerdo con este razonamiento, porque parece más un temor a una metodología nueva que otra cosa, al considerar que si el proyecto es pequeño se podría corregir cualquier desviación. Yo creo que lo que define cual metodología usar, es la madurez y la capacidad de comunicación y colaboración del equipo, cuanto mayor sea mayor es la posibilidad de éxito con una metodología ágil, cuanto menor sea es mejor el uso de una metodología tradicional que garantiza que cada paso está siendo perfectamente guiado y documentado.

sábado, 9 de septiembre de 2017

Carta abierta sobre el desarrollo de software en la vida empresarial

Hace un par de años, mientras estudiaba mi maestría en Investigación en Desarrollo de Software, tuve la oportunidad de participar en un foro sobre Especificación de Sistemas Software con estudiantes que no había trabajado nunca en el desarrollo de sistemas dentro de un ambiente empresarial (o de forma profesional, es decir siempre habían sido estudiantes) y preguntaban cuanto de lo que veían en su carrera universitaria se aplicaría en el “mundo real”.

El siguiente extracto, el cual acabo de recuperar, es parte de mi participación en dicho foro, trata sobre todo de la formalización de un sistema mediante documentación previa a la construcción, aunque puede pecar de subjetivo, espero que sirva como orientación para estudiantes de Ingeniera en Software o carreras afines.

Tengo en “activo” en el mundo del desarrollo de software desde finales de los 90. He pasando por todos los puestos imaginables, desde "chico de los cafés", hasta mi puesto actual como encargado de la arquitectura de software. Te diré que yo amo esta profesión, pero en todo este tiempo he pasado por diferentes fases anímicas en cuento a las gratificaciones que me ha ofrecido.


En lo que a mí respecta, existe una brecha entre el mundo académico y el mundo empresarial. Muchas veces es muy difícil aplicar los conocimientos obtenidos en tus estudios directamente, y en “crudo”, en tu trabajo. Muchas de estos conocimientos, por otro lado, no cumplen las necesidades reales de los clientes, que son principalmente:

  •  Tener un software útil.
  •  Que su software se cree rápido, y sea fácil de modificar.
  •  Que su software no tenga errores.

Si no cumples estas expectativas, no importa que metodología, diagramas, UML y demás uses. Si no cumples estas fuera del mercado. El cliente te va a cambiar por otro que si cumpla su necesidad.

¿Qué es lo que tienes que hacer? buscar herramientas que te ayuden a cumplir con los requisitos mencionados, y además, lo más importante, que tu equipo (o el equipo donde estas) hablen el mismo idioma.

Lo mejor es estar siempre en un equipo donde exista una comunicación verbal y clara entre sus integrantes, donde se haga ruido, se discuta y se hable. Si trabajan cada uno en su lugar, con los cascos puestos, cada integrante se concentrara en la tarea que tienen asignada y no entenderá el concepto global del sistema, alargándose el desarrollo muchos más meses de lo previsto.

En cuanto al valor que le va a dar tu cliente a toda la documentación que hagas sobre su futuro sistema, es básicamente nula. El cliente quiere un software, no un documento, un UML, u otro tipo diagrama. El en cualquier caso necesita (antes de la construcción del proyecto) dos cosas:

  • El tiempo
  • El costo.

Tú (como analista) eres el que necesita documentos que garanticen que has comprendido lo que el cliente necesita, y allí es donde se convierten, dichos documentos, en una necesidad contractual, más que en una necesidad técnica.

Pero, ¿Sabes qué? El cliente no entiende que quiere hasta que lo ve. Es parecido a comprar un coche, hasta que no estás arriba, no sabes que quieres. Hasta que usuario no vea el sistema funcionando no va saber que quiere. El producto define la necesidad. Steve Jobs, por ejemplo, no hacia estudios de mercado precisamente por eso (a Ford, igualmente se le atribuye la frase “Si les hubiera preguntado a mis clientes que quieren me hubiera dicho que caballos más rápidos”).

Entonces el tema de la documentación se convierte mas en una necesidad “hacia dentro”, y no “hacia fuera”. Y allí depende más del estilo de empresa y del equipo que tengas, la necesidad de la documentación requerida.

Generalmente yo huyo de la documentación excesiva al crear un sistema, porque muchas veces es redundante, burocrática, y tiende en exceso a ser obsoleta. ¿Por qué?, porque muchas veces cambia tanto un sistema que la documentación inicial y el producto final, no se parecen en nada. Y si se parecen no será lo que el cliente quiere (por que al ver el producto se dará cuenta que quiere otra cosa).

Si quieres documentación, tienes que buscar herramientas y lenguajes que permitan llevar a la par la construcción y dicha documentación, que desde la documentación se pueda generar el código fuente y viceversa, que desde el código fuente se puede generar la documentación.

Las metodólogas agiles, de las que he hecho muy afín últimamente, dan más importancia a los productos que a la documentación. Solo hay que tener cuidado, porque a veces algún líder de proyecto, considera solo el punto de “poco documentación” de las metodologías Agiles, y se olvida de todo los demás, a lo que dan importancia dichas metodologías, y eso también lleva a un futuro desastre.

Me gustaría igual señalarte un problema que tienen los recién egresado, su trabajo acaba siendo los que llamamos “tareas de escuela”, soluciones técnicamente correctas que no tienen aplicación en el mundo real, ¿Por qué?, porque no vieron su trabajo en el contexto de un sistema real. Su meta fue programar un sistema, y esa, nunca es la meta, la meta es resolver una necesidad al cliente. En su enfoque nunca hubo un usuario manejando el sistema.

miércoles, 16 de agosto de 2017

Regla N°12 de la Ingeniería de Software: “Hay que prepararse para la lluvia cuando hace sol” (olvídate de “Si funciona no lo toques”)

Recuerdo, cuando era niño e iba a la escuela, que hubo una época de sequía que se alargó durante bastantes meses. Aquello parecía que iba a durar para siempre. Un día, no recuerdo a cuento de que, nuestro profesor de matemáticas dijo: “Pero ya falta un día menos para que llueva”. Nos quedamos anonadados ante tal afirmación, ¿Acaso sabia nuestro profesor cuando iba a llover? Nos aclaró que no tenía ni idea de cuando iba a llover, pero lo que era seguro es que llovería algún día y que cada vez faltaba menos para que llegara ese día. El tema, básicamente, es que hay eventos que van a suceder, tarde o temprano y que hay que estar preparados para ellos.

“Si funciona no lo toques”, es un refrán bastante popular y además es horrible, promueve una filosofía de conformismo e incluso de cobardía ante el cambio. Me imagino que funcionaria en algún momento, donde tu zona de confort sea enorme. En la actualidad, y particularmente en nuestro negocio, las zonas de confort tienen a hacerse muy pequeñas muy rápidamente.

¿Cuándo es el momento de “tocar” algo que funciona?, si crees que es “cuando no funcione”, estas en un error, ese es el peor momento para plantearte cambios. Por la misma circunstancia que “no funciona”, el objetivo, o la prioridad ya no es crear ningún tipo de mejora, si no conseguir que el sistema siga funcionando.

¿Por qué dejo de funcionar un sistema? Generalmente por un cambio en el ambiente en que se encuentra, ya sea un cambio tecnología o un cambio en el negocio. Con independía del tipo de cambio, lo cierto es que nuestro sistema dejo de cumplir nuestras necesidades, por lo menos durante un periodo crítico en el que ya no está siendo productivo (y en el cual, nuestros competidores si lo son).

Es por eso que conviene “tocar” los sistemas cuando estos están funcionando, “Hay que prepararse para la lluvia cuando hace sol”, de esta manera podemos realizar las mejoras, cambios y adecuaciones a nuestros sistemas, en un momento donde nuestro sistema está bien, y no debemos preocuparnos de no estar cumpliendo la producción de nuestro negocio. Si alguno no sale bien, podemos regresarnos al momento donde si funcionaba, porque tenemos esa libertad de movimiento al ser nosotros (y no un factor externo), los generadores del movimiento del cambio.

Trabajando con antelación, podemos dedicar tiempo a las cosas “importantes” y no perderlo en multitud de cosas “urgentes” que se acaban convirtiendo en una solución temporal, sobre otra soluciones temporales.

martes, 11 de julio de 2017

Curso Patrones de Software


En las últimas semanas, he estado impartiendo un curso de “Patrones de Software”, en el cual pretendía explicar una colección de patrones, a la vez que se establecían las bases para el desarrollo de un código empresarial sostenible y de alta calidad.

Los materiales del curso están en GitHub. Esperando que pudieran ser de utilidad, lo hago de código libre (tanto los ejemplos como la documentación). Se les puede dar el fin que se desee.



El temario del curso fue el siguiente:



Acerca de este documento


La misión de este documento es exponer los objetivos, mecánica y temerarios planteados para el curso de CreSer “Patrones de Software”.


Objetivos del curso


Los patrones de software son soluciones previamente establecidas (y probadas como optimas) a problemas conocidos y repetitivos dentro del desarrollo de software.

El curso de “Patrones de Software” pretende proporcionar herramientas para crear un escenario en el que se favorezca la creación de software de calidad, escalable y funcional.

A la vez que se revisan conceptos básicos para la ingeniera de software (para establecer un contexto de inicio) se estudiaran una selección de los más útiles patrones de software. Por otro lado y a modo de complemento se revisar una colección de los “peores” patrones de software, o anti-patrones (comportamiento y metodologías perjudiciales para la construcción de sistemas), de forma que sirva como elementos comparativo.


Metodología


Se distribuirá el curso en tres sesiones de tres horas cada una en las cuales, después de una introducción de los temas a plantear, se realizan talleres prácticos de los patrones de software, los cuales serán realizados en equipos de a dos ( dos personas compartiendo una computadora ).

Requisitos


Es necesario una laptop por cada dos personas, y tener conocimientos promedios de programación en C#. La computadora debe tener instalador Visual Studio 2010 o superior.




  • Les proporcionare igualmente un script de Ruby para facilitar la configuración a base de datos, si desean usarlo, deben instalarse Ruby, si no deberán hacer la configuración manualmente.


Temario


  1. Presentación de objetivos

  2. El desarrollo de software en la empresa

  3. En este apartado se trataran temas propios de la ingeniera de software y el desarrollo de software en la empresa con intención de establecer un contexto previo

    a) Acerca de la ingeniería de software


    b) Escenarios dentro del desarrollo de software


    c) Construcción de una fábrica de software


  4. Acerca de los programación orientada a objetos

  5. Se analizara los principios básicos de la programación orientada a objetos, para establecer los fundamentos solos los que se sustentan los patrones de software

    a) Principios generales de la orientación a objetos


    b) Principios SOLID



  6. Introducción a los patrones de software


  7. Breve introducción a los patrones de software, su origen y su utilidad.

    1. Breve historia de los patrones de software.
    2. Tipos de patrones de software.
    3. Anti patrones de software.

  8. Explicación de patrones de software

  9. Hediondez del código


  10. En este apartado se trata la “hediondez del código”, un concepto por el cual un software que aparentemente funciona bien, oculta graves problemas en su interior que pueden emerger en cualquier momento. Se revisaran los siguientes conceptos


  11. Anti-patrones de software

  12. Los anti-patrones de software son la mejor forma de hacer algo mal. Aquí se estudiaran con intención de evitarlos.


    Los anti-patrones para estudiar a:

    • Base de datos como comunicador de procesos.
    • Clase Gorda.
    • Re-dependencia.
    • Acoplamiento secuencial.
    • Modelo de dominio anémico.
    • YAL (Yet Another Layer, y otra capa más).
    • Ancla del barco.
    • Código espagueti.
    • Reinventar la rueda.
    • No inventado aquí.
    • Otra reunión más lo resolverá.
    • Proyecto del día de la marmota.
    • Si funciona, no lo toques.

  13. Conclusiones

domingo, 2 de julio de 2017

Ventajas económicas del desarrollo ágil de software para la empresa


Hace una semanas se me presento un curioso desafío, debía demostrar que el desarrollo ágil de software es beneficioso, pero desde el punto de vista de la empresa que va a usar los sistemas construidos y no desde el punto de vista del desarrollo o de la metodología empleada.

La explicación está basada en empresas que tienen su propio equipo de desarrollo de software, es decir empresas que tiene un negocio en particular, y un departamento de desarrollo que cree el software que sustente ese negocio.

Este escenario es complicado porque no se aprecia directamente el costo y valor del software. esto es debido a que el gasto para el desarrollo de software es realmente la nomina de los empleados del departamento y no directoramente el software en sí. Por otro lado las ganancias son atribuidas al progreso del negocio, y no a la implementación del software.

Siendo francos siempre es complicado dar el valor correcto al software, pero hay tener en cuenta que el software "siempre" tiene un costo. Las personas que crean software dedica tiempo a él, tiempo que vale dinero (Si ese tiempo no les reporta una ganancia, no solo "no" están ganando dinero, sino que están perdiendo el tiempo en el podrían estar haciendo otra actividad que les genera un beneficio). Esto aplica para todo tipo de software e incluso el software libre o gratuito, el costo del software existe, aunque al final se supla de forma indirecta, ya sea mediante donativos, prestación de servicios cobrados o la obtención de una posición en el mercado.

Tenemos dos grandes versiones del desarrollo del software, de un lado las metodologías pesadas y del otro las metodologías agiles.


Metodologías Pesadas

Se divide el sistema en fases más o menos secuenciales y de larga duración como análisis, definición, construcción, pruebas, y despliegue.

Hasta que no se llevado a cabo todo el ciclo no se entrega el producto al cliente además solo hay contacto con él en la fases de análisis y posiblemente en la diseño.

Se documenta cada paso de forma más o menos completa.


Metodologías Ágiles.

El contacto con el cliente es continuo, cada poco tiempo se entrega un software que agrega un valor al sistema, que en principio, se entrega incompleto pero funcional.

Las constantes entregas y pruebas agregan comprensión al problema y la verdadera necesidad del cliente. Cada iteración está más cerca del resultado final.

Es importante señalar que no hay una solución correcta a cada problema, sino que hay elegir la metodología mas correcta para cada tipo de circunstancia.


Ejemplo de comparación de proyecto Ágil / Pesado


Tengamos un supuesto de un proyecto de las siguientes características:

Parámetros del sistema
Valor
Comentarios
Número de personas asignadas
6
Personas involucras en el proyecto
Costo persona/mes
$ 2,000.00
Costo mensual por cada persona.
Duración (meses)
5
Duración de proyecto.
Funcionalidad a entregar
200
Cada unidad representa una funcionalidad identificada que le da valor al proyecto.
Ingreso mensual esperado
$ 10,000.00
Cantidad de dinero mensual que espero ingresar después que estén en producción el sistema.

Parámetros Calculados
Valor
Comentarios
Costo persona/Día
$ 66.67
El costo de una persona, por día
Costo total persona/Día
$ 400.00
El costo de todas las personas por día
Costo total persona/Mes
$ 12,000.00
El costo de todas las personas por mes
Costo total proyecto
$ 60,000.00
El costo total de proyecto
Ingreso mensual esperado / Funcionalidad
$ 50.00
Lo que espero ingresar por cada característica liberada

En resumen el objetivo es la construcción de un sistema, con seis personas asignadas, durante cinco meses, con un costo total para la empresa de $ 60,000.00.



Flujo de dinero con metodología pesada

Aquí no hay duda en como fluye el dinero; todo el proyecto es gasto (los seis meses) hasta la finalización, en la que comienza a generar ganancia mensual ($ 10,000.00).

Metodología Pesada
Fecha
Funcionalidad
Egreso
Ingreso
Beneficio
01/01/2018
0
0
0
0
01/02/2018
0
$ 12,000
$ -
-$ 12,000
01/03/2018
0
$ 12,000
$ -
-$ 12,000
01/04/2018
0
$ 12,000
$ -
-$ 12,000
01/05/2018
0
$ 12,000
$ -
-$ 12,000
01/06/2018
200
$ 12,000
$ 10,000
-$ 2,000
Totales
$ 60,000
$ 10,000
-$ 50,000





Flujo de dinero con metodología ágil

Aquí es mas difícil de analizar el flujo de dinero, pero supongamos que al ser una metodología ágil, se van entregando funcionalidad a nuestro cliente, de manera que se comienza a crear beneficio desde el primer mes, con lo que parte del gasto de la nomina de los codificadores es absorbido por el dinero ingresado por la aplicación (la cual no está completa al 100%)

Metodología Ágil
Fecha
Funcionalidad
Egreso
Ingreso
Beneficio
01/01/2018
0
0
0
0
01/02/2018
67
$ 12,000
$ 3,333
-$ 8,667
01/03/2018
100
$ 12,000
$ 5,000
-$ 7,000
01/04/2018
133
$ 12,000
$ 6,667
-$ 5,333
01/05/2018
167
$ 12,000
$ 8,333
-$ 3,667
01/06/2018
200
$ 12,000
$ 10,000
-$ 2,000
Totales
$ 60,000
$ 33,333
-$ 26,667




Conclusiones

La más evidente es que con la metodología ágil, al final del proyecto este nos ha constado $ 26,667, en lugar de los $ 60, 000, mientras que en la metodología pesada, no tenemos ningún benéfico hasta que el programa está completamente funcional.

Aunque el análisis mostrado aquí es puramente económico, y muy simplista en cuenta a su linealidad, al margen del tema económico, las ventajas de las metodologías agiles, están mas enfocadas en aumentar la calidad del software, y disminuir los tiempos de entrega, motivo por el cual habría de hecho una mejora económica indirecta (más que por el hecho de poder usar el software productivamente en las primeras etapas)

El archivo usado para los cálculos de los montos, se encuentra en el siguiente enlace:

jueves, 13 de abril de 2017

Referencias Culturales: Inyección de código en Rick y Morty


La inyección de código es una vulnerabilidad, por la cual un atacante consigue ejecutar un código malicioso en nuestro sistema, introduciéndolo, generalmente, a través de una entrada de datos de dicho sistema.

En el primer capítulo de Rick y Morty de la tercera temporada ( Rick & Morty - S03E01 - Rickson Break ), se ve claramente un ejemplo Inyección de código, con fatales consecuencias (para los enemigos de Rick).



Rick y Morty, es una serie de animación para adultos de Adult Swim, en la que un joven y su abuelo inventor viven aventuras a través de distintos lugares y dimensiones. En este capítulo Rick fue capturado y le están haciendo una exploración dentro de su mente (a través de sus recuerdos), para recuperar cierta información que quieren obtener sobre uno de sus inventos.

En la escena ocurre algo parecido un escalamiento de privilegios, hasta ser root , por no validar los datos de una entrada. Veamos la parte de la inyección de código en cuestión:






Bola extra. Otro ejemplo de inyección de código en Rick y Morty.

En el capítulo cuarto de la primera temporada (Rick & Morty - S01E04 - M. Night Shaym-Aliens ! ), hay una escena parecida de inyección de código, en la esta vez se intenta obtener información sobre un combustible creado por Rick. Rick es puesto en una simulación holográfica, e intentando escapar de ella acaba creando el combustible, los enemigos de Rick intentan recrear la formula sin antes hacer algún tipo de comprobación. La moraleja es “Cualquier entrada es siempre maliciosa, valida tus datos”.