¿Tiene sentido que un refactor termine con un LOC más alto? [cerrado]

¿Hay casos en que un código más detallado (como en las declaraciones más lógicas) es más limpio que un código más conciso?

Para responder eso, tomemos un ejemplo del mundo real que me sucedió. En C # una biblioteca que mantengo, tenía el siguiente código:

TResult IConsFuncMatcher<T, TResult>.Result() =>
    TryCons(_enumerator) is var simpleMatchData && !simpleMatchData.head.HasValue
        ? _emptyValue.supplied
            ? _emptyValue.value
            : throw new NoMatchException("No empty clause supplied");
        : _recursiveConsTests.Any() 
            ? CalculateRecursiveResult() 
            : CalculateSimpleResult(simpleMatchData);

Al discutir esto con sus compañeros, el veredicto unánime fue que las expresiones ternarias anidadas, junto con el uso "inteligente" de is varresultaron en código conciso, pero difícil de leer.

Entonces lo refactoricé para:

TResult IConsFuncMatcher<T, TResult>.Result()
{
    var simpleMatchData = TryCons(_enumerator);

    if (!simpleMatchData.head.HasValue)
    {
        return _emptyValue.supplied
            ? _emptyValue.value
            : throw new NoMatchException("No empty clause supplied");
    }

    return _recursiveConsTests.Any() 
        ? CalculateRecursiveResult() 
        : CalculateSimpleResult(simpleMatchData);
}

La versión original contenía solo una expresión compuesta con una implícita return. La nueva versión ahora contiene una declaración de variable explícita, una ifdeclaración y dos explícitos returns. Contiene más declaraciones y más líneas de código. Sin embargo, todos los que consulté consideraron que era más fácil leer y razonar, que son aspectos clave del "código limpio".

Entonces, la respuesta a su pregunta es un "sí" enfático, más detallado puede ser más limpio que el código conciso y, por lo tanto, es una refactorización válida.

1. Falta de correlación entre LOC y la calidad del código.

El objetivo de la refactorización es mejorar la calidad de un código.

LOC es una métrica muy básica que, a veces, se correlaciona con la calidad de un código: por ejemplo, es probable que un método con unos pocos miles de LOC tenga problemas de calidad. Cabe señalar, sin embargo, que LOC no es el único métrica, y en muchos casos carece de la correlación con la calidad. Por ejemplo, un método 4 LOC no es necesariamente más legible o más fácil de mantener que un método 6 LOC.

2. Algunas técnicas de refactorización consisten en agregar LOC.

Si toma una lista de técnicas de refactorización , puede detectar fácilmente las que consisten en agregar LOCs intencionalmente . Ejemplos:

• Reemplazar número mágico con constante simbólica .
• Extraer variable .

Ambas son técnicas de refactorización muy útiles, y su efecto en el LOC es completamente irrelevante cuando se considera si usarlas o no.

Evita usar LOC.

LOC es una métrica peligrosa. Es muy fácil de medir y es muy difícil de interpretar correctamente.

Hasta que se familiarice con las técnicas de medición de la calidad del código, considere evitar medir LOC en primer lugar. La mayoría de las veces, no obtendrá nada relevante, y habrá casos en los que lo engañará para que disminuya la calidad de su código.

Si desea ver el resultado final de solo minimizar el recuento de bytes o el recuento de LoC de su código fuente, eche un vistazo a los envíos al sitio de Stack Exchange Code Golf .

Si su código fuente se reduce de tal manera, pronto tendrá un desastre imposible de mantener. Incluso si usted es la persona que escribió dicho código y lo entiende completamente en ese momento, ¿qué tan eficiente será cuando regrese a él dentro de seis meses? Tampoco hay evidencia de que ese código mínimo realmente se ejecute más rápido.

El código debe estar escrito de tal manera que cualquier miembro de su equipo pueda verlo y comprender lo que está haciendo de inmediato.

Sí, la refactorización definitivamente puede generar más líneas de código.

El caso más común de IMO es cuando tomas código que no es genérico y lo haces más genérico / flexible . El código genérico hace que las líneas de código aumenten significativamente (a veces por un factor de dos o más).

Si espera que el código genérico nuevo sea utilizado por otros (en lugar de solo como un componente interno de software) como una biblioteca, generalmente terminará agregando código de prueba de unidad y marcado de documentación en código que aumentará las líneas de código nuevamente.

Por ejemplo, aquí hay un escenario muy común que ocurre para cada desarrollador de software:

• su producto necesita una nueva característica urgente de alta prioridad o corrección de errores o mejora en dos semanas (o cualquier período de tiempo que se considere urgente para el tamaño de su proyecto / tamaño de la empresa / etc.)
• trabajas duro y entregas XYZ a tiempo y funciona. ¡Felicidades! ¡Gran trabajo!
• Mientras desarrollaba XYZ, su diseño / implementación de código existente realmente no era compatible con XYZ, pero pudo colocar XYZ en la base de código
• el problema es que la cuña es fea y tiene un olor a código terrible porque hiciste algunas cosas difíciles / inteligentes / feas / malas-prácticas-pero-un poco-funciona
• cuando encuentre tiempo más tarde, refactorice el código, lo que puede cambiar muchas de las clases o agregar una nueva capa de clases y su nueva solución se "hace bien" y ya no tiene el mal olor del código ... sin embargo, al hacerlo "forma correcta" ahora ocupa muchas más líneas de código.

Algunos ejemplos concretos que me vienen a la cabeza:

• para una interfaz de línea de comando , podría tener 5000 líneas de código if / else-if o podría usar devoluciones de llamada ... cada devolución de llamada sería mucho más pequeña y más fácil de leer / probar / verificar / depurar / etc. pero si cuenta líneas de codifique las 5000 líneas feas de código if / else-if probablemente sería más pequeño
• para un fragmento de código de procesamiento que admite N métodos de procesamiento , podría usar nuevamente declaraciones if / else que se verían más feas ...
  • o podría cambiar a devoluciones de llamada, que serían mejores / mejores, pero las devoluciones de llamada toman más líneas de código (aunque todavía es tiempo de compilación)
  • o puede abstraer más y hacer complementos que se pueden cambiar en tiempo de ejecución. los complementos son buenos porque no tiene que volver a compilar el producto principal para cada nuevo complemento o modificación de un complemento existente. y puede publicar la API para que otros puedan ampliar el producto. PERO de nuevo, un enfoque de complemento utiliza más líneas de código.
• para una GUI, creas un nuevo widget genial
  • usted o un compañero de trabajo observan que el nuevo widget sería excelente para XYZ y ABC, pero en este momento el widget está estrechamente integrado solo para funcionar para XYZ
  • refactoriza el widget para que funcione para ambos, pero ahora las líneas totales de código aumentan