¿Alguien podría explicar las ventajas de eliminar (o mantener) el código no utilizado?

He escuchado muchas veces que el código no utilizado debe eliminarse del proyecto. Sin embargo, no me queda claro "¿por qué?".

Mis puntos para no borrar eso son:

• El código ya está escrito y se dedican esfuerzos
• El código se puede probar en un entorno sintético y real
• Si está bien organizado (agrupado, paquete separado, poco acoplado, etc.), no le molesta en el análisis general del código o la refactorización
• El código puede usarse en el futuro
• Cuando se elimina, el autor puede sentirse incómodo

¿Alguien podría explicar las ventajas de eliminar (o mantener) el código no utilizado?

Estas son algunas de las razones por las que se debe eliminar el código no utilizado:

• Para cualquier persona nueva que trabaje en un proyecto, no solo debe comprender el código de trabajo, sino que también debe comprender el material no utilizado. Esto es tiempo perdido y crea confusión.

• Existe el peligro de que en algún momento alguien haga un cambio que involucre inadvertidamente el código 'inactivo' y pueda introducir errores. Sé que ha sucedido en proyectos en los que he trabajado.

• El mantenimiento de cualquier código es una carga administrativa. Al conservar el código redundante antiguo, esa carga aumenta. Por ejemplo, fusionar cambios en la rama principal se vuelve más difícil porque hay más código para trabajar y más posibilidades de cometer un error.

• Lo que sucede con el tiempo es que se agrega más y más código antiguo sin usar a la base de código. Esto aumenta la confusión, los posibles malentendidos y los gastos administrativos.

• Es muy poco probable que el código no utilizado se vuelva a utilizar. Con el tiempo, esa posibilidad de reutilización disminuye. Si el código debe eliminarse y se considera lo suficientemente importante, entonces el código se puede ramificar y documentar.

• Es comprensible cualquier sentimiento personal que pueda tener un codificador sobre el código en el que haya trabajado duro. Pero parte de ser profesional requiere que esos pensamientos se dejen de lado para el bien mejor. El tiempo no representa a nadie y no hay lugar para preservar el código histórico en una base de código que funcione.

@suspectus ha hecho un excelente trabajo al presentar las razones para eliminar el código; Me gustaría abordar sus balas individuales para mantener el código.

• El código ya está escrito y se dedican esfuerzos

Pero si el código ya escrito no está en uso, esto solo tiene un costo sin valor (futuro). Es un esfuerzo invertido en vano, y preservar el producto no utilizado de esos esfuerzos no valida esos esfuerzos. Guardamos el código porque es útil, ahora, no como una especie de monumento a los esfuerzos de los autores.

• El código se puede probar en un entorno sintético y real

Lo siento, no sé a qué te refieres con esto.

• Si está bien organizado (agrupado, paquete separado, poco acoplado, etc.), no le molesta en el análisis general del código o la refactorización

Si existe en el código base, no importa lo bien organizado que esté, contribuye a la carga de mantenimiento y comprensión. Es cierto que se puede organizar para que sea menos una carga, pero si desaparece, no es una carga en absoluto.

• El código puede usarse en el futuro

En la escuela Agile, decimos YAGNI : No lo vas a necesitar. Sí, es posible que tenga un uso para él en el futuro, pero hoy no podemos saber lo suficiente sobre las necesidades del mañana para poder predecir eso con algún tipo de confiabilidad. Pensar de otra manera es arrogancia que tiende a la arrogancia. Lo que podemos saber sobre el mañana es: queremos que nuestra base de código sea fácil de modificar, y el código no utilizado resta valor a esa característica.

• Cuando se elimina, el autor puede sentirse incómodo

El autor debe superarlo. Todos hemos escrito cosas que resultaron no ser útiles; mucho mejor poder apuntar a un cuerpo de código que se está utilizando todo (porque se eliminó el cruft no utilizado) que a un cuerpo de código en el que se puede decir algunos métodos, "¡y ese está realmente en uso!"

¿No es lo suficientemente difícil tomar un código y averiguar la intención, pero ahora tienes que averiguar qué partes no están en uso?

El código ya está escrito y se dedican esfuerzos

También es innecesario. Si no lo usa para nada, es (por definición) inútil, sin importar lo que haga o cuánto esfuerzo se haya invertido en él.

El código se puede probar en un entorno sintético y real

Si es inútil, sigue siendo inútil incluso si tiene pruebas. Si el código es inútil, las pruebas también deberían ser inútiles (por lo tanto, mantener el código comentado allí crea ambigüedad: ¿conservas las pruebas? Si tuvieras el código de cliente del código comentado, ¿comentas también el código de cliente? )

Si está bien organizado (agrupado, paquete separado, poco acoplado, etc.), no le molesta en el análisis general del código o la refactorización

No tan. Todas sus herramientas (control de fuente, análisis estático, extractor de documentación, compilador, etc.) se ejecutarán más lentamente, porque tienen que procesar más datos (y una parte mayor o menor de esos datos es ruido).

Si el código no está bien organizado, por otro lado, estropeará el análisis estático, la refactorización y cualquier otro.

Estás introduciendo ruido en la entrada de tus herramientas y esperas que lo afronten correctamente.

¿Qué pasa si su herramienta de análisis estático calcula una proporción de comentarios / código? Simplemente lo arruinaste, con algo que era relevante hasta ayer (o cuando se comentaba el código).

Lo más relevante de todo es que los bloques de código comentados introducen retrasos en la comprensión del código para su mantenimiento y desarrollo posterior, y estos retrasos casi siempre cuestan mucho. Pregúntese esto: si necesita comprender la implementación de una función, ¿qué preferiría tener en cuenta? ¿Dos líneas de código claro, o dos líneas de código y otras veintiséis de comentarios que ya no son reales?

El código puede usarse en el futuro

Si es así, lo encontrará en el SCM de su equipo.

Si usa un SCM competente y confía en él para mantener el código muerto (en lugar de saturar la fuente), debería ver no solo quién eliminó ese código (autor de confirmación), sino por qué motivo (mensaje de confirmación) y qué otros Se realizaron cambios junto con él (el resto de las diferencias para esa confirmación).

Cuando se elimina, el autor puede sentirse incómodo

¿Entonces?

Sois (supongo) un equipo completo de desarrolladores a los que se les paga por crear el mejor software que sepas, no "el mejor software que sepas sin herir los sentimientos de X".

Es parte de la programación, que la mayoría del código escrito finalmente se descartará; por ejemplo, Joel Spolsky dijo en algún momento que para su empresa, aproximadamente el 2% del código escrito ve producción.

Si priorizas el ego de los desarrolladores sobre la calidad del código base, sacrificarás la calidad de tu producto, por ... ¿qué exactamente? ¿Preservando la inmadurez de sus compañeros desarrolladores? ¿Protegiendo las expectativas poco realistas de sus colegas?

Editar: He visto una razón válida para dejar el código comentado en la fuente, y es un caso muy específico: cuando el código está escrito de una forma extraña / poco intuitiva y la forma limpia de reescribirlo no trabajar por una razón muy sutil. Esto también debe aplicarse solo después de que se haya realizado un intento repetido para corregir el problema y cada vez que el intento haya reintroducido el mismo defecto. En tal caso, debe agregar el código intuitivo comentado como comentario y explicar por qué no funciona (para que los futuros desarrolladores no vuelvan a intentar el mismo cambio):

// note by <author>: the X parameter here should normally
// be a reference:
// void teleport(dinosaur& X);
// but that would require that we raise another dinosaur and
// kill it every twelve hours
// as such, the parameter is passed by value
void teleport(dinosaur X);

El código muerto está contaminando tu código

El código muerto disminuye la comprensión y la legibilidad.

Los mejores códigos siempre se reutilizan, y si tienes códigos muertos, se reduce la reutilización

Nos impulsa el enfoque modular de la codificación, en el que diseñamos códigos para la interacción con nuestros compañeros programadores, no para una máquina. Debemos poner la mayor energía para facilitarle la comprensión de nuestro código. La máquina estará bien de todos modos.

El código muerto o comentado es como señales de seguimiento falsas que solo confunden a las personas, así que evítelo a toda costa.

• Temer . Esto hace que el equipo se preocupe más y produzca menos. La cantidad de miedo aumenta exponencialmente cuando se introduce más código muerto. "No sabemos si se usa ese bit, así que no nos atrevemos a quitarlo o tocarlo".

• Cambios radicales . Si algo que debe cambiarse en todas partes del sistema también existe en el código muerto, ¿lo cambia? Es muy difícil saber si definitivamente no se usa en algún lugar, por lo que siempre es un riesgo. E incluso si no rompiera nada, ¿funcionaría el código muerto si se volviera a usar después de este cambio?

  Cuando se trata de un cambio radical, los desarrolladores también tendrán que comprobar todos los lugares que contienen el código y, en el caso de un código muerto, esto es redundante. Y verificarlos lleva más tiempo cuando el código está muerto, ya que es difícil verificar que no se use en ninguna parte.

• Carga mental . Cada vez que necesita pensar si se usa algo o si debe hacer algo con el código muerto, se necesita algo de su poder cerebral.
• Persecuciones de gansos salvajes . "Necesito un ejemplo sobre cómo usar Foobar. Oh, está en estos lugares de la base de código. Verificaré el primer resultado y averiguaré dónde está en la interfaz de usuario. Hmm ... No puedo encontrarlo en ninguna parte".
• Informes inflados (por ejemplo, cuántas líneas de código, clases, rutinas, cambios). Distorsiona la visibilidad del proyecto y las decisiones sobre en qué partes del código base se debe trabajar y las estimaciones de proyectos futuros.
• Confianza debilitada en el código base . Esto puede resultar en más tiempo dedicado a tareas redundantes y rompe el flujo de uso del código base. Es posible que los desarrolladores deban comprobar con mucho cuidado que todo lo que utilicen funcione de la forma que creen que debería funcionar.

Es extremadamente valioso si sabe que una parte del código base no se usa porque entonces puede eliminarlo. Si lo deja permanecer, en el futuro puede ser difícil o casi imposible estar seguro de que realmente no se utiliza. Por ejemplo, algunas de las cosas que usan código de manera sorprendente: reflexión, rutinas de llamadas dinámicas concatenadas de cadenas, eval, framework magic .

Sin embargo, si existe una alta probabilidad de que el código se use en el futuro, es más fácil agregarlo si está allí junto al otro código en lugar de hacerlo en el sistema de control de versiones. Es posible que no recuerde las palabras que tenía el código después de un tiempo, por lo que puede ser muy difícil encontrar el código en las entrañas del VCS. Pero dejaría que el código muerto existiera solo en raras ocasiones e incluso entonces comentaría el código.

• El código no utilizado es un espacio de búsqueda más grande para que usted lo lea y cualquier otra cosa que generalmente escanee su código. Por ejemplo, un compilador, IDE, búsqueda en archivo, depuración, análisis estático, más para revisar, inclusión de archivos, verificación de VCS, etc. Esto ralentiza esos procesos y agrega ruido significativo.
• El código no utilizado no siempre es un código muerto. Puede ejecutarse en determinadas circunstancias. Esto no solo puede ofrecer un vector para errores y problemas de rendimiento, sino que también puede ser un problema de seguridad. Con respecto al rendimiento, esto puede expresarse de formas inesperadas, como descargas más grandes.
• El código no utilizado genera código no utilizado. Si elimina una llamada a una función y luego busca los usos de esa función para ver si todavía es necesaria, es posible que vea una coincidencia del código no utilizado anterior y suponga que puede conservarlo. Cuanto más código sin usar tenga, más saltos será para determinar si el código no se usa.
• El código no utilizado a menudo termina siendo necesario mantenerlo. Digamos que A y B dependen de C. De esos, B no se usa. Cambia C y luego B no se compilará porque ha eliminado un miembro de una estructura en C que B requería, ahora tiene que arreglar B o eliminarlo activamente de la compilación. Deberías haberlo quitado simplemente.

Esta lista puede parecer simple, pero cada uno de estos se manifiesta en cientos de formas diferentes, lo que agrega resistencia que crea sinergias a lo largo de todo el proceso de desarrollo. La ineficiencia a menudo se puede probar o demostrar de una manera sencilla y matemática.

En respuesta a sus puntos ...

• El código ya está escrito y se dedican esfuerzos

Pero a menudo debe mantenerse. También aparecerá inmóvil en cosas como buscar en archivo.

• El código se puede probar en un entorno sintético y real

No estoy seguro de a qué te refieres con esto. Creo que es igual que el anterior. Quiere decir que el código ya está probado y limpiarlo podría significar que necesita una nueva prueba. Ese es un costo que generalmente vale la pena porque pagará el 90% del tiempo y evitará que se haya limpiado antes de salir a producción. Casi todo el código tiene dos iteraciones, hazlo funcionar, hazlo limpio. La razón por la que debe probarse dos veces es porque alguien se saltó el último paso. Si su código también es demasiado caro para revisar las diferencias, probar (lo que probablemente sea si está desordenado con mucho código sin usar), etc., entonces ese es otro problema.

• Si está bien organizado (agrupado, paquete separado, poco acoplado, etc.), no le molesta en el análisis general del código o la refactorización

Su código debería ser así de todos modos, pero eso solo mitiga moderadamente el problema. Es el argumento más extraño escuchar que algo debe estar organizado pero que no está limpio. Es normal tratar de mantener el código modular y reducir las dependencias, pero también desea un código reutilizable y si todos sus módulos son una isla, es probable que no haya estado SECO. También puede encontrarse haciendo un desacoplamiento excesivo que no hace más que mitigar el problema del código desordenado no utilizado.

• El código puede usarse en el futuro

Mucha gente valora demasiado el código escrito. Si no se usa ahora, es un peso muerto y, en realidad, cuando recorre este camino, a menudo solo una fracción del código no utilizado se convierte en código usado. Con toda probabilidad, el código no utilizado no es probable que sea utilizable o utilizado. El código que tiene más probabilidades de ser reutilizado es el código ya usado que está haciendo algo.

Lo peor es que el código no utilizado no tiene un propósito. Cuando alguien llega y tiene que cambiar algo que termina afectando el código no utilizado, se quedará perplejo sentado allí tratando de averiguar qué debe hacer este código no utilizado sin ningún propósito.

Es fácil que las personas se sientan así al comenzar, ya que el código requiere mucho esfuerzo. Sin embargo, una vez que lo dominas y estás acostumbrado, el código se vuelve como andar en bicicleta. Descubrirá que el costo de escribir un fragmento de código de este tipo se desploma y el costo de mantenerlo aumenta.

• Cuando se elimina, el autor puede sentirse incómodo

Este es el problema del autor. Por un lado, es egoísta dejar un montón de código sin usar para que otros tengan que lidiar con él. Por otro lado, si un autor pone sus sentimientos sobre la calidad del código, probablemente no debería estar codificando. Sigue el camino con esto de que no puede arreglar su código cuando está roto porque herirá sus sentimientos. No es una buena señal si alguien está apegado al código simplemente porque es suyo y no porque sea bueno. Un autor debería sentirse feliz por la limpieza de su código. Es como si alguien sacara la basura y la tirara a la basura.

Me encantaría que alguien hiciera eso por mí. Lo que podría hacer que sea más fácil superar esos sentimientos es en lugar de esperar a que alguien más lo haga, intente hacerlo usted mismo. Continúe reescribiendo iterativamente un fragmento de código que ha hecho, para que funcione mejor, se mueva conciso, con menos exceso y sea más flexible pero con menos código cada vez. Trate de no sentirse bien con la cantidad de código, sino con cuánto puede lograr con un código pequeño. Esto está trabajando para subir de nivel y una vez que lo haga, todo su código saldrá a un buen nivel, por lo que no será necesario nivelarlo con tanta frecuencia.

En primer lugar, siempre debe usar una herramienta de control de fuente para administrar sus proyectos y, por lo tanto, eliminar el código no utilizado es una buena práctica, ya que siempre puede volver a usar el control de fuente para obtener el código eliminado. Para mí, la razón para eliminar el código no utilizado es que solo la persona que sabe que el código no está utilizado lo sabe, alguien más en el equipo se encontrará con ese código e intentará averiguar qué hace y cómo encaja en toda la aplicación y se sentirá decepcionado después de tanto esfuerzo que el código no se usa en absoluto :)

Esta discusión tiene varios años, pero me la encontré ...

Una cosa que no vi mencionada es el trabajo que se debe realizar para eliminar el código no utilizado. En muchos casos, el tiempo y el esfuerzo para eliminar el código no utilizado no son de naturaleza trivial, además, normalmente existen costos adicionales para probar y documentar el sistema refactorizado. Solo otra cosa a considerar en el proceso de decisión.

Creo que puede tener dos casos: - código de aplicación: si no se usa, tal vez no se haya probado y no se haya mantenido con el tiempo, tal vez pueda cambiar a un "repositorio de código interno" - código API: si está escribiendo una biblioteca, en mi humilde opinión es una mejor opción para mantenerlo pero dentro de su proceso de desarrollo activo

¿Estás seguro de que el código no se utiliza?

No es suficiente comprobar que el código aún se compila. En C ++, si elimina un método definido implícitamente "no utilizado" comooperator= si no fuera a obtener un error de compilación, la clase simplemente comenzará a usar silenciosamente una implementación predeterminada (potencialmente incorrecta). En Java o C #, el código se puede usar mediante reflexión. En los lenguajes orientados a objetos, la herencia puede desempeñar un papel (ahora se puede llamar a la clase base). En casi cualquier idioma, otra función sobrecargada puede haberse hecho cargo.

Verifique la antigüedad del código en el control de versiones, no solo que no esté en uso. He visto código que parecía sin usar pero que acababa de ser comprometido, y en realidad era el primer paso en el proyecto de otro desarrollador.

Eliminar agresivamente el código no utilizado

Paga para mantener el código:

• Arreglando construcciones rotas (tiempo de ingeniería). Recientemente tuvimos una complicada cadena de#include cambios, que introdujo una nueva sobrecarga en el código no utilizado, lo que generó un dolor de cabeza de tamaño razonable para cada ingeniero de un equipo de docenas de desarrolladores.
• En recursos de máquina en pruebas (asumiendo que tiene compilaciones continuas de autoprueba). Mi equipo examinó recientemente todas nuestras pruebas más lentas, y muchas de ellas estaban sobre el código que de otro modo no se usaba. Los ingenieros que ejecutan pruebas de forma local o como parte de la integración continua están esperando pruebas sobre el código no utilizado.
• En términos de legibilidad (tiempo de ingeniería nuevamente). Sus archivos de encabezado representan una API. Si incluyen funciones que nadie querría usar, pero todos tienen que leer, la curva de aprendizaje de su código es mucho más difícil.
• En búsquedas de códigos (tiempo de ingeniería nuevamente). ¿Limpiarías tu casa, tu disco duro o Google Drive? Cuanto más busque en un dominio, más importante será que tenga contenido relevante para evitar falsos positivos (o utilice una búsqueda más sofisticada como un motor de búsqueda web).

Yo diría que esencialmente todo el código que escribe el desarrollador promedio no se usa en un horizonte de cinco años, por lo que esta actividad nunca se detiene. No dejes que este seas tú; escriba únicamente código de alta calidad y absolutamente necesario.