assert - logica - aserciones sinonimo
¿Cuándo deberían las aserciones permanecer en el código de producción? (17)
Hay una discussion continua en comp.lang.c ++ moderada sobre si las aserciones, que en C ++ solo existen en compilaciones de depuración de forma predeterminada, deberían mantenerse en el código de producción o no.
Obviamente, cada proyecto es único, por lo que mi pregunta aquí no es tanto si se deben mantener las afirmaciones, sino en qué casos es recomendable / no una buena idea.
Por afirmación, quiero decir:
- Un control en tiempo de ejecución que prueba una condición que, cuando es falsa, revela una falla en el software.
- Un mecanismo por el cual el programa se detiene (quizás después de un trabajo de limpieza realmente mínimo).
No estoy hablando necesariamente de C o C ++.
Mi propia opinión es que si usted es el programador, pero no posee los datos (que es el caso con la mayoría de las aplicaciones de escritorio comerciales), debe mantenerlos activados, ya que una confirmación errónea muestra un error y no debe ir. con un error, con el riesgo de corromper los datos del usuario. Esto te obliga a probar con fuerza antes de enviar y hace que los errores sean más visibles, por lo tanto, es más fácil detectarlos y repararlos.
¿Cuál es su opinión / experiencia?
Aclamaciones,
Carl
Vea la pregunta relacionada here
Respuestas y actualizaciones
Hola Graham,
Una afirmación es un error, puro y simple, y por lo tanto debe manejarse como tal. Como se debe manejar un error en el modo de lanzamiento, entonces realmente no necesita aserciones.
Es por eso que prefiero la palabra "error" cuando hablo de aserciones. Hace las cosas mucho más claras. Para mí, la palabra "error" es demasiado vaga. Un archivo faltante es un error, no un error, y el programa debería tratarlo. Intentar desreferenciar un puntero nulo es un error, y el programa debe reconocer que algo huele mal a queso.
Por lo tanto, debe probar el puntero con una aserción, pero la presencia del archivo con el código normal de manejo de errores.
Levemente fuera del tema, pero un punto importante en la discusión.
Como advertencia, si sus afirmaciones entran en el depurador cuando fallan, ¿por qué no? Pero hay muchas razones por las que un archivo no podría existir y que están completamente fuera del control de su código: derechos de lectura / escritura, disco lleno, dispositivo USB desenchufado, etc. Como no tiene control sobre él, creo que las afirmaciones son no es la forma correcta de lidiar con eso.
Carl
Thomas,
Sí, tengo Code Complete y debo decir que estoy totalmente en desacuerdo con ese consejo en particular.
Supongamos que el asignador de memoria personalizado se vuelve defectuoso y pone a cero un trozo de memoria que todavía utiliza otro objeto. Resulta que pongo a cero un apuntador que este objeto se desreferencia regularmente, y una de las invariantes es que este puntero nunca es nulo, y usted tiene un par de aserciones para asegurarse de que se mantenga así. ¿Qué haces si el puntero de repente es nulo? ¿Simplemente si () a su alrededor, esperando que funcione?
Recuerde, estamos hablando de código de producto aquí, por lo que no hay interrupción en el depurador e inspeccionar el estado local. Este es un error real en la máquina del usuario.
Carl
A menos que los perfiles muestren que las afirmaciones están causando problemas de rendimiento, les digo que también deberían permanecer en la versión de producción.
Sin embargo, creo que esto también requiere que manejes las fallas de afirmación de forma algo graciosa. Por ejemplo, deberían dar como resultado un tipo general de diálogo con la opción de (automáticamente) reportar el problema a los desarrolladores, y no solo salir o bloquear el programa. Además, debe tener cuidado de no usar afirmaciones para las condiciones que realmente permite, pero que posiblemente no le agraden o que considere no deseadas. Esas condiciones deberían ser manejadas por otras partes del código.
Considero que es mejor manejar todos los errores que están en el alcance, y usar afirmaciones para las suposiciones que estamos afirmando SON verdaderas.
es decir, si su programa está abriendo / leyendo / cerrando un archivo, entonces no poder abrir el archivo está en el alcance: es una posibilidad real, que sería negligente ignorar, en otras palabras. Entonces, eso debería tener un código de comprobación de errores asociado.
Sin embargo, digamos que su fopen () está documentado como siempre devolviendo un manejador de archivo válido y abierto. Abre el archivo y lo pasa a su función readfile ().
Esa función readfile, en este contexto, y probablemente de acuerdo con su especificación de diseño, puede asumir que obtendrá un archivo ptr válido. Por lo tanto, sería un desperdicio agregar código de manejo de errores para el caso negativo, en un programa tan simple. Sin embargo, al menos debe documentar la suposición, de alguna manera, garantizar de alguna manera, que este es realmente el caso, antes de continuar su ejecución. No se debe suponer REALMENTE que siempre será válido, en caso de que se llame incorrectamente, o se copie / pegue en algún otro programa, por ejemplo.
Entonces, readfile () {assert (fptr! = NULL); ..} es apropiado en este caso, mientras que el manejo de errores en toda regla no lo es (ignorando el hecho de que leer el archivo requeriría de todos modos algún sistema de manejo de errores).
Y sí, esas afirmaciones deberían permanecer en el código de producción, a menos que sea absolutamente necesario para deshabilitarlas. Incluso entonces, probablemente debas inhabilitarlos solo dentro de las secciones críticas para el rendimiento.
Deje las afirmaciones activadas en el código de producción, a menos que haya medido que el programa se ejecuta significativamente más rápido con ellos apagados.
si no vale la pena medir para demostrar que es más eficiente, entonces no vale la pena sacrificar la claridad para una apuesta de rendimiento. "- Steve McConnell 1993
En mi C ++, defino REQUIRE (x) que es como assert (x), excepto que arroja una excepción si la aserción falla en una compilación de lanzamiento.
Como una afirmación fallida indica un error, se debe tratar con seriedad incluso en una compilación de versión. Cuando importa el rendimiento de mi código, a menudo usaré REQUIRE () para el código de nivel superior y assert () para el código de nivel inferior que debe ejecutarse rápidamente. También uso REQUIRE en lugar de assert si la condición de falla puede ser causada por datos pasados desde un código escrito por un tercero, o por corrupción de archivos (de manera óptima, diseñaría el código específicamente para comportarme bien en caso de corrupción de archivos, pero no siempre tienes tiempo para hacer eso.)
Dicen que no debe mostrar esos mensajes afirmar a los usuarios finales porque no los entenderán. ¿Asi que? Los usuarios finales pueden enviarle un correo electrónico con una captura de pantalla o algún texto del mensaje de error, que le ayuda a depurar. Si el usuario simplemente dice "se estrelló", tiene menos capacidad para solucionarlo. Sería mejor que se envíe automáticamente los mensajes de falla de aserción a través de Internet, pero eso solo funciona si el usuario tiene acceso a Internet y puede obtener su permiso.
LAS ASERCIONES no son errores y no deben tratarse como errores. Cuando se lanza una afirmación, esto significa que hay un error en su código o, alternativamente, en el código que llama a su código.
Hay algunos puntos para evitar habilitar las aserciones en el código de producción: 1. No desea que su usuario final vea un mensaje como "ASSERTION failed MyPrivateClass.cpp line 147. El usuario final NO es usted QA engineer. 2. ASSERTION might influenciar el rendimiento
Sin embargo, hay una razón importante para dejar las afirmaciones: ASSERTION puede influir en el rendimiento y el tiempo, y lamentablemente esto a veces importa (especialmente en los sistemas integrados).
Tiendo a votar por dejar la afirmación en el código de producción, pero asegurándome de que estas afirmaciones impresas no estén expuestas al usuario final.
~ Yitzik
La mayoría de las veces, cuando uso assertion en java (la palabra clave assert) agrego automáticamente algunos códigos de producción. Según el caso, puede ser un mensaje de registro, una excepción ... o nada.
Según mi opinión, todas tus afirmaciones son críticas en la versión dev, no en la versión de producción. Algunos de ellos deben mantenerse, otros deben descartarse.
Las afirmaciones nunca deberían permanecer en el código de producción. Si una afirmación particular parece que podría ser útil en el código de producción, entonces no debería ser una aserción; debería ser una verificación de error de tiempo de ejecución, es decir, algo codificado de esta manera: if( condition != expected ) throw exception .
El término "aseveración" ha pasado a significar "un control de tiempo de desarrollo que no se realizará en el campo".
Si comienzas a pensar que las afirmaciones pueden llegar al campo, inevitablemente también comenzarás a hacer otros pensamientos peligrosos, como preguntarse si realmente vale la pena hacer una afirmación determinada. No hay afirmación que no valga la pena. Nunca debería preguntarse "¿debo afirmar esto o no?" Solo debería preguntarse "¿Hay algo que olvidé afirmar?"
Nuestro software de servidor de base de datos contiene aserciones de producción y de depuración. Las aserciones de depuración son solo eso: se eliminan en el código de producción. Las aserciones de producción solo ocurren si (a) existe alguna condición que nunca debería existir y (b) no es posible recuperarla de manera confiable desde esta condición. Una afirmación de producción indica que se ha encontrado un error en el software o que se ha producido algún tipo de corrupción de datos.
Como se trata de un sistema de base de datos y almacenamos datos potencialmente críticos para la empresa, hacemos todo lo que podemos para evitar datos corruptos. Si existe una condición que puede hacer que almacenemos datos incorrectos, inmediatamente hacemos valer, revertimos todas las transacciones y dejamos el servidor.
Habiendo dicho eso, también tratamos de evitar afirmaciones de producción en rutinas de desempeño crítico.
Nunca los mantengo en el código de rendimiento crítico.
Permítame citar el código completo de Steve McConnell. La sección de Afirmaciones es 8.2.
Normalmente, no desea que los usuarios vean mensajes de aserción en el código de producción; Las aserciones son principalmente para uso durante el desarrollo y mantenimiento. Las afirmaciones normalmente se compilan en el código en el momento del desarrollo y se compilan a partir del código para la producción.
Sin embargo, más adelante en la misma sección, se da este consejo:
Para código altamente robusto, afirme y luego maneje el error de todos modos.
Creo que siempre que el rendimiento no sea un problema, deje la aserción, pero en lugar de mostrar un mensaje, haga que escriba en un archivo de registro. Creo que ese consejo también está en Code Complete, pero no lo estoy encontrando ahora mismo.
Raramente utilizo las afirmaciones para cualquier otra cosa que compile la verificación del tipo de tiempo. Usaría una excepción en lugar de una aserción simplemente porque la mayoría de los lenguajes están diseñados para manejarlos.
Ofrezco un ejemplo
file = create-some-file();
_throwExceptionIf( file.exists() == false, "FILE DOES NOT EXIST");
en contra
file = create-some-file();
ASSERT(file.exists());
¿Cómo manejaría la aplicación la afirmación? Prefiero el método de try catch para lidiar con errores fatales.
Si desea conservarlos, reemplácelos con manejo de errores. Nada peor que un programa que acaba de desaparecer. No veo nada de malo en tratar ciertos errores como errores graves, pero deben dirigirse a una sección de su programa que esté equipada para tratar con ellos recopilando datos, registrándolos e informando al usuario que su aplicación ha tenido alguna condición no deseada y está saliendo.
Si incluso está pensando en dejar las afirmaciones en producción, probablemente esté pensando en ellas mal. El objetivo de las afirmaciones es que puedes desactivarlas en producción, ya que no son parte de tu solución. Son una herramienta de desarrollo, utilizada para verificar que sus suposiciones son correctas. Pero cuando ingresa en la producción, ya debe tener confianza en sus suposiciones.
Dicho esto, hay un caso en el que presentaré las afirmaciones en producción: si encontramos un error reproducible en la producción que nos resulta difícil reproducir en un entorno de prueba, puede ser útil reproducir el error con las afirmaciones activadas. en producción, para ver si proporcionan información útil.
Una pregunta más interesante es esta: en su fase de prueba, ¿cuándo desactiva las afirmaciones?
Siempre que se manejen como cualquier otro error, no veo ningún problema. Tenga en cuenta que las afirmaciones fallidas en C, como en otros idiomas, saldrán del programa, y esto no suele ser suficiente para los sistemas de producción.
Hay algunas excepciones: PHP, por ejemplo, le permite crear un controlador personalizado para fallas de aserción para que pueda mostrar errores personalizados, hacer un registro detallado, etc. en lugar de simplemente salir.
Una afirmación es un error, puro y simple, y por lo tanto debe manejarse como tal.
Como se debe manejar un error en el modo de lanzamiento, entonces realmente no necesita aserciones.
El principal beneficio que veo para las aserciones es un salto condicional: son mucho más fáciles de configurar que la exploración a través de las ventanas de VC para configurar algo que requiere una línea de código.
Veo afirma como pruebas unitarias en línea. Útil para una prueba rápida mientras se desarrolla, pero en última instancia esas aserciones deben refactorizarse para probarse externamente en pruebas unitarias.
Las afirmaciones son comentarios que no se vuelven obsoletos. Documentan qué estados teóricos están destinados y qué estados no deberían ocurrir. Si se cambia el código para que los estados permitan el cambio, el desarrollador se informará pronto y debe actualizar la afirmación.