// ❌ Veralteter Code ohne Typsicherheit und ohne TSDoc
function processUserData(data: any) {
  console.log("User ID:", data.id);
  if (data.role === "admin") {
    return data.permissions.includes("write");
  }
  return false;
}

Refactoring von legacy any-Typen in TypeScript mit Type Guards und TSDoc

// VORHER : Wortreicher und fehleranfälliger Legacy-Code
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");
        }
    }
}

Refactoring in Java 21+: Records und Pattern Matching für lesbaren Code

namespace JWDocs.Services;

/// <summary>
/// Dienst zur Verarbeitung von Kundenzahlungen.
/// </summary>
public class PaymentProcessor
{
    private readonly IPaymentGateway _gateway;
    private readonly ILogger _logger;

    /// <summary>
    /// Initialisiert eine neue Instanz von <see cref="PaymentProcessor"/>.
    /// </summary>
    /// <param name="gateway">Der primäre Zahlungsanbieter.</param>
    /// <param name="logger">Der Audit-Protokolldienst.</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("Zahlung wird gestartet...");
        await _gateway.ChargeAsync(amount);
    }
}

Modernes C# 12: Refactoring mit Primary Constructors und 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";

Modernes TypeScript: ?., ?? und satisfies ohne Formatierungsfehler

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 und DAX: drei Gewohnheiten für schnelle, lesbare Abfragen

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

PEP 8 in Python 3.12: lesbare match/case-Blöcke schreiben