debugging - que - Tratando con objetos de Dios
what is an object in grammar (7)
Eso me recuerda mi trabajo actual y la primera vez que me uní. No me permitieron volver a escribir nada porque tenía el mismo argumento: "¡Estas clases son tan grandes y están mal escritas! Nadie podría entenderlas y mucho menos agregarles nuevas funcionalidades".
Entonces, lo primero que haría es asegurarme de que haya pruebas exhaustivas detrás de las áreas que usted está buscando cambiar. Y al menos entonces tendrás la oportunidad de cambiar el código y no tener (demasiados) argumentos (con suerte). Y mediante pruebas, me refiero a probar los componentes funcionalmente con pruebas de integración o aceptación y asegurarme de que esté 100% cubierto. Si las pruebas son buenas, entonces debería poder cambiar el código con confianza al dividir la clase grande en otras más pequeñas, deshacerse de la duplicación, etc.
Trabajo en un equipo de tamaño mediano y me encuentro con estos archivos de clase dolorosamente grandes de forma regular. Mi primera tendencia es atacarlos con un cuchillo, pero eso generalmente empeora las cosas y me pone en un mal estado de ánimo.
Por ejemplo, imagine que acaba de recibir un servicio de Windows para trabajar. Ahora hay un error en este servicio y necesita averiguar qué hace el servicio antes de que pueda tener alguna esperanza de solucionarlo. Abre el servicio y ve que alguien decidió usar solo un archivo para todo. El método de inicio está ahí, el método Stop, los temporizadores, todo el manejo y la funcionalidad. Estoy hablando de miles de líneas de código. Los métodos bajo cien líneas de código son raros.
Ahora, suponiendo que no pueda volver a escribir toda la clase y estas clases de dioses sigan apareciendo, ¿cuál es la mejor manera de lidiar con ellas? ¿Dónde comienzas? ¿Qué intentas lograr primero? ¿Cómo lidias con este tipo de cosas y no solo quieres obtener todo lo nuevo?
Si tiene alguna estrategia solo para controlar su temperamento, eso también es bienvenido.
Consejos hasta ahora:
- Establecer cobertura de prueba
- Código plegable
- Reorganizar los métodos existentes
- Documentar el comportamiento como descubierto
- Apuntar a la mejora incremental
Editar:
Charles Conway recomienda un podcast que resultó ser muy útil. enlazar
Michael Feathers (chico en el podcast) comienza con la premisa de que tenían mucho miedo de simplemente sacar un proyecto del control de la fuente y simplemente jugar con él directamente y luego descartar los cambios. Puedo decir que soy culpable de esto.
En esencia, dijo que tomara el objeto sobre el que desea obtener más información y que simplemente comenzara a separarlo. Descubre sus dependencias y luego descárgalas. Síguelo a donde quiera que vaya.
Un gran consejo Tome la clase grande que se usa en otros lugares y pídala que implemente una interfaz emtpy. Luego tome el código usando la clase y haga que cree una instancia de la interfaz. Esto le dará una lista completa de todas las dependencias de esa clase grande en su código.
Incluso si no puede refactorizar el archivo, intente reorganizarlo. Mueva métodos / funciones para que estén organizados al menos lógicamente dentro del archivo. Luego ponga muchos comentarios explicando cada sección. No, no ha vuelto a escribir el programa, pero al menos ahora puede leerlo correctamente, y la próxima vez que tenga que trabajar en el archivo, tendrá muchos comentarios escritos por usted (lo que significa que lo hará). ser capaz de entenderlos) que lo ayudará a manejar el programa.
Lo primero que haría es escribir algunas pruebas unitarias para enmarcar el comportamiento actual, suponiendo que ya no existan. Luego comenzaría en el área donde tengo que hacer el cambio y trataré de limpiar ese método, es decir, refactorizar el código de trabajo antes de introducir cambios. Use técnicas comunes de refactorización para extraer y reutilizar métodos de métodos largos existentes para hacerlos más comprensibles. Cuando extrae un método, busque otros lugares en el código donde exista un código similar, ponga esa área en el casillero y reutilice el método que acaba de extraer.
Busque grupos de métodos que "cuelguen juntos" y que puedan dividirse en sus propias clases. Escriba algunas pruebas de cómo deberían funcionar esas clases, construya las clases usando el código existente como una plantilla si es necesario, luego sustituya las nuevas clases en el código existente, eliminando los métodos que reemplazan. Una vez más, usa tus pruebas para asegurarte de que no estás rompiendo nada.
Mejore lo suficiente el código existente para que sienta que puede implementar su nueva característica / solución de una manera limpia. Luego, escriba las pruebas para la nueva característica / solución e implemente para pasar las pruebas. No sientas que tienes que arreglar todo la primera vez. Intente una mejora gradual, pero siempre deje el código mejor de lo que lo encontró.
Me he encontrado con esta situación también.
Personalmente imprimo (sí, puede ser muchas páginas) el código primero. Luego dibujo un recuadro alrededor de secciones de código que no forman parte de ningún "bucle principal" o que son solo funciones auxiliares y me aseguro de que entiendo estas cosas primero. La razón es que probablemente sean referidos muchas veces dentro del cuerpo principal de la clase y es bueno saber lo que hacen
En segundo lugar, identifico los algoritmos principales y los descompongo en sus partes usando un sistema de numeración que alterna entre números y letras (es feo pero funciona bien para mí). Por ejemplo, podría estar viendo parte de un algoritmo 4 "niveles" profundos y la numeración sería 1.b.3.e o alguna otra cosa horrible. Tenga en cuenta que cuando digo niveles, no me refiero directamente a los bloques de control o al ámbito necesariamente, pero donde he identificado los pasos y subpasos de un algoritmo.
Entonces solo se trata de leer y volver a leer el algoritmo. Cuando comienzas parece mucho tiempo, pero creo que al hacerlo desarrolla una capacidad natural para comprender una gran cantidad de lógica a la vez. Además, si descubres un error atribuido a este código, al haberlo desglosado visualmente en papel antes de tiempo, te ayudará a "navegar" el código más adelante, ya que ya tienes una especie de mapa en tu cabeza.
Si tus jefes no creen que entiendes algo hasta que tengas alguna forma de UML que lo describa, un diagrama de secuencia UML podría ayudar aquí si pretendes que los niveles de subpasos son diferentes "clases" representadas horizontalmente, y de principio a fin es representado verticalmente de arriba a abajo.
¡Ay! Suena como el lugar donde uso para trabajar.
Eche un vistazo a Working effectivly con el código heredado . Tiene algunas gemas sobre cómo lidiar con un código atroz.
Recientemente, DotNetRocks hizo un show sobre cómo trabajar con código heredado. No hay una píldora mágica que la haga funcionar.
El mejor consejo que he escuchado es comenzar a ajustar gradualmente el código en las pruebas.
Code Folding puede ayudar. Si puedes mover cosas dentro de la clase gigante y organizarlas de una manera un tanto lógica, entonces puedes poner pliegues alrededor de varios bloques.
Oculte todo y vuelva a un paradigma C, excepto con pliegues en lugar de archivos separados.
Siento tu dolor. Abordé algo así una vez para un proyecto de hobby que implica el procesamiento de datos de TV digital en mi computadora. Un compañero en un foro de hardware había escrito una herramienta increíble para grabar programas, ver todo lo que estaba encendido y más. Además, él había hecho un trabajo increíblemente vital para resolver los errores en las señales de transmisión real que violaban el estándar. Él había hecho un trabajo increíble con la programación de hilos para asegurarse de que no importaba qué pasara, no perdería esos paquetes en tiempo real: en un viejo Pentium, podía grabar cuatro transmisiones simultáneamente mientras jugaba Doom y nunca perdía un paquete. En resumen, este código incorporó una tonelada de gran conocimiento. Esperaba tomar algunas piezas e incorporarlas a mi propio proyecto.
Obtuve el código fuente. Un archivo, 22,000 líneas de C, sin abstracción . Pasé horas leyéndolo; hubo todo este gran trabajo, pero todo fue hecho mal. No pude reutilizar ni una sola línea, ni siquiera una sola idea.
No estoy seguro de cuál es la moraleja de la historia, pero si me hubiera visto obligado a usar estas cosas en el trabajo, habría pedido permiso para cortar piezas de una en una, construir pruebas de unidad para cada pieza, y finalmente hacer crecer una cosa nueva y sensata fuera de las piezas. Este enfoque es un poco diferente a tratar de refactorizar y mantener un ladrillo grande en su lugar, pero preferiría haber dejado intacto el código heredado y tratar de abrir un nuevo sistema en paralelo.