¿Alguien más tiene un problema de refactorización? [cerrado]

Parece que después de haber escrito una cantidad significativa de código, tengo esta sensación de ansiedad de que no lo he hecho de la mejor manera posible, y termino continuamente refactorizando y pasando demasiado tiempo en el proyecto, o nunca hecho a veces. ¿Le pasa esto a alguien más y cómo lidias con esto?

Disfruto estos momentos cuando me pasan.

La razón: si no mirara hacia atrás en mi trabajo y pensara que hay algo que podría haber hecho mejor de lo que no estaría avanzando como desarrollador. Por lo tanto, cuando ocurran estos momentos de iluminación, abrácelos y tome nota de lo que aprendió. Considere su cronograma para el proyecto actual y, si es posible, refactorice el código, si no es posible, tome la lección y úsela en futuras implementaciones para proyectos.

De cualquier manera, ¡aprender de tus propios errores es una gran cosa!

Aquí hay algunas reglas para restringir esta actividad y hacerla más productiva:

• caja de tiempo, por ejemplo, configure el temporizador a 25 minutos
• hágalo solo cuando tenga una cobertura de prueba decente.
• Intente que su refactorización sea útil para el desarrollo de las próximas características

Parece que siempre puedes refactorizar, ¿no? Intento limitar la refactorización solo cuando intento resolver otros problemas. Por ejemplo, refactorice cuando tenga un problema de rendimiento y refactorice con ayuda para resolverlo; refactorice cuando necesite agregar nuevas funciones y la refactorización lo ayudará a resolverlo

Para ser honesto, me preocuparía más si estuviera generando enormes cantidades de código y pensando que todo es perfecto y no necesita ninguna refactorización ...

Cuando era más joven e inexperto, era muy arrogante acerca de mi capacidad de programación, y siempre tendía a imaginar que es posible diseñar y planificar muy bien, y que una vez que llegue a la etapa de implementación, simplemente lo explotaré y eso ' Todos serán perfectos.

La realidad es casi lo contrario. Algunos incluso dicen que tan pronto como comience a codificar debería estar en modo Mantenimiento. La idea aquí es que la etapa de "Implementación" del SDLC realmente no existe como tal, porque nunca debe dejar de lado la corrección de errores o la refactorización y pretender que el código que está produciendo es "fresco" y perfecto.

Dicho todo esto, supongo que ES posible obsesionarse demasiado con la refactorización. Simplemente no lo he visto todavía. Y cuanta más experiencia tenga, más creo que sería bueno que más equipos de software se negaran evidentemente a cumplir plazos ajustados y endeudarse técnicamente. Después de todo, esta es la razón más común por la cual la refactorización se deja de lado en el mundo real.

Sugeriría no depender exclusivamente de la sensación o el olor del código.

Enumere claramente qué está mal con el código y cuáles son las soluciones. En serio, escríbelo, porque querrás revisar qué tan efectivo fue tu refactor en contra de esto.

Identifique formas de dividir el refactorizador en partes alcanzables y priorícelas. Tenga la disciplina para concentrarse solo en el alcance de cada fragmento, evitando las tangentes que pueden socavar su tarea.

Además, identifique qué pruebas unitarias puede escribir contra el código existente antes de continuar. Si ya hay pruebas exhaustivas, eso es una gran cosa. La falta de pruebas unitarias representa una gran oportunidad para hacer algunas.

No hay duda de que caigo en esta trampa, pero algunas refactorizaciones son importantes para el futuro soporte / depuración.

Al escribir una pieza importante de código, es muy fácil seguir las líneas de código en el método que se está escribiendo actualmente. Cuando he completado una parte importante del código, coloco un comentario de todo: revisión de código . Luego, unos días más tarde, haré la revisión del código y refactorizaré en consecuencia. Si tengo problemas para leerlo unos días después, qué pasará en unos meses o incluso años.

Caigo en esta trampa cuando estoy aprendiendo un idioma o tecnología por primera vez. Por ejemplo, cuando aprende Java por primera vez, imagine que escribe una aplicación web con un servlet, pensando que es la forma correcta. Entonces te das cuenta de que hay jsp y piensas, oh, eso es más nuevo, probablemente sea correcto. Luego, una vez que llegue a la mitad, encontrará Struts y tal vez algunas cosas de EJB, después de lo cual encontrará spring (basado en xml) después de lo cual encontrará las geniales anotaciones @MVC, después de lo cual lo encontrará demasiado detallado y estará mimado por ¡elección entre groovy / grails y scala / lift! Esto está perfectamente bien para proyectos personales, ya que el punto generalmente es aprender y no necesariamente cumplir con una fecha límite.

Yo también solía ser refactorizador en el trabajo. Pero a medida que gané más experiencia, me volví más selectivo sobre lo que refactorizaré. Resulta que cuando sales de una empresa no llevas el código contigo, y generalmente otros ingenieros pueden destruir el código casi más rápido de lo que puedes arreglarlo.

La regla general que sigo es esta: refactorizo ​​hasta que esté tan optimizado como pueda en ese momento y luego no lo refactorizo ​​nuevamente a menos que las situaciones cambien, o más raramente si tengo una inspiración sobre alguna forma nueva y mejor de hacer cosas (por ejemplo, usando una nueva función de idioma).

Por ejemplo, una vez tuve que escribir un nuevo módulo de código para una aplicación existente. Lo escribí de cierta manera, y al día siguiente lo pensé más y pensé que podría refactorizarlo y hacerlo más abstracto, ya que estábamos bastante seguros de que necesitaría extenderse más adelante para otros usos. Así que refactoré el código. Luego, decidí que era demasiado genérico y consolidé algunas clases e interfaces que básicamente estaban haciendo lo mismo, usando Generics (C #) para obtener la misma funcionalidad. En este punto, probablemente podríarefactorizar aún más para hacerlo aún mejor, pero es "lo suficientemente bueno": el código está bien escrito, sigue patrones de diseño y conceptos de ingeniería adecuados, y es extensible. Solo lo refactorizaría nuevamente si los requisitos me obligaran a reevaluar el código, o si hubiera una función de lenguaje que pudiera hacer que el código sea más claro y / o más legible.