Lidiando con un proyecto interminable no reparable

Tenemos un sitio web grande (más de 1200 horas) que tiene mucha deuda técnica. Esto se debe principalmente a las siguientes razones (habituales).

1. Múltiples programadores que van y vienen durante el desarrollo.
2. Cambio de especificaciones durante el desarrollo.
3. Numerosas funcionalidades agregadas agregadas (en poco tiempo).

El cliente quiere muchas nuevas funcionalidades, y eso básicamente se reduce a trabajar en este proyecto semanalmente durante más de 10 horas.

Debido a la deuda técnica, pasamos MUCHAS horas arreglando o investigando problemas, que generalmente encuentran su origen en uno de los siguientes:

1. Un insecto descarado y tonto que hace llorar a la gente.
2. Una nueva característica da como resultado lo anterior porque no habíamos previsto todos los lugares donde la nueva característica tendría influencia.
3. Algunos otros problemas que hemos enfrentado (por ejemplo, migración del servidor, actualizaciones)

Tenemos problemas a diario y hemos tratado de hacer lo siguiente para detener esto:

1. Se creó documentación técnica sobre la importación, el pago y el funcionamiento general del sitio web.
2. Tenga una reunión al comienzo de la semana, discutiendo los problemas o mejoras actuales y cómo deben abordarse.
3. Tener un plan de prueba. El programador A prueba B, B prueba C y C prueba A. Entonces nuestro Gerente de Proyecto lanzará algunas pruebas. Con respecto al impacto de la función, la lanzamos a un entorno de ensayo y dejamos que el cliente compruebe por sí mismo.

El problema es que los problemas continúan sucediendo ... y de alguna manera no podemos controlarlo. Las nuevas características aún causan errores, y los errores antiguos siguen diciendo hola. De alguna manera, tal vez debido al tamaño del proyecto, parece que no podemos controlarlo.

Supongo que hay muchos programadores trabajando en proyectos más grandes que esto. Por eso llego a mi pregunta:

¿Qué podemos hacer, o qué es lo que hacer para evitar estos problemas en grandes proyectos?

Edición menor, información adicional:

1. Usamos control de versiones (SVN).
2. Tenemos proceso de desarrollo DTAP.

Interpretaré al abogado del diablo, habiendo visto con demasiada frecuencia cómo resulta esto: no puedes lidiar con eso. Te garantizo que eres el único que realmente ve un problema real con el sistema tal como es, o de lo contrario no tendrías que preguntar cómo lidiar con él porque la cultura de la empresa sería una para eliminar errores y corregir el código siempre que sea posible, es decir, operar cómo trabajan profesionales reales.

Apuesto a que es demasiado grande para comenzar a escribir pruebas unitarias, porque no ha tenido a nadie que sepa cómo hacer pruebas unitarias antes que usted (y con suerte a otras personas en su equipo) y es imposible saber por dónde comenzar, y tal vez incluso imposible prueba porque se basa en implementaciones exactas y datos concretos, por lo que llevaría demasiado tiempo quitar todo eso a las interfaces, simulaciones, stubs y similares para poder probarlo en primer lugar. También apuesto a que no puedes ir y refactorizar lo que necesita ser refactorizado porque está demasiado ajustado y, dado que no hay pruebas, quién sabe qué se romperá al corregir un código incorrecto. En resumen, es probable que se vuelva demasiado canceroso para solucionarlo seriamente, pero, por supuesto, no se puede cortar y comenzar de nuevo.

Estás peleando una batalla perdida, mi amigo. O te cansarás de la frustración y eventualmente dejarás de hacerlo o te volverás loco, o si te quejas por el tiempo suficiente tratando de hacer que otros se den cuenta de los problemas, pensarán que el único problema eres tú y se te mostrará la puerta.

Las pruebas de unidad son un buen punto de partida si no está haciendo ninguna. Como mínimo, lo protegerán de agregar nuevos errores al corregir errores antiguos.

El control de fuente también ayuda, a menos que no lo esté usando. Las características de culpa y registro, en particular, son maravillosas para determinar cómo / por qué se cometió un código defectuoso.

Por parte del cliente, descubrí que discutir el precio y los retrasos (largos) tan pronto como se soliciten cambios / características adicionales funciona razonablemente bien, al igual que cobrar por el tiempo que pasa discutiendo / diseñando ellos. Con frecuencia, los clientes decidirán que pensándolo bien pueden esperar.

(Por el contrario, si inmediatamente profundiza en las especificaciones y las ideas de implementación con él, generalmente lo prepararán para un "oh, pensé que habíamos acordado que haría esto de todos modos" o (peor, después de varios días de retraso y adelante sobre los detalles) "pero mira, ¡ya está diseñado y nosotros lo que discutimos no suena tan difícil!")

Por último, pero no menos importante, descubrí que, siendo sincero, que solo leo correos electrónicos una vez al día (al llegar al trabajo) y que tengo un teléfono para cualquier cosa más urgente, conduce a un tremendo aumento de la productividad.

Le sugiero que agregue algunas pruebas basadas en CI, principalmente en las áreas que se rompen con mayor frecuencia. Eso lo ayudará a aumentar la calidad a medida que se trabaja en el proyecto.

También se hace más evidente qué áreas / funcionalidades se rompen con mayor frecuencia y, por lo tanto, es más fácil decidir qué partes necesitan refactorización, o al menos una mayor prueba.

Agregar más pruebas manuales conlleva el riesgo de que el proyecto vaya por el camino equivocado en términos de $$$ y tiempo requerido por función agregada.

Algunas revisiones de código son buenas, pero tal vez eso sea parte del esquema de prueba A-> B-> C-> A. (¿Tal vez la revisión del código en la otra dirección?)

Déjame arrojarte una fábula. Estabas caminando con una persona más temprano en el día por la calle y llegas a tu destino. La persona con la que camina rápidamente descubre que perdió su anillo en algún lugar del camino, por lo que ambos deciden dar marcha atrás y buscarlo. La persona con la que camina se detiene rápidamente en una farola y comienza a mirar frenéticamente. Dices: "¿Por qué estás mirando el poste de la lámpara cuando creo que podrías haberlo perdido cuando cruzamos el callejón?". Él responde: "Lo sé, pero la luz es mejor aquí".

He estado en esta situación más de unas pocas veces y he notado algunos puntos en común. Este tipo de proyectos de mantenimiento de pesadilla generalmente se ejecutan en un entorno de procesos pesados ​​con una gran supervisión y mejoras de procesos impuestas por la administración. No digo que las mejoras de procesos sean algo malo, pero la mayoría de las veces, los tipos de mejoras de procesos que la Administración normalmente querrá promulgar tienen dos puntos clave.

1) Generalmente no interrumpen la política de la oficina y el equilibrio de poder. 2) Tienen éxito en crear la ilusión de control por parte de la gerencia en lugar de atacar el corazón del problema.

La opinión de la gerencia de "la luz es mejor aquí" generalmente se expresa al decir: "Cada nueva característica debe tener una especificación tecnológica detallada" o "Tengamos una reunión de estado cada hora todos los días para discutir problemas y cómo superarlos".

Ninguna de estas cosas realmente golpea el corazón de los problemas y puede que solo disminuyan la productividad, pero ciertamente validan la ilusión de control por parte de la gerencia.

Los únicos cambios verdaderos que puede ayudar a impulsar serían aquellos que sacudan las cosas. Sin embargo, sospecho que su monstruosidad de un sitio web es probablemente irreparable en este momento y que estaría más adelante para rediseñar y reescribir. Sin embargo, para el futuro, puede tener en cuenta la importancia de la metodología ágil, la integración continua, el desarrollo basado en pruebas, las revisiones de código y las especificaciones de requisitos comerciales que están reguladas bajo estrictos procedimientos de control de cambios para ayudar a minimizar el desplazamiento del alcance sin ajustes de programación.

Este tipo de cambios realmente requieren un cambio en la forma de pensar a nivel gerencial y en toda mi experiencia profesional nunca me he dado cuenta de que esto suceda sin algún tipo de cambio en el nivel gerencial medio. Espero que no sea demasiado desalentador, ya que deberías intentar lo que es correcto, independientemente de si estás luchando una batalla cuesta arriba, porque es probable que encuentres una feroz resistencia por parte de las personas que aman el statu quo.

He estado en el mismo lugar hace algún tiempo. Ya no estoy gracias a dos reglas simples:

• Cada semana, uno o dos días se dedican a arreglar / reescribir la mayoría de las partes peludas de la aplicación. Sin búsqueda de errores, sin desarrollo de nuevas características.
• Mientras implementamos nuevas funciones, nos esforzamos por hacerlo bien, incluso cuando pasamos más tiempo del esperado.

El único problema es lograr que otras personas los respeten. La parte fácil sorprendentemente fue el cliente. Realmente no puedo explicar por qué, pero de alguna manera lo hemos convencido de que cuando trabajamos en una función un poco más, es mejor para todos. Respetar la primera regla resulta ser más problemático, pero también creemos que nos ayuda mucho. Garantiza un progreso constante a medida que mejoran las diferentes partes de la aplicación.

Revisiones de código. Pruebas unitarias. Real QA Testing. Proceso de recopilación de especificaciones y desarrollo incremental: estas son algunas cosas que deberían resolver la mayoría de sus problemas.

Tampoco permita que los clientes hagan ping directamente a sus desarrolladores: esta suele ser la forma más improductiva de resolver problemas. Contrata a un buen administrador de programas que formará la interfaz entre tus clientes y desarrolladores. Su trabajo sería conocer el producto de principio a fin, el estado actual, las direcciones futuras, etc. Cada vez que el cliente quiera otra función nueva, debería poder proporcionar la lista actual de artículos y mostrar a los clientes lo que se eliminará si se toma esta nueva solicitud.

El proceso es malo cuando se usa muy poco o demasiado. Creo que estás en el estado anterior.

Como menciona Deni, si puede agregar pruebas unitarias al proyecto, esto lo ayudaría. Realice una prueba que cubra una parte del sistema que está a punto de cambiar / arreglar, y cuando realice el código de refactorización, use esa prueba como guía para asegurarse de que no está rompiendo nada.

Además, clasifique las partes más rotas del código. Intente incluir a los más afectados en una lista de riesgos y administre esos riesgos de forma independiente. Intente hacerse una idea de la cantidad de código roto que hay en la base de código preguntando dónde ocurren más los errores. Luego puede enumerar el área afectada por el recuento de errores (o los problemas reportados, lo que sea que funcione para usted).

Remendar y limpiar el código llevará tiempo, pero si cada desarrollador del equipo puede dejar el código un poco más limpio, antes de que lo toques, con el tiempo la base de código mejorará. Si buscas una solución rápida y de estilo militar, resuélvela ahora, dudo que haya algo práctico (o recomendado) que pueda ayudarte.

Salud. Jas

Escriba especificaciones funcionales claras; pedagógicamente, así que si puedes soportarlo y revisar la funcionalidad con esas especificaciones regularmente. Cuanto menos idea tenga un desarrollador sobre lo que se supone que está desarrollando, menos posibilidades hay de que sea de la forma en que se supone que se desarrolle.

Antes de comenzar a escribir código, realice un trabajo de diseño inicial; No es necesario que sea perfecto, ni enorme, ni que contenga UML, pero debe describir una solución bastante sólida para el problema que debe resolverse. Por lo que puedo decir, cuanto menos software esté planeado, peor será. Discuta el diseño antes de comenzar a trabajar en él.

Cuando comienzas a trabajar en un área del código que es claramente mala y que realmente obstaculiza tu progreso; deje de agregarle, retroceda del problema, descubra cómo podría rediseñar la arquitectura para que los obstáculos no estuvieran allí y para que fuera más adaptable en el futuro. Cuanto más tiempo lo deje antes de abordar la deuda técnica, más difícil será resolverla sin una reescritura completa. Yo diría que es una cosa exponencial.

Diseñe pruebas que prueben el comportamiento y no se acoplen estrechamente a su arquitectura. No está muy de moda, pero diría que no comience a probar hasta que el verdadero propósito de su código sea claro. Específicamente, no comience a probar hasta que sepa lo que realmente quiere probar; OMI, una prueba mal pensada es peor que ninguna prueba. Y cuantas más pruebas tenga, más difícil será cambiar su código internamente. Trate su código de prueba como lo haría con el código de producción; necesita ser planeado y bien escrito.

Haga revisiones de código regulares / diarias: se trata más de la comprobación de la cordura para asegurarse de que el desarrollador no se haya desviado demasiado. Use estas sesiones para planificar los próximos días de trabajo. Puede haber días en que estos tarden 5 minutos o 1 hora; El punto es mantener un diálogo abierto y dar a los desarrolladores la oportunidad de discutir su trabajo con otros desarrolladores y buscar asesoramiento. Realice algunas sesiones de emparejamiento sobre partes difíciles del código o prototipos de ideas, pero permita que las personas tengan su propio tiempo para trabajar.

Facilite la creación e implementación de su código. Intenta mantener cortos los tiempos de construcción. Cuanto más fácil sea construir, más se construirá, más rápido será, más se construirá.

Adopte estándares de codificación y aplíquelos rígidamente. Esto debería abarcar todo, desde dónde debería vivir un proyecto en el sistema de archivos hasta la carcasa de un const privado. Esto puede parecer inútil y molesto, pero los buenos hábitos son la piedra angular de un proceso de desarrollo.

Básicamente, no creo que el proceso que utilices sea tan importante, las modas van y vienen. Lo que realmente importa es que eres profesional sobre cómo desarrollas el software y que eres disciplinado en tu práctica.

Comenzaría diseñando y automatizando pruebas de humo y lanzándolas al entorno de CI. Esos deberían ser funcionales. Cuando el cliente le dice que algo debería funcionar de manera regular, solicite que lo anote, para que pueda consultarlo más adelante. Cuando vea una cierta solución en el software, haga preguntas y, tan pronto como reciba las respuestas, incorpórelas a la base de conocimiento y hágalas trazables.

Asegúrese de que la funcionalidad básica para casos positivos funcione. Luego comience a construir pruebas incrementales para el manejo incorrecto de datos, colocando defectos donde se considere necesario. Tenga una discusión larga y profunda sobre las prioridades, y haga que el gerente de pruebas lo sepa, para que pueda asignar el tiempo de prueba en consecuencia. No intente automatizar todo, pero tan pronto como algunos casos de prueba tengan sentido para ser automatizados, no lo dude.

En general, utilice las pruebas para aumentar la confianza en el producto, y no como la herramienta que aumentará la calidad al instante. Sé tranquilo, pero asertivo :). Tal vez intente volverse ágil, pero solo si de manera absoluta y positiva puede contratar un PM certificado. Introducir a Agile por una persona que no conoce a Agile, probablemente matará el proyecto.