¿Es significativamente más costoso corregir un error al final del proyecto?

En una publicación de blog de Andrew Hay , se postuló el siguiente axioma:

Cuesta significativamente más arreglar un error al final del proyecto que corregir el mismo error anteriormente en el proyecto.

Sin embargo, esto no parece seguro, especialmente después de leer una publicación de blog sobre Less Wrong , y los datos que he visto para respaldarlo son extremadamente antiguos.

¿Sigue siendo exacto este axioma hoy?

Los únicos datos duros que he visto son Boehm y Papaccio, Comprensión y control de costos de software .

Esto se remonta a 1988 y fue un estudio de alrededor de 80 proyectos de software. Llegaron a la conclusión de que una decisión tomada temprano y corregida tarde podría costar 50-200 veces más de lo que hubiera sido si se hubiera corregido temprano. Pero el tipo de decisiones muy tempranas de las que están hablando es sobre qué sistema operativo ejecutar y qué idioma y base de datos utilizar.

Por lo tanto, esas cifras pueden ser excesivas con respecto al desarrollo de software actual. Sin embargo, ahora tenemos mucha experiencia en el campo y sabemos instintivamente que todavía es cierto hasta cierto punto.

En el extremo, sabemos que si se detecta una falla en los requisitos justo antes de que empecemos a producir, esto provoca una gran cantidad de reelaboración y el proyecto se retrasa o se cancela, donde si se hubiera detectado antes de realizar cualquier trabajo, Hubiera estado bien.

Editar: Doc Brown hace un buen punto en su comentario.

La investigación de Boehm se realizó en proyectos COBOL y FORTRAN en un momento en que los tiempos de compilación y ejecución eran ridículamente lentos. Comencé mi carrera a principios de los 90 en COBOL y el ciclo de compilación y prueba solía llevar tanto tiempo que valió la pena probar en seco el código antes de pasar por el ciclo (o al menos durante la fase de construcción, por si acaso podría atrapar algo y cancelarlo temprano, ahorrándose una hora más o menos).

A su vez, nuestros jefes solían reírse de nuestras quejas porque no hace mucho tiempo tenían que llevar una caja de tarjetas perforadas clasificadas a mano a la sala de servidores y dejarlas allí por un día.

Entonces definitivamente era más cierto entonces que ahora.

Y sin embargo, muy recientemente, he visto blogs que reutilizan la visualización de Steve McConnell de este problema ( ref , con fecha de 1996) como si ese gráfico se basara realmente en números concretos. No lo es Es una visualización, para explicar su punto simplemente.

Creo que la premisa de Morendil, en el artículo que citó el OP, es buena. La ciencia que tenemos sobre este tema es pobre y anticuada y, sin embargo, se trata como un canon. Pero también creo que se mantiene bien y suena cierto porque sabemos por amarga experiencia que todavía es cierto, al menos hasta cierto punto. Y creo que su fraseo dramático de "disciplina enferma" no le hace ningún favor.

Si bien no conozco ningún dato sólido u otra evidencia que respalde esta afirmación, como mínimo , creo que es de sentido común.

Piénselo de esta manera. Si tiene un sistema complejo con subsistemas interdependientes (como lo hacen la mayoría de las aplicaciones no triviales), piense en problemas que pueden ser el resultado de los cambios realizados en cualquiera de los sistemas. Si subsistemas han demostrado ser correcto (a través de pruebas de unidad y similares) y se fijan temprano, el número de errores que se produce debido a knock-ons solo se mitigan simplemente mediante la fijación de principios.

Además, si está solucionando errores temprano, la implementación aún está fresca en la mente del desarrollador. Dependiendo de la duración de cualquier proyecto dado, si está solucionando errores al final, el desarrollador necesitará tiempo para averiguar qué escribieron y (tal vez) cómo funcionan los subsistemas de los que depende su código. Tiempo dedicado a volver a aprender esto = $.

Dudo que sea posible llegar a una forma científicamente rígida de medir esto: hay demasiados factores involucrados, y no hay dos proyectos que sean lo suficientemente comparables para servir como algo más que estudios de caso. Sin embargo, el pensamiento lógico debería llevarte lejos. Algunos argumentos:

• La cantidad total de código en un proyecto tiende a crecer hacia el final. Cuanto más espere para corregir un error, mayor será la base de código que debe tocar.
• La calidad del nuevo código agregado a un proyecto disminuye hacia el final, al menos si hay presión (que generalmente es un hecho): una fecha límite inminente hace que las personas arrojen las mejores prácticas por la borda solo para enviar a tiempo. Esto significa que cuanto más tarde solucione un error, más código incorrecto tendrá que revisar.
• Aunque la duplicación de código generalmente está mal vista, ocurre todo el tiempo, y dado que es fácil copiar y pegar, pero difícil volver a fusionar secciones de código duplicado, la cantidad de código una vez copiado generalmente aumenta durante la vida útil de un proyecto. Más código copiado significa una mayor probabilidad de que su error se duplique y necesite ser encontrado y reparado varias veces (y, en consecuencia, una mayor probabilidad de que algunas de sus ocurrencias pasen desapercibidas).
• Arreglar un error es un cambio en una base de código; espera mejorar las cosas, pero un cambio siempre conlleva un riesgo. Un cambio que causa problemas serios en un proyecto con meses por delante debería dejar bastante margen para la gestión de daños, pero dos días antes del envío, te encontrarás con serios problemas.
• Cuanto más tiempo exista el error, más probable será que otras partes de la aplicación comiencen a depender de su mal comportamiento. Luego, cuando lo arreglas, de repente desatas un montón de errores secundarios en el código que no espera que tu función realmente proporcione los resultados documentados correctos.

Esto es algo básico aceptado por la ingeniería de sistemas, y se aplica a cualquier forma de desarrollo técnico (ya sea construir puentes, misiles, acorazados o software).

Esencialmente, el costo de las cosas aumenta aproximadamente un orden de magnitud a medida que avanza por las etapas de desarrollo.

Algo que cuesta $ 10 arreglar en el momento de concebir la idea ...

Costará alrededor de $ 100 si necesita actualizar la especificación ...

O cuesta alrededor de $ 1000 si se implementó algo y necesita hacer cambios en ese punto (y actualizar las especificaciones y obtener las aprobaciones, etc.) pero no había pasado por algún tipo de prueba formal de aceptación / venta

O cuesta alrededor de $ 10000 si se implementó algo y el cliente lo aceptó, y necesita hacer cambios en ese punto (y actualizar la especificación, y obtener las aprobaciones, y volver a probar y volver a ejecutar la aceptación y calificación del cliente, y así sucesivamente)

Y el costo después de la implementación / implementación / puesta en servicio es aún más.

Los ejemplos abundan y es fácil de entender: un sistema bancario con un cambio de alcance serio realizado después de que haya 25,000 empleados usándolo costará un paquete en tiempo de reentrenamiento ... incluso antes de considerar el alcance, la codificación, la prueba, la regresión, etc etc etc.

OBVIAMENTE su millaje variará: los costos e impactos de cambiar el sitio web de comercio electrónico de calentamiento de medias de Fred Nurke son algo diferentes a los costos de cambiar el software en una computadora de control de vuelo de la aeronave.

No tengo acceso a datos o datos concretos, por lo que solo puedo ofrecerle observaciones anecdóticas obtenidas de mis últimos 20 años en TI.

Creo que hay una gran diferencia entre la forma en que la mayoría de los desarrolladores crean software hoy en comparación con hace 20 años. Con el movimiento ágil que ha ganado tanto impulso, particularmente en los últimos 5-6 años, he visto un cambio real en las actitudes en el lugar de trabajo. Tanto es así que la calidad de lo que hacemos parece crecer a pasos agigantados cada año, y con cada proyecto a medida que aplicamos las lecciones que hemos aprendido de un proyecto a otro. Los procesos Leaner combinados con un enfoque en el desarrollo de prueba primero han pasado de ser muy controvertidos a ser comunes. Tanto es así que hoy, si no te sientes cómodo con Agile, entrarás en muchas compañías y tendrás suerte si no te muestran la puerta.

Entonces, ¿qué impacto ha tenido esto? En primer lugar, he notado que los problemas a menudo se identifican mucho antes. A menudo se da el caso de que si el problema no parece ser demasiado grande, a veces se puede suspender indefinidamente. En un puñado de casos, he visto errores que se creían triviales que se convierten en problemas serios cuando se abordan más tarde, ya que se hace evidente un problema fundamental que no se consideró en ese momento. A veces, esto puede conducir a un ciclo de arreglo prolongado, y eso puede ser costoso hasta cierto punto, pero ese costo a menudo se mide menos en términos de recursos y, más a menudo, en términos del impacto en la relación entre el cliente y el desarrollador. Los clientes se están acostumbrando a esta forma ágil de pensar, que les devuelve resultados mucho más rápido que en los viejos tiempos, con sprints de desarrollo altamente iterativos y respuesta rápida entre solicitudes e implementación, por lo que han llegado a esperar mucho de nosotros. Y en lo que respecta a los errores reales, el tiempo para solucionar un error se reduce con mayor frecuencia como resultado de tener un conjunto sólido de pruebas para soportar los cambios, y la capacidad de crear nuevas pruebas para proporcionar información y soluciones a los problemas reportados.

Entonces, en general, parece que el esfuerzo general para corregir errores se ha reducido en la mayoría de los casos si hay un conjunto robusto de pruebas y procedimientos para garantizar que las pruebas sigan siendo el foco de lo que hace el desarrollador, pero el costo real se ha desplazado de alguna manera, al menos en parte, desde la implementación a otras áreas del negocio, porque de alguna manera, el enfoque también se ha desplazado de la oferta y la demanda pura a la gestión de relaciones.

Otra cosa que se ha hecho evidente es que nuestros instintos intestinales de hace unos años, que sugerían que ser ágiles reducirían nuestros ciclos de mantenimiento, han sido probados en cierto grado, tanto correctos como incorrectos. Justo en el sentido de que las pruebas sólidas han hecho que sea más fácil depurar y corregir nuestro código en gran medida, y reducir la cantidad general de errores liberados en el código de producción, y equivocado en el sentido de que ahora estamos trabajando más duro para evitar la necesidad de mantenga el código heredado, refactorizando constantemente el código y mejorando la arquitectura de tal manera que sea cada vez más raro que necesitemos desarrollar nuevos productos completamente desde cero.

Entonces, al final, ¿qué significa esto con respecto a la pregunta del OP? Bueno, significa que la respuesta realmente no es tan simple como podríamos haber pensado alguna vez. Hace 15 años, probablemente habría respondido la pregunta como un sí, pero ahora siento que es más realista decir que realmente es demasiado difícil de medir empíricamente, porque la naturaleza de lo que hacemos para desarrollar software ha cambiado mucho desde que comenzamos a hacernos la pregunta del OP en ese momento. De alguna manera, cuanto más avancemos en nuestras técnicas y habilidades como industria, más crecerá la pregunta desde un sí definitivo, hasta un punto en el que sospecho que en un corto número de años estaremos diciendo que no importa. cuando arreglemos errores, debido a que nuestras pruebas y procesos serán mucho más robustos, el tiempo de las correcciones de errores será menos impulsado por los esfuerzos para salvar nuestros presupuestos, y más por las prioridades para satisfacer las necesidades de nuestros clientes, y el costo relativo se vuelven virtualmente sin sentido contextualmente.

Pero como digo, esta no es una evidencia sólida respaldada por datos, solo mis observaciones de los últimos años, y mi instinto me dice que habrá más sabiduría innovadora que mejorará la forma en que hacemos las cosas.

Los primeros errores se propagarán a otras partes del sistema, por lo que cuando solucione el error, se verá obligado a reescribir algunas partes del sistema que se basaron en el error en sí.

Además, con el tiempo te olvidarás de cómo se construyen algunas partes del programa y tendrás que recordarte a ti mismo. Es una forma de deuda técnica (si apresura el proyecto en una etapa temprana, tendrá problemas para terminarlo debido a los atajos que ha tomado).

Es tan simple como eso y no hay nada que probar.

Creo que está tratando de acelerar el proyecto lo más rápido posible para presentar alguna solución de trabajo a su empleado. La buena noticia es que lo tendrás muy rápido, la mala noticia es que probablemente nunca lo terminarás sin una reescritura completa si sigues escribiendo basura lo más rápido posible y planeas arreglar todo en un par de meses. Probablemente ni siquiera puedas refactorizar esto.

Bueno, probablemente no pueda darte la prueba definitiva que estás pidiendo, pero puedo relatar un incidente bastante reciente de mi trabajo.

Agregamos una característica que proporcionó capacidades de gestión de flujo de trabajo a nuestro producto. Cosas típicas de BDUF, especificaciones firmadas y aprobadas por el cliente. Implementado a espec. Quejas desde el día 1 sobre el despliegue.

No habíamos hecho un tutorial real de usabilidad con el cliente, solo habíamos aceptado lo que querían. Resultado: cientos de horas de retrabajo: análisis, diseño, implementación y control de calidad tuvieron que rehacerse. Todo porque la especificación omitió casos de uso particulares. Un error en la especificación, por así decirlo.

He visto cosas similares en trabajos anteriores cuando alguien en la cadena hace suposiciones que son diferentes de las suposiciones del usuario final. Los errores de codificación directos son relativamente fáciles de manejar si se detectan cerca de cuando ocurren, pero los errores de diseño pueden matar sistemas completos.

Si corrige el error después del lanzamiento, entonces tiene el costo de encontrarlo y corregirlo, lo que puede tomar o no más tiempo / costo para realizar el lanzamiento posterior. Sin embargo, tiene que tener en cuenta una ronda de pruebas de integración, pruebas de regresión, pruebas de UA, actividades de lanzamiento, etc. A menos que la corrección de errores se aplique con una serie de otras correcciones o una actualización de la versión, tendrá un gasto adicional para las actividades de prueba y lanzamiento que se evitarían al incluir la corrección en la versión inicial, porque estos costos se compartirían en una serie de correcciones / actualizaciones / características.

También considere el costo que causará el error en el uso, si es solo cosmético, entonces probablemente no importa, pero un error de función o rendimiento podría crear un costo con actividades de soporte o reducción de la productividad o cálculos incorrectos.

Pregúntele a Intel cuánto les costó el Pentium Bug. El Ariane 5 Rocket es otro buen ejemplo. Estos errores fueron corregidos al final del proyecto. He trabajado en un sistema donde un "intento" de lanzamiento de software tiene un presupuesto de 6 cifras. En estos casos extremos, es fácil ver el costo. En otros casos (¿la mayoría?), El costo oculta el ruido, pero sigue ahí.

No hay duda de que los errores cuestan dinero mientras existan. Un elemento, informes de defectos, toma tiempo para compilar, clasificar y cerrar como duplicado, el tiempo es dinero, por lo tanto, un error abierto crea un costo continuo. por lo tanto, debe ser que aplazar las correcciones de errores cuesta más que arreglarlas antes.

Si un error se escapa a la naturaleza, el costo tiene un salto escalonado ... ¿Es "El final del proyecto" antes o después del lanzamiento del software?

Una vez leí un artículo que tenía dos puntos interesantes (desafortunadamente las referencias que tenía desaparecieron hace mucho tiempo, así que tendré que postular aquí). El primer punto que destacaron fue que alrededor del 50% de todos los errores se introdujeron en la especificación de requisitos y que alrededor del 90% de todos los errores se encontraron durante las pruebas de UAT o del sistema.

El segundo punto que tenían era que para cada fase en el modelo V, el costo aumentaba 10 veces. Si el factor es correcto o no, me parece irrelevante, pero los errores más costosos son cuando su diseño se basa en una suposición incorrecta. Esto lleva a una gran cantidad de reescritura. Todo el código que funciona debido a esa suposición pero falla cuando se aplica la suposición correcta tendrá que ser reescrito.

He experimentado la reescritura de todo el modelo de dominio debido a una suposición incorrecta en las especificaciones de requisitos. Si dicho error se detecta temprano, es decir, al revisar las especificaciones de los requisitos, el costo es muy bajo. En este caso particular, habría tomado diez líneas de texto. En el caso de que se encuentre durante UAT (como era), el costo es sumativo (en el ejemplo dado, el costo del proyecto se incrementó en un 50%)

Sin datos estadísticos, pero experiencia personal:

El código de control del motor de cohete en el que estaba trabajando tenía una línea como powerCutoff = someCondition && debugOptions.cutoffIsAllowed;. La opción predeterminada no permitía el corte. Se suponía que la compilación 'final' eliminaría todas las opciones de depuración, por lo que la línea se modificó a powerCutoff = someCondition;.

¿Captó el error durante la revisión del código? Nosotros no La primera vez que se produjo la condición de activación en la prueba que causó un corte inesperado fue solo unos meses antes del primer vuelo.

Este error habría costado menos de una hora si hubiera sido detectado durante la revisión. Podría haber costado uno o dos días si fue detectado durante la integración, causando una sola repetición de prueba. Si fue capturado durante la calificación formal, podría haber costado una semana o dos al provocar un reinicio completo de la serie de pruebas con una nueva compilación.

Así las cosas, el costo se disparó. Primero diseñamos y realizamos pruebas para determinar si la unidad de vuelo podría incluso desencadenar la condición. Después de que se determinó que era una posibilidad real, hubo un costo para la ingeniería, la administración y el análisis del cliente de la mejor solución, lanzando la nueva compilación, creando y ejecutando un nuevo plan de prueba de regresión, pruebas del sistema en múltiples unidades y simuladores. En general, costó miles, si no decenas de miles de horas hombre. Además de los 15 minutos originales para hacer el cambio de código correcto.

Lamentablemente, como muchas cosas, depende.

Si un mensaje de diálogo está mal escrito, puede ser 'trivial' arreglarlo (actualizar cadena, reconstruir / empaquetar, volver a desplegar). O si un diseño necesita actualización, una modificación a un archivo .css puede ser suficiente.

Si el error es que la salida de un método crítico que tiene una especificación de más de 100 páginas y la prueba es incorrecta, entonces la investigación en sí puede llevar horas o días. Esto es a lo que se refiere el antiguo 'axioma' y a lo que, entre otras cosas, TDD y ágil está tratando de evitar (fallar temprano y claramente, hacer un progreso incremental seguro, yada).

Desde mi experiencia reciente con equipos multi-scrum en un solo proyecto, los 'errores' generalmente son problemas de fusión / integración que solo aparecen al cierre de un lanzamiento a medida que las ramas de características se promueven a estables. Estos son los peores, ya que los conflictos a menudo requieren apoyo entre equipos mientras los equipos están apurados para terminar sus propios objetivos, pero no sé si son más caros que otros errores, ya que ocurren cuando ocurren: tarde el lanzamiento, pero lo más pronto posible. Eso es lo que los hace los peores.