¿Compilaciones separadas de 'depuración' y 'lanzamiento'?

https://stackoverflow.com/questions/420343

05-07-2019
|

Pregunta

Creo que es mejor lanzar la versión del software que sus desarrolladores realmente probaron; Por lo tanto, tiendo a eliminar el objetivo de 'depuración' del proyecto / archivo MAKE, de modo que solo se pueda compilar una versión (y probarla, depurarla y publicarla).

Por una razón similar, no uso 'aserciones' (ver también Son aserciones siempre mal? ...).

Una persona allí argumentó que la razón de una versión de 'depuración' es que es más fácil de depurar: pero, sostuve que eventualmente querrás apoyar y depurar lo que sea que hayas liberado, por lo que debes construir una versión que puede depurar si es necesario ... esto puede significar habilitar símbolos de depuración e inhabilitar algunas optimizaciones, incluso en la versión 'lanzamiento'.

Alguien más dijo que " esta es una idea tan mala " ;; Es una política que desarrollé hace algunos años, después de haber sido quemada por:

Algunos desarrolladores están probando sus versiones de depuración pero no de versión
Errores de escritura de algunos desarrolladores que solo aparecen en la versión de lanzamiento
La compañía está lanzando la versión de lanzamiento después de una prueba inadecuada (¿es alguna vez completamente adecuada?)
Al ser llamado para depurar la versión de lanzamiento

Desde entonces, he visto a más de otra tienda de desarrollo seguir esta práctica (es decir, no tener versiones de depuración y lanzamiento separadas).

¿Cuál es tu política?

Solución

Esto podría ser menor, pero se suma a lo que otros han dicho aquí. Una de las ventajas de tener versiones de prueba de control de calidad es que con el tiempo las capacidades integradas de depuración y registro de su software avanzarán debido a las necesidades de los desarrolladores que necesitan descubrir por qué las cosas van mal en el control de calidad.

Cuanto más necesiten los desarrolladores para depurar las versiones de lanzamiento, mejores herramientas tendrán más adelante cuando los clientes comiencen a tener problemas. Por supuesto, no hay razón para que los desarrolladores trabajen en versiones de lanzamiento como parte del ciclo de desarrollo.

Además, no conozco ninguna compañía de software que tenga ciclos lo suficientemente largos como para permitirse la sobrecarga de cambiar el control de calidad de la depuración para lanzar versiones a mitad del período de prueba de una versión. Tener que hacer un ciclo completo de control de calidad es algo que muy a menudo sucede muy raramente.

Otros consejos

Tener compilaciones separadas de depuración y lanzamiento es una buena idea, porque facilita el desarrollo.

Pero las compilaciones de depuración deben ser solo para desarrollo, no para pruebas. Pruebas solo compilaciones de lanzamiento. Y no usa desarrolladores para probar esas compilaciones, usa probadores.

Es una política simple que ofrece lo mejor de ambos mundos, IMO.

Editar: En respuesta a un comentario, creo que es obvio que las compilaciones de depuración y lanzamiento (pueden) generan un código diferente. Piense " -DDEBUG " vs. " -DNDEBUG " ;, y " # si se define (DEBUG) " ;, etc.

Por lo tanto, es vital que pruebe el código que termina enviando. Si do genera un código diferente en las compilaciones de depuración y lanzamiento, eso significa probar dos veces, independientemente de si la misma persona lo probó o no.

Sin embargo, los símbolos de depuración no son un problema tan grande. Construya siempre con símbolos de depuración, guarde una copia del binario sin tirar, pero libere un binario con tiras. Siempre que etiquetes cada binario con un número de compilación de alguna manera, siempre deberías poder identificar qué binario no marcado corresponde al binario eliminado que debes depurar ...

Cómo quitar binarios y cargar símbolos en su depurador desde una fuente externa depende de la plataforma.

Nuestra política es que los desarrolladores trabajen en las compilaciones de depuración, pero TODOS los demás (QA, BA, ventas, etc.) ejecutan la versión de lanzamiento. Ayer tuve que arreglar un error que solo apareció en el lanzamiento, compilarlo, era obvio lo que estaba sucediendo simplemente PORQUE solo apareció en el lanzamiento

Es el primero aquí en esta tienda, y he estado aquí alrededor de 18 meses.

Donde las cosas se ponen difíciles es cuando la versión Release hace cosas diferentes a la versión de depuración. Sí, he estado en el infierno y he visto esto en un código de producción muy antiguo y muy ropy.

No veo ninguna razón para no tener ambas si la única diferencia entre las configuraciones son los símbolos de depuración y las optimizaciones.

por lo que necesita construir una versión que puedes si es necesario depurar ... esto puede significar habilitar símbolos de depuración, y deshabilitar algunas optimizaciones, incluso en la compilación 'release'.

Ummm ... suena como si estuvieras haciendo una versión de depuración para mí ... ¿verdad?

La parte en la que salió mal es esta declaración:

Creo que es mejor liberar el versión del software que tu los desarrolladores realmente probaron

Los desarrolladores no prueban el código. Prueba el código de prueba.

Las pruebas unitarias deben probar las configuraciones de compilación TODAS . No haga que sus desarrolladores trabajen con una mano atada detrás de la espalda; permítales usar todas las herramientas de depuración que tienen a su disposición. Una construcción de depuración es uno de estos.

Con respecto a las afirmaciones: el uso de las afirmaciones depende en gran medida de si usted programa o no por contrato. Si lo hace, entonces las aserciones simplemente verifican el contrato en una compilación de depuración.

Según mi respuesta en el hilo vinculado, también utilizamos la misma compilación para depurar y liberar por razones muy similares. Las ganancias de rendimiento del 10% -20% del optimizador tienden a ser muy pequeñas en comparación con las optimizaciones manuales a nivel de algoritmo. Una sola compilación elimina muchos errores potenciales. Específicamente;

Las variables sin inicializar y los pequeños desbordamientos de búfer pueden terminar con resultados muy diferentes en la depuración y en las versiones de lanzamiento optimizadas.
Incluso con la información simbólica disponible, depurar una versión optimizada puede ser difícil ya que el objeto no coincide con la fuente, p. las variables pueden haberse optimizado y el código se puede reorganizar. Por lo tanto, los errores reportados en las versiones de lanzamiento probadas pueden ser más difíciles y, por lo tanto, llevar mucho tiempo rastrearlos.

Al comparar las compilaciones optimizadas y no optimizadas en las pruebas de regresión automatizadas, las mejoras de rendimiento proporcionadas por la optimización no proporcionan suficiente valor adicional para tener dos compilaciones en mi caso. Vale la pena señalar que el software que desarrollo es muy hambriento de CPU (por ejemplo, crear y manipular modelos de grandes superficies).

Al desarrollar con Java, odio las versiones sin depuración. Cuando se lanza una excepción, no se obtiene información de línea que hace que sea difícil o incluso imposible rastrear errores. Además, la diferencia de tiempo de ejecución entre depuración y no depuración es de alrededor del 5% con Java 5 o posterior, por lo que esto realmente no es un problema y con los discos duros de hoy, el tamaño ya no importa.

En el lado positivo, usando versiones de depuración:

Los seguimientos de pila contienen toda la información que necesita
Las variables pueden ser examinadas
Si tiene un problema en la producción, simplemente puede adjuntarlo al proceso en ejecución sin tener que detener el servidor primero para instalar una versión de depuración.
No te atraparán los errores de optimización inteligente
La construcción es más simple (solo un artefacto)

Los desarrolladores trabajan con compilaciones de depuración, control de calidad y todos los demás usan la versión de lanzamiento, que llamamos "producción". La principal ventaja de esto es que en la compilación de depuración, podemos agregar muchos códigos y afirmaciones adicionales. Algunos objetos contienen información adicional que no tiene ningún uso, excepto al ver el código en el depurador. Algunos objetos se validan periódicamente para asegurarse de que toda la información del estado sea consistente. Estas cosas hacen que la versión de depuración sea mucho más lenta, pero nos han ayudado a encontrar un sin fin de errores que hubieran sido un infierno encontrar en la compilación de producción.

Como dije, todas nuestras pruebas de control de calidad y rendimiento utilizan compilaciones de producción, y ocasionalmente nos encontramos con problemas que aparecen en la producción pero no en la depuración. Pero son relativamente poco frecuentes, y como desarrollador, las ventajas de depurar una compilación de depuración en lugar de una compilación de producción superan con creces ese problema.

Creo que depende del tamaño del proyecto y del tipo de sistema de compilación y prueba que esté utilizando.

Si tiene un sistema de compilación automatizado y es sencillo ejecutar pruebas unitarias y funcionales en una compilación determinada, entonces nunca debería tener ningún problema con varios tipos de compilación.

Siempre me he suscrito al " Enviar lo que depura, para que pueda depurar lo que envía " enfoque, por todas las razones que enumeras en tu pregunta.

En mi opinión, a esta discusión le falta un punto muy importante:

¡Realmente depende de qué tipo de proyecto sea!

Si crea un proyecto nativo (C / C ++), de hecho se verá obligado a crear compilaciones de depuración, simplemente porque las optimizaciones del compilador pueden hacer que la depuración sea casi imposible en algunos casos.

Si crea aplicaciones web, es posible que desee simplemente tener una compilación (aunque "compilar" es bastante engañosa para algunas aplicaciones web) que puede habilitar las funciones de registro durante el tiempo de ejecución.

Aunque un proyecto C ++ nativo y una aplicación web PHP obviamente no son todos los tipos de proyectos que existen, espero que mi punto de vista se haya difundido.

P.S .: Al desarrollar para C #, te encuentras con un caso de borde ya que aunque usar una versión de depuración desactiva las optimizaciones del compilador, en mi experiencia, no encontrarás tantas diferencias como con C ++

aquí desarrollamos en modo de depuración y hacemos todas las pruebas unitarias en modo de lanzamiento. Somos una tienda pequeña con solo unas pocas aplicaciones (menores de 12 años) que admiten desde ASP clásico, ASP.Net, VB.Net y C #. También tenemos una persona dedicada para manejar todas las pruebas, los problemas depurados son devueltos a los desarrolladores.

Siempre construimos ambos, ni siquiera consideramos no hacerlo. Habilitar las opciones de depuración aumenta el tamaño de su código y ralentiza el rendimiento, posiblemente no sea un problema con su tipo de software durante las pruebas, pero qué pasa si el cliente está ejecutando su código más otras 5 aplicaciones ...

Los problemas con las pruebas se pueden resolver mediante el uso de pruebas automatizadas para que su versión de lanzamiento se pueda probar sin esfuerzo cuando crea que está listo para la versión. El hecho de que sus desarrolladores o compañía no prueben adecuadamente las versiones de lanzamiento no es un fracaso en la idea de las versiones de lanzamiento y depuración, sino en sus desarrolladores y / o compañía.

En su último punto, nunca me han pedido que depure una versión de lanzamiento, solo para solucionarlo ...

Es una compensación. Dado que los ciclos de CPU son baratos y cada vez más baratos, mientras que los ciclos humanos siguen siendo caros, tiene mucho sentido mantener solo una versión única de un programa grande y complejo: la versión de depuración (gable).

Usar aserciones siempre es una política más segura que nunca usarlas. Si produce versiones separadas de depuración y lanzamiento, vuelva a habilitar los símbolos #define d que necesite para garantizar que las aserciones también estén habilitadas en la versión de lanzamiento.

Creo que la compensación es simple: sí, con solo una versión de lanzamiento, realmente se prueba lo que realmente se está enviando. Por otro lado, usted paga un precio en la facilidad de depuración para sus desarrolladores y / o rendimiento para el usuario, por lo que depende de usted verificar ambos casos.

En la mayoría de los proyectos de tamaño mediano a grande, la facilidad de depuración garantizará un mejor producto para sus usuarios al final.

Vea esto ¿Cuál es su opinión de programación más controvertida?

cita:

Opinión: Nunca jamás tengas diferente   código entre " depuración " y " liberar "   compilaciones

La razón principal es ese lanzamiento   El código casi nunca se prueba. Mejor   tener el mismo código ejecutándose en la prueba   como es en la naturaleza.

Al eliminar el " objetivo de depuración " ;, obliga a los desarrolladores a depurar la versión de lanzamiento del software. Lo que eso significa en la práctica es dos cosas:

1) " versiones de lanzamiento " tendrá optimizaciones deshabilitadas (otros desarrolladores no pueden usar un depurador)

2) Ninguna compilación tendrá macros PREPROCESSOR especiales que alteren su ejecución.

Entonces, lo que realmente harás es fusionar las configuraciones de lanzamiento y depuración en lugar de eliminar solo la " depuración " modo.

Yo personalmente he hecho esto con el desarrollo de iOS sin efectos negativos. La cantidad de tiempo que pasamos en nuestro código escrito es menos del 1% de lo que realmente está sucediendo, por lo que las optimizaciones no contribuyeron de manera significativa. En este caso, realmente parecieron causar un aumento en los errores, pero incluso si no lo hicieron, la idea de probar de una manera, y luego dar control de calidad con un código diferente introduce solo un factor más a considerar con los problemas.

Por otro lado, hay casos en que las optimizaciones son necesarias, donde son útiles e incluso cuando hay suficiente tiempo para probar ambas. Por lo general, los cambios entre la depuración y el lanzamiento son tan pequeños que no causa ningún problema a nadie.

Si tiene un grupo de control de calidad real en el que se puede confiar para probar el problema en su totalidad, yo diría que debe hacer construcciones de depuración hasta que se acerque al lanzamiento, y luego asegurarse de que se realice un ciclo completo de control de calidad en la misma construcción que sale por la puerta.

Aunque en al menos un caso lanzamos algo que todavía tenía algún código de depuración. La única consecuencia fue que se ejecutó un poco más lento y que los archivos de registro eran bastante grandes.

En mi empresa tenemos Debug y Release. - Los desarrolladores utilizan la versión de depuración para encontrar y corregir errores correctamente. - Estamos usando TDD y, por lo tanto, tenemos un gran conjunto de pruebas que ejecutamos en nuestro servidor que prueba las configuraciones de compilación tanto de depuración como de lanzamiento, así como las compilaciones 64/32 que también tenemos.

Por lo tanto, si utiliza la función " depurar " la configuración ayuda a un desarrollador a encontrar un error más rápido, no hay razón para no usarlo: cuando el código ingresa en el servidor (para probarlo más a fondo) o revisado, usamos la " Versión " uno.

Hace mucho tiempo aprendí a construir la versión de lanzamiento con archivos .PDB para poder depurar la versión de lanzamiento. Lo que muchos programadores tienden a olvidar es que cuando ejecuta la versión de depuración, con todas las optimizaciones desactivadas, está depurando un programa completamente diferente. Puede comportarse como la versión de lanzamiento (en su mayor parte), pero sigue siendo un programa diferente al de la versión de lanzamiento.

Además, la depuración de la versión de lanzamiento no es tan difícil. Y si obtiene un volcado de memoria, debe poder hacerlo de todos modos.

Licenciado bajo: CC-BY-SA con atribución

No afiliado a StackOverflow