Código inflado

Habitualmente, el código inflado lo genera un programador que simplemente usa más líneas de código de las que requiere la solución óptima al problema.

Algunas de las razones por las que un programador acaba generando código inflado son:

• Un uso excesivo de constructos de programación orientada a objetos (como clases y herencia) puede llevar a diseños desordenados y confusos, a menudo usando más líneas de código que la solución óptima.
• Usos incorrectos de patrones de diseño, algunos programadores intentan “forzar” patrones a soluciones que no los necesitan (regla del martillo de oro).
• No usar un encapsulamiento adecuado sobre problemas parciales permitiendo su reutilización y por lo tanto derivando en código duplicado.[1]
• Utilizar un estilo de programación declarativa en un lenguaje de programación imperativa.
• Excesivo desenroscado de bucles sin asegurar una mejora en el rendimiento.
• Abusar de las instrucciones if en lugar de utilizar una tabla de búsqueda.

Algunas implementaciones de plantillas de C++ son ejemplos de código inflado generado por el compilador.

Un compilador inadecuado podría generar una versión de cada método de una plantilla por cada tipo de dato con que se use la plantilla. Esto provoca que se compilen métodos que podrían no ser usados. Los compiladores y enlazadores más sofisticados detectan las copias no operativas y las descartan o incluso evitan generarlas, reduciendo así la inflamación de código. De esta manera el código generado con plantillas puede llevar a archivos binarios más reducidos ya que el compilador puede eliminar este tipo de código muerto.

Algunos ejemplos de código inflado producido por el compilador incluyen:

• Código que es ejecutado pero cuyo resultado jamás es usado (código muerto).
• Re-evaluar expresiones que han sido calculadas anteriormente. Estos cálculos redundantes suelen generarse al implementar verificaciones de límites para prevenir desbordamientos de buffer. Los compiladores más sofisticados hacen estos cálculos una sola vez, eliminando así los cálculos redundantes, usando eliminación de subexpresiones comunes y desplazamiento de invariantes de bucle.

El siguiente algoritmo de JavaScript tiene gran cantidad de variables redundantes, lógica innecesaria y concatenación ineficiente de cadenas.

function TK2getImageHTML(tamano, zoom, sensor, marcadores)
{
    var strImagenFinal = "";
    var strInicioHTML = '<img src="';
    var strFinalHTML = '" alt="The map"/>';
    var strURL = "http://maps.google.com/maps/api/staticmap?center=";
    var strTamano = '&size='+ tamano;
    var strZoom = '&zoom='+ zoom;
    var strSensor = '&sensor='+ sensor;

    strURL += marcadores[0].latitude;
    strURL += ",";
    strURL += marcadores[0].longitude;
    strURL += strTamano;
    strURL += strZoom;
    strURL += strSensor;

    for (var marcador = 0; marcador < marcadores.length; marcador++)
    {
        strURL += marcadores[marcador].addMarker();
    }

    strImagenFinal = strInicioHTML + strURL + strFinalHTML;
    return strImagenFinal;
};

La misma lógica se puede expresar de manera más eficiente como el siguiente:

TK2.getImageHTML = function(tamano, zoom, sensor, marcadores)
{
    var url =
    [
        'http://maps.google.com/maps/api/staticmap',
        '?center=', marcadores[0].latitude, ',', marcadores[0].longitude,
        '&size=', tamano,
        '&zoom=', zoom,
        '&sensor=', sensor
    ];

    for (var marcador = 0; marcador < marcadores.length; marcador++)
    {
        url.push(marcadores[marcador].addMarker());
    }

    return '<img src="' + url.join('') + '" alt="The map" />';
}

La diferencia en densidad de código entre varios lenguajes de programación es tan grande que habitualmente se requiere menos memoria para un lenguaje compacto (como un lenguaje específico de dominio, Código empaquetado de Microsoft o Código enhebrado) que para un lenguaje escrito en lenguaje máquina.

Algunas técnicas para reducir el código inflamando incluyen:[2]

• Refactorizar secuencias de código de uso común en una subrutina y llamar dicha subrutina desde diferentes puntos del código en lugar de copiar y pegar el código en todos esos puntos.
• Reutilizar subrutinas existentes (puede que con parámetros adicionales) en lugar de crear una nueva rutina desde cero.

• Sobrecarga en polimorfismo.
• Software inflado.
• Minimalismo.

• Esta obra contiene una traducción derivada de «Code bloat» de Wikipedia en inglés, concretamente de esta versión, publicada por sus editores bajo la Licencia de documentación libre de GNU y la Licencia Creative Commons Atribución-CompartirIgual 4.0 Internacional.