testing - serp - ¿Separaciones separadas de ''depuración'' y ''liberación''?
test seo tags (19)
Creo que es mejor lanzar la versión del software que tus desarrolladores realmente probaron; Por lo tanto, tiendo a eliminar el objetivo ''depurar'' del proyecto / archivo MAKE, de modo que solo hay una versión que se puede generar (y probar, depurar y publicar).
Por una razón similar, no uso ''afirmaciones'' (ver también ¿Las afirmaciones siempre son malas? ...).
Una persona argumentó que el motivo de una versión de "depuración" es que es más fácil de depurar: pero, contradice que eventualmente puede querer soportar y depurar lo que sea que haya lanzado, y entonces necesita construir una versión que Si es necesario, puede depurar ... esto puede significar habilitar los símbolos de depuración y deshabilitar algunas optimizaciones, incluso en la compilación ''liberar''.
Alguien más dijo que "esta es una mala idea"; es una política que desarrollé hace algunos años, quemada por:
- Algunos desarrolladores prueban sus versiones de depuración pero no de lanzamiento
- Errores de escritura de algunos desarrolladores que aparecen solo 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?)
- Ser llamado para depurar la versión de lanzamiento
Desde entonces, he visto más de una tienda de desarrollo seguir esta práctica (es decir, no tener versiones separadas de depuración y liberación).
¿Cuál es su política?
entonces necesitas construir una versión que puedas depurar si es necesario ... esto puede significar habilitar los símbolos de depuración y deshabilitar algunas optimizaciones, incluso en la compilación ''liberar''.
Ummm ... parece que me estás haciendo una depuración ... ¿verdad?
La parte donde saliste mal es esta declaración:
Creo que es mejor lanzar la versión del software que tus desarrolladores realmente probaron
Los desarrolladores no prueban el código. Prueba el código de prueba.
Las pruebas de tu unidad deben probar TODAS las configuraciones de compilación. No hagas que tus desarrolladores trabajen con una mano atada a la espalda, déjalos usar todas las herramientas de depuración que tienen a tu disposición. Una compilación de depuración es una de estas.
En cuanto a las aseveraciones: el uso de aserciones depende en gran medida de si usted programa o no por contrato. Si lo hace, las aserciones simplemente verifican el contrato en una compilación de depuración.
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 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 rastros 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.
- Usted no será atrapado por astutos errores de optimización
- La compilación es más simple (solo un artefacto)
Al eliminar el "objetivo de depuración", está obligando a los desarrolladores a depurar la versión de lanzamiento del software. Lo que eso probablemente significa en la práctica es dos cosas:
1) "builds de lanzamiento" tendrá deshabilitadas las optimizaciones (los desarrolladores de otherwised no pueden usar un depurador)
2) Ninguna construcción tendrá macros PREPROCESADOR especiales que alteren su ejecución.
Entonces, lo que realmente hará será fusionar las configuraciones de liberación y depuración en lugar de eliminar solo el modo "depurar".
Personalmente he hecho esto con el desarrollo de iOS sin efectos nocivos. La cantidad de tiempo invertido en nuestro código escrito es menos del 1% de lo que realmente está sucediendo, por lo que las optimizaciones no fueron contribuciones significativas. En este caso, realmente parecían causar un aumento en los errores, pero incluso si no lo hicieron, la idea de probar de una manera, y luego dar a la garantía de calidad con un código diferente introduce solo un factor más a tener en cuenta.
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 la versión son tan pequeños que no causan problemas a nadie.
Aprendí a construir la versión de lanzamiento con archivos .PDB hace mucho tiempo 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 diferente por completo. Puede comportarse como la compilación de lanzamiento (en su mayor parte), pero sigue siendo un programa diferente de la compilació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 emergencia, debe poder hacerlo de todos modos.
Creo que depende del tamaño del proyecto y qué tipo de sistema de compilación y pruebas está utilizando.
Si tiene un sistema de compilación automatizado en su lugar, y es simple ejecutar pruebas funcionales y de unidades en una compilación determinada, nunca debería tener problemas con varios tipos de compilación.
Creo que la compensación es simple: sí, con solo una compilación de lanzamiento, realmente prueba lo que se está enviando realmente. Por otro lado, usted paga un precio que facilita la depuración de sus desarrolladores y / o el rendimiento para el usuario, por lo que depende de usted comprobar ambos casos.
En la mayoría de los proyectos medianos a grandes, la facilidad de depuración asegurará un mejor producto para sus usuarios al final.
En mi compañía tenemos Debug and Release. - Los desarrolladores usan la versión de depuración para encontrar y corregir errores. - Estamos utilizando TDD, por lo que tenemos un gran paquete de pruebas que ejecutamos en nuestro servidor que prueba tanto las configuraciones de compilación de depuración como las versiones de 64/32 que también tenemos.
Entonces, si usar la configuración de "depuració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 al servidor (para ser probado posteriormente) o revisado, usamos el de "Liberar".
En mi opinión, esta discusión falta un punto muy importante:
¡Realmente depende de qué tipo de proyecto sea!
Si crea un proyecto nativo (C / C ++), se verá forzado 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 confuso para algunas aplicaciones web) que puede habilitar las funciones de registro durante el tiempo de ejecución.
Aunque un proyecto nativo de C ++ y una aplicación web de PHP obviamente no son todas las clases de proyectos que existen, espero que mi punto haya llegado.
PD: Al desarrollar C #, te topas con un caso de borde ya que aunque usar una compilación de depuración deshabilita las optimizaciones del compilador, en mi experiencia no encontrarás tantas diferencias como con C ++
Es una compensación. Dado que los ciclos de CPU son baratos y cada vez son más baratos, mientras que los ciclos humanos siguen siendo costosos, tiene mucho sentido mantener solo una versión única de un programa grande y complejo: la versión de depuración (aguilón).
Usar siempre aserciones siempre es una política más segura que nunca usarlas. Si produce versiones separadas de depuración y liberación, 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.
Esto podría ser menor, pero se suma a lo que otros han dicho aquí. Una de las ventajas de tener compilaciones de versiones de prueba de QA es que con el tiempo las capacidades de depuración y registro integradas de su software avanzarán debido a las necesidades de los desarrolladores que necesitan descubrir por qué las cosas van mal en QA.
Cuanto más necesiten los desarrolladores para depurar 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 versiones de depuración a versión a mitad del período de prueba de una versión. Tener que hacer un ciclo de control de calidad completo es algo que sucede demasiado a menudo.
Los desarrolladores trabajan con compilaciones de depuración, QA 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 aserciones adicionales. Algunos objetos contienen información adicional que no tiene uso, excepto cuando se visualiza el código en el depurador. Algunos objetos se validan periódicamente para asegurarse de que toda la información del estado sea coherente. Estas cosas hacen que la versión de depuración sea mucho más lenta, pero nos han ayudado a encontrar un sinfín de errores que habría sido un infierno encontrar en la compilación de producción.
Como dije, todas nuestras pruebas de control de calidad y rendimiento utilizan construcciones de producción, y ocasionalmente encontramos problemas que aparecen en la producción pero no en la depuración. Pero son relativamente raros, y como desarrollador, las ventajas de depurar una versión de depuración en lugar de una compilación de producción superan con creces ese problema.
Nuestra política es que los desarrolladores trabajen en compilaciones de depuración, pero TODOS los demás (control de calidad, licenciatarios, ventas, etc.) ejecutan la versión de lanzamiento. Ayer tuve que arreglar un error que solo aparecía en la versión de lanzamiento, era obvio lo que estaba sucediendo simplemente PORQUE solo aparecía en el lanzamiento
Es el primero aquí en esta tienda, y llevo aquí 18 meses más o menos.
Donde las cosas se ponen peludas es cuando la compilación Release hace cosas diferentes a la compilación de depuración. Sí, he estado en Hell y he visto esto en un código de producción muy viejo y muy ropy.
No veo ninguna razón para no tener ambos si la única diferencia entre las configuraciones son los símbolos de depuración y las optimizaciones.
Según mi respuesta en el hilo vinculado, también usamos la misma compilación para la depuración y la versión por razones muy similares. Las ganancias de rendimiento del 10% -20% del optimizador tienden a ser muy menores en comparación con las optimizaciones manuales a nivel de algoritmo. Una sola compilación elimina muchos errores potenciales. Específicamente;
Las variables no inicializadas y los pequeños desbordamientos de búfer pueden terminar con resultados muy diferentes en las versiones de depuración y de versiones optimizadas.
Incluso con la información simbólica disponible, la depuración de una versión optimizada puede ser difícil ya que el objeto no coincide con la fuente, por ejemplo, las variables pueden haberse optimizado y el código puede haber sido reorganizado. Por lo tanto, los errores reportados en versiones de versiones probadas pueden ser más difíciles de rastrear y, por lo tanto, requieren mucho tiempo.
Después de comparar construcciones optimizadas y no optimizadas según las pruebas de regresión automática, las ganancias 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 tiene mucha CPU (por ejemplo, crear y manipular modelos de gran superficie).
Si tienes un verdadero grupo de control de calidad con el que puedes contar para probarlo completamente, diría que construyes depuración hasta que te acerques al lanzamiento, y luego asegúrate de que se realice un ciclo de control de calidad completo en la misma versión que está saliendo 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 corrió un poco más lento y los archivos de registro eran bastante grandes.
Siempre construimos las dos, ni siquiera consideramos no hacerlo. Al habilitar las opciones de depuración aumenta el tamaño del código y se ralentiza el rendimiento, posiblemente no sea un problema con su tipo de software al realizar la prueba, pero ¿qué sucede si el cliente ejecuta su código más otras 5 aplicaciones ...?
Los problemas con las pruebas pueden resolverse mediante el uso de pruebas automáticas, de modo que su lanzamiento se puede probar sin esfuerzo cuando crea que está listo para ser lanzado. El hecho de que los desarrolladores o la empresa no prueben correctamente las compilaciones de lanzamiento no es un fracaso en la idea de las compilaciones de lanzamiento y depuración, sino en sus desarrolladores y / o compañía.
En su último punto, nunca me pidieron que depure una versión de lanzamiento, solo para solucionarlo ...
Siempre me suscribí al enfoque "Envíe lo que depure, para que pueda depurar lo que envía", por todos los motivos que enumera en su pregunta.
Tener construcciones separadas de depuración y liberación es una buena idea, porque facilita el desarrollo.
Pero las compilaciones de depuración deberían ser solo para desarrollo, no para pruebas. Usted prueba versiones de lanzamiento solamente. 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 liberación (pueden) generar código diferente. Piense "-DDEBUG" contra "-DNDEBUG", y "# si está definido (DEBUG)", etc.
Por lo tanto, es vital que pruebe el código que termina enviando. Si genera código diferente en las compilaciones de depuración y liberación, eso significa realizar dos pruebas, independientemente de que la misma persona lo haya probado o no.
Sin embargo, los símbolos de depuración no son un gran problema. Construya siempre con símbolos de depuración, conserve una copia del binario sin comprimir, pero libere un binario despojado. Siempre que etiquete cada binario con un número de compilación de alguna manera, siempre debe poder identificar qué binario sin comprimir corresponde al binario eliminado que debe depurar ...
Cómo pelar binarios y cargar símbolos en su depurador desde una fuente externa depende de la plataforma.
Ver esto ¿Cuál es tu opinión de programación más controvertida?
citar:
Opinión: nunca tener un código diferente entre las compilaciones "debug" y "release"
La razón principal es que el código de lanzamiento casi nunca se prueba. Es mejor tener el mismo código ejecutándose en la prueba que en la naturaleza.
aquí desarrollamos en modo de depuración y realizamos todas las pruebas unitarias en modo de lanzamiento. somos una pequeña tienda con solo unas pocas aplicaciones (menores de 12) para soporte que van desde Classic ASP, ASP.Net, VB.Net y C #. También tenemos una persona dedicada para manejar todas las pruebas, los problemas depurados se devuelven a los desarrolladores.