unit-testing - refactorizar - tdd wikipedia
¿Cómo se refactoriza? (14)
Me preguntaba cómo otros desarrolladores comienzan a refactorizar. ¿Cuál es tu primer paso? ¿Cómo difiere este proceso (refactorización) si usted refactoriza el código que no es suyo? ¿Escribes pruebas mientras refactorizas?
Refactorizar sin Prueba Unitaria es peligroso. Siempre tenga una prueba unitaria. Si cambia algo sin tener una buena prueba, podría estar seguro para una parte del código, pero algo en otro lugar podría no tener el mismo comportamiento. Con Unit Testing usted protege cualquier cambio.
Refactorizar otro código también está bien, pero el extremo no. Es normal que alguien más no programe como tú. No es "amable" cambiar cosas porque lo hubieras hecho de la otra manera. Simplemente refactorizando si es realmente necesario.
Refactorizo mientras escribo código nuevo, usando pruebas unitarias. También refactorizaré el código anterior, ya sea el mío o el de otra persona, si los métodos son demasiado largos, o las variables mal nombradas, o veo la duplicación, etc.
Elimino la duplicación, que unifica los patrones de pensamiento inherentes al código. Refactoring necesita lograr esas dos cosas. Si tiene un código que hace lo mismo dos veces, vuelva a configurarlo en una ubicación común, unificando la abstracción. Si tienes el mismo literal en tres lugares, ponlo en una constante, unificando el propósito. Si tiene el mismo grupo de argumentos, asegúrese de que siempre se utilicen en el mismo orden o, mejor aún, colóquelos en una estructura común, unificando grupos de información.
Comience con las pruebas unitarias y luego use herramientas de refactorización automatizadas. Si la refactorización no se puede automatizar, no se trata de una transformación mecánica del código, por lo que no se trata de una refactorización. Las pruebas unitarias son para asegurarse de que realmente solo está realizando transformaciones mecánicas de una base de código a una equivalente.
Depende mucho de mis objetivos. Como se ha dicho, necesita pruebas unitarias para asegurarse de que su refactorización no haya roto nada, y si lo tiene tiene que dedicar tiempo a solucionarlo. En muchas situaciones, pruebo la solución existente y, si funciona, la envuelvo en lugar de refactorizarla, ya que esto minimiza la posibilidad de una interrupción.
Si tengo que refactorizar, por ejemplo, recientemente tuve que transferir un montón de C ++ basado en ASCII a UNICODE, tiendo a asegurarme de tener buenas pruebas de regresión que funcionen tanto para el usuario final como para el nivel de la unidad. Una vez más, trato de utilizar herramientas en lugar de refactorizar manualmente, ya que esto es menos propenso a errores, y los errores que obtienes son sistemáticos y no aleatorios.
Estoy de acuerdo con los otros carteles cuando está refactorizando el código que escribió.
Si es un código que no escribiste, y especialmente si hay mucho, comenzaría usando herramientas como fxCop, Análisis de código de Visual Studio, DevPartner. Estoy seguro de que hay otras buenas. Le darían ideas sobre dónde comenzar y cuáles son los problemas de codificación más comunes. También haría pruebas de estrés para ver dónde están los cuellos de botella, por lo tanto, el mayor retorno en su esfuerzo por mejorar el código.
Me encanta refactorizar mi código, pero es posible exagerar. Si no está realmente mejorando el rendimiento de la aplicación, o está mejorando seriamente la legibilidad del código, probablemente debería detenerse. Siempre existe la posibilidad de introducir nuevos errores cuando se refactoriza, especialmente si está trabajando sin pruebas unitarias.
Para mí, lo primero es asegurarme de que el código llegue a todas las mejores prácticas de nuestra oficina. Por ejemplo, usando estrictas advertencias y manchas para nuestros scripts de Perl.
Si hay problemas de eficiencia o velocidad, concéntrese en ellos. Cosas como encontrar un algoritmo mejor o encontrar una forma mejor de hacer lo que está haciendo el ciclo de anidado cuádruple.
Y, por último, ver si hay una forma de hacer que el código sea más legible. Esto normalmente se logra al convertir 5 pequeños scripts que hacen cosas similares en 1 módulo (clase).
Tomo mierda y la hago menos horrible. :-)
Seriamente. No refactor para crear una nueva funcionalidad. La refactorización ocurre antes de cosas nuevas. Si no hay pruebas, escribo pruebas para asegurarme de que no estoy rompiendo nada con mi refactorización. Si hay pruebas, las uso. Si las pruebas son insuficientes, podría escribir más pruebas, pero lo consideraría separado de la refactorización y lo haré primero.
El primer paso para mí es notar que puedo abstraer algo y hacerlo más general (y útil en otros lugares que necesitan la funcionalidad ahora), o me doy cuenta de que algo es malo y podría ser mejor (subjetivo). No me refactorizo a la generalidad sin una razón. El principio de YAGNI se aplica.
Tenemos el concepto de propiedad compartida, por lo que el código siempre es mío, es posible que no lo haya escrito, pero no lo considero al refacturar. Puedo tratar de entender las cosas antes de decidir que es necesario refactorizar si el propósito no está claro, aunque eso casi siempre es una razón para refactorizar por sí mismo.
Soy mucho más reacio a refactorizar el código escrito por otros que a refactorizar el mío.
Si ha sido escrito por uno de mis predecesores, generalmente refactorizo solo dentro de una función. Por ejemplo, podría reemplazar una instrucción if con un interruptor. Algo mucho más grande que eso generalmente está fuera del alcance y no está dentro del presupuesto.
Para mi propio código, suelo refactorizar mientras escribo, cuando algo se ve feo o comienza a oler. Es mucho más fácil solucionarlo ahora en lugar de esperar a que cause problemas en el futuro.
- no refactorice nada no trivial que no tenga ya pruebas unitarias
- escribir pruebas unitarias, luego refactorizar
- refactorizar piezas pequeñas y volver a ejecutar las pruebas con frecuencia
- deje de refactorizar cuando el código esté SECO * limpio
* DRY = No te repites
Lea el libro de Martin Fowler " Refactorización "
Por cierto, ese es el enlace de Amazon Exec de Martin Fowler, si te estás preguntando :)
Primer paso: identificar un olor a código.
Segundo paso: Considere implementaciones alternativas y cuáles son las compensaciones y cuáles acepto en términos de cuál es "mejor".
Tercer paso: implementar una mejor solución.
Esto no difiere si el código es mío o no, ya que a veces puedo volver sobre el código que escribí hace meses o años y se verá como código de otra persona. Puedo escribir pruebas si estoy creando nuevos métodos o no hay pruebas adecuadas para el código, IMO.
¿Cuál es tu primer paso?
El primer paso es ejecutar las pruebas unitarias para asegurarse de que todas pasen. De hecho, puede perder una gran cantidad de tiempo buscando cuál de sus cambios rompió la prueba a si ya se había roto antes de modificar el código.
¿Cómo difiere este proceso si usted refactoriza el código que no es suyo?
Ciertamente estoy haciendo pasos más pequeños cuando refactorizo el código que no escribí (o el código que escribí hace mucho tiempo). También puedo verificar la cobertura de la prueba antes de continuar, para evitar depender de pruebas unitarias que siempre pasan ... pero que no prueban el área en la que estoy trabajando.
¿Escribes pruebas mientras refactorizas?
Normalmente no, pero puedo agregar nuevas pruebas en las siguientes circunstancias (lista no exhaustiva):
- la idea de una nueva prueba brilla en mi mente ( "¿Qué pasa si ...?" - escribe una prueba para saber)
- descubrir el agujero en la cobertura de la prueba
también depende de la refactorización que se realiza. Al extraer una función, puedo crear una nueva prueba si puede invocarse de una manera diferente a como estaba antes.
Aquí hay algunos consejos generales:
Lo primero es mantener una lista de los olores del código detectados al trabajar en el código. Esto permite liberar la mente de la carga de recordar lo que se vio en el código. También,
La regla de oro nunca es refactor cuando las pruebas de la unidad no pasan completamente.
Refactorice cuando el código esté estable, antes de agregar algo que sepa que se verá afectado por una futura refactorización, antes de integrarlo y sobre todo antes de decir lo que hizo .
En ausencia de pruebas unitarias, deberá poner a prueba la parte del código que desea refactorizar. Si las pruebas unitarias son demasiado difíciles de realizar, como suele ser el caso, puede crear pruebas de caracterización , tal como lo recomienda Michael Feathers en Working Effectively with Legacy Code . En resumen, son pruebas de extremo a extremo que le permiten precisar el comportamiento actual del código (que no se supone que funciona perfectamente todo el tiempo).
No tengas miedo de hacer pasos de bebé . No hagas dos cosas al mismo tiempo. Si comenta algo que requiera refactorización, anótelo, no lo arregle en este momento, incluso si parece muy fácil.
Regístrese muy a menudo, cuando pasen las pruebas. Para que pueda revertir una mala refactorización sin perder lo que se hizo antes.
Tenga en cuenta que la refacturación no agrega valor a su cliente (esto puede discutirse), pero el cliente no le paga a refactorizar. Una regla de oro es refactorizar antes de hacer cambios o agregar nuevas capacidades al código.
Enfoque general
Puedo comenzar echando un vistazo al software (componente) desde la vista de pájaro. El análisis de dependencia y las herramientas gráficas son de gran ayuda aquí (ver secciones posteriores). Busco un círculo en las dependencias de nivel de paquete o de nivel de clase, y también alternativamente para las clases con demasiadas dependencias. Estos son buenos candidatos para refactorizar.
Herramientas del oficio
Herramientas de análisis de dependencia: