// ❌ Código legado desestructurado y sin seguridad de tipos
function processUserData(data: any) {
  console.log("User ID:", data.id);
  if (data.role === "admin") {
    return data.permissions.includes("write");
  }
  return false;
}

Refactorización de tipos any en TypeScript con Type Guards y TSDoc

// ANTES: Código legado verboso y propenso a errores
public abstract class Response {
}

public class SuccessResponse extends Response {
    private final String data;
    public SuccessResponse(String data) { this.data = data; }
    public String getData() { return data; }
}

public class ErrorResponse extends Response {
    private final String errorCode;
    public ErrorResponse(String errorCode) { this.errorCode = errorCode; }
    public String getErrorCode() { return errorCode; }
}

public class ResponseProcessor {
    public static String process(Response response) {
        if (response instanceof SuccessResponse) {
            SuccessResponse success = (SuccessResponse) response;
            return "OK: " + success.getData();
        } else if (response instanceof ErrorResponse) {
            ErrorResponse error = (ErrorResponse) response;
            return "FAIL: " + error.getErrorCode();
        } else {
            throw new IllegalArgumentException("Unknown response type");
        }
    }
}

Refactorización en Java 21+: Records y Pattern Matching para Código Legible

namespace JWDocs.Services;

/// <summary>
/// Servicio para procesar pagos y emitir recibos de clientes.
/// </summary>
public class PaymentProcessor
{
    private readonly IPaymentGateway _gateway;
    private readonly ILogger _logger;

    /// <summary>
    /// Inicializa una nueva instancia de <see cref="PaymentProcessor"/>.
    /// </summary>
    /// <param name="gateway">El proveedor de pagos principal.</param>
    /// <param name="logger">El servicio de registro de eventos auditables.</param>
    public PaymentProcessor(IPaymentGateway gateway, ILogger logger)
    {
        _gateway = gateway ?? throw new ArgumentNullException(nameof(gateway));
        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
    }

    public async Task ProcessAsync(decimal amount)
    {
        _logger.LogInfo("Iniciando pago...");
        await _gateway.ChargeAsync(amount);
    }
}

C# 12 Moderno: Refactorización con Primary Constructors y XML Docs

const config = {
  retries: 3,
  endpoint: "https://api.example.com",
} satisfies Record<string, string | number>;

const timeout = options?.timeout ?? 5000;
const city = user?.address?.city ?? "Sin ciudad";

TypeScript moderno: ?., ?? y satisfies sin errores de formato

SELECT o.id, o.total, c.name
FROM orders AS o
JOIN customers AS c ON c.id = o.customer_id
WHERE o.created_at >= DATE '2026-01-01'
ORDER BY o.total DESC;

SQL y DAX: tres hábitos para consultas rápidas y legibles

match command.split():
    case ["go", direction] if direction in {"north", "south"}:
        move(direction)
    case ["quit" | "exit"]:
        shutdown()
    case _:
        print("Comando desconocido")

PEP 8 en Python 3.12: cómo escribir bloques match/case legibles