What Is Technical Debt?

// Callback hell - nested, hard to read, error handling nightmare
getUserData(userId, function(err, user) {
    if (err) {
        console.log(err);
        return;
    }
    getOrders(user.id, function(err, orders) {
        if (err) {
            console.log(err);
            return;
        }
        getOrderDetails(orders[0].id, function(err, details) {
            if (err) {
                console.log(err);
                return;
            }
            processPayment(details.total, function(err, result) {
                if (err) {
                    console.log(err);
                    return;
                }
                sendEmail(user.email, result);
            });
        });
    });
});

// Modern async/await - readable, maintainable, clear error handling
async function processUserOrder(userId) {
    try {
        const user = await getUserData(userId);
        const orders = await getOrders(user.id);
        const details = await getOrderDetails(orders[0].id);
        const result = await processPayment(details.total);
        await sendEmail(user.email, result);
        return result;
    } catch (error) {
        logger.error('Order processing failed:', error);
        throw new OrderProcessingError(error);
    }
}

# Mixing Python 2 and 3 - compatibility issues, deprecated features
from __future__ import print_function  # Workaround for Python 2
import urllib2  # Python 2 library (removed in Python 3)

def fetch_data(url):
    # Python 2 style string handling
    response = urllib2.urlopen(url)
    data = response.read()
    # Using Python 2 dict.iteritems() (removed in Python 3)
    for key, value in data.iteritems():
        print key, value  # Python 2 print statement
    return data

# Using old exception syntax
try:
    result = fetch_data('http://api.example.com')
except Exception, e:  # Python 2 syntax
    print "Error:", e

# Clean Python 3 code - modern, supported, type hints
import urllib.request
from typing import Dict, Any

def fetch_data(url: str) -> Dict[str, Any]:
    """Fetch and parse JSON data from URL."""
    with urllib.request.urlopen(url) as response:
        data = json.loads(response.read().decode('utf-8'))

    for key, value in data.items():  # Python 3 .items()
        print(f"{key}: {value}")  # f-strings (Python 3.6+)

    return data

# Modern exception handling
try:
    result = fetch_data('http://api.example.com')
except Exception as e:  # Python 3 syntax
    logger.error(f"Error fetching data: {e}")

// Java 8 code - outdated, verbose, no modern features
import java.util.ArrayList;
import java.util.Date;  // Deprecated since Java 1.1!
import java.util.List;

public class UserService {
    // Verbose boilerplate
    public List<String> getActiveUserNames(List<User> users) {
        List<String> names = new ArrayList<>();
        for (User user : users) {
            if (user.isActive()) {
                names.add(user.getName());
            }
        }
        return names;
    }

    // Using deprecated Date class (not thread-safe)
    public Date getCreatedDate() {
        return new Date();  // Security scanner flags this
    }

    // Try-with-resources verbose
    public String readFile(String path) throws IOException {
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader(path));
            return reader.readLine();
        } finally {
            if (reader != null) {
                reader.close();
            }
        }
    }
}

// Java 17+ - modern, secure, concise
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.LocalDateTime;  // Modern date/time API
import java.util.List;
import java.util.stream.Collectors;

public class UserService {
    // Stream API - functional, concise
    public List<String> getActiveUserNames(List<User> users) {
        return users.stream()
            .filter(User::isActive)
            .map(User::getName)
            .collect(Collectors.toList());
    }

    // Modern date/time (thread-safe, immutable)
    public LocalDateTime getCreatedDate() {
        return LocalDateTime.now();
    }

    // Modern file I/O (auto-closeable, one-liner)
    public String readFile(String path) throws IOException {
        return Files.readString(Path.of(path));
    }

    // Record classes (Java 14+) - immutable data carriers
    public record UserDTO(String name, String email, boolean active) {}
}

// .NET Framework 4.8 - Windows-only, old patterns, limited async
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web.Mvc;  // Old ASP.NET MVC (not cross-platform)

namespace LegacyApp.Controllers
{
    public class UserController : Controller
    {
        // Synchronous database call (blocks thread)
        public ActionResult GetUsers()
        {
            var users = db.Users.ToList();  // Blocks thread
            return View(users);
        }

        // ConfigurationManager (old config system)
        public string GetSetting()
        {
            return ConfigurationManager.AppSettings["ApiKey"];
        }

        // LINQ with verbose syntax
        public List<string> GetActiveUserEmails()
        {
            List<string> emails = new List<string>();
            foreach (var user in db.Users)
            {
                if (user.IsActive)
                {
                    emails.Add(user.Email);
                }
            }
            return emails;
        }
    }
}

// .NET 8 - cross-platform, async, minimal APIs, top performance
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;

namespace ModernApp.Controllers;

[ApiController]
[Route("api/[controller]")]
public class UserController : ControllerBase
{
    private readonly AppDbContext _db;
    private readonly IConfiguration _config;

    public UserController(AppDbContext db, IConfiguration config)
    {
        _db = db;
        _config = config;
    }

    // Async all the way (doesn't block threads)
    [HttpGet]
    public async Task<ActionResult<List<User>>> GetUsers()
    {
        var users = await _db.Users.ToListAsync();
        return Ok(users);
    }

    // Modern configuration (DI, strongly typed)
    [HttpGet("setting")]
    public string GetSetting()
    {
        return _config["ApiKey"] ?? throw new InvalidOperationException("ApiKey not configured");
    }

    // LINQ + async + modern C# features
    [HttpGet("active-emails")]
    public async Task<List<string>> GetActiveUserEmails()
    {
        return await _db.Users
            .Where(u => u.IsActive)
            .Select(u => u.Email)
            .ToListAsync();
    }
}