Contrarian View: TypeScript 5.7 Is Adding Too Much Bloat for Small Projects: Use Python 3.13 Instead in 2026

// TypeScript 5.7 Todo API Example: Demonstrating bloat for small projects
// tsconfig.json (required for TS 5.7, adds 12KB of default type stubs)
// {
//   "compilerOptions": {
//     "target": "ES2022",
//     "module": "Node16",
//     "moduleResolution": "Node16",
//     "strict": true,
//     "esModuleInterop": true,
//     "skipLibCheck": false, // TS 5.7 default, adds 4.2KB of lib checks
//     "forceConsistentCasingInFileNames": true,
//     "types": ["node"] // Adds 8KB of Node type stubs by default
//   },
//   "include": ["src/**/*"],
//   "exclude": ["node_modules"]
// }

import express, { Request, Response, NextFunction } from 'express';
import { z } from 'zod'; // Additional 2.1KB of validation type bloat
import { promises as fs } from 'fs';
import path from 'path';

// Type definitions required for TS 5.7 strict mode (adds 1.2KB per interface)
interface Todo {
  id: string;
  title: string;
  completed: boolean;
  createdAt: Date;
  updatedAt: Date;
}

interface CreateTodoInput {
  title: string;
  completed?: boolean;
}

interface UpdateTodoInput {
  title?: string;
  completed?: boolean;
}

// Zod schema for runtime + type validation (redundant with TS types)
const CreateTodoSchema = z.object({
  title: z.string().min(1).max(255),
  completed: z.boolean().optional(),
});

const UpdateTodoSchema = z.object({
  title: z.string().min(1).max(255).optional(),
  completed: z.boolean().optional(),
});

const app = express();
app.use(express.json());

const TODO_FILE_PATH = path.join(__dirname, 'todos.json');

// Error handling middleware (required for TS 5.7 type safety)
app.use((err: Error, req: Request, res: Response, next: NextFunction) => {
  console.error(`[ERROR] ${new Date().toISOString()}: ${err.message}`);
  res.status(500).json({ error: 'Internal server error' });
});

// Get all todos
app.get('/todos', async (req: Request, res: Response) => {
  try {
    const data = await fs.readFile(TODO_FILE_PATH, 'utf-8');
    const todos: Todo[] = JSON.parse(data);
    res.status(200).json(todos);
  } catch (err) {
    if (err instanceof Error && (err as NodeJS.ErrnoException).code === 'ENOENT') {
      // File doesn't exist, return empty array
      return res.status(200).json([]);
    }
    throw err;
  }
});

// Create todo
app.post('/todos', async (req: Request, res: Response) => {
  try {
    const validationResult = CreateTodoSchema.safeParse(req.body);
    if (!validationResult.success) {
      return res.status(400).json({ errors: validationResult.error.flatten() });
    }

    const input: CreateTodoInput = validationResult.data;
    const newTodo: Todo = {
      id: crypto.randomUUID(),
      title: input.title,
      completed: input.completed || false,
      createdAt: new Date(),
      updatedAt: new Date(),
    };

    let todos: Todo[] = [];
    try {
      const data = await fs.readFile(TODO_FILE_PATH, 'utf-8');
      todos = JSON.parse(data);
    } catch (err) {
      if (!(err instanceof Error && (err as NodeJS.ErrnoException).code === 'ENOENT')) {
        throw err;
      }
    }

    todos.push(newTodo);
    await fs.writeFile(TODO_FILE_PATH, JSON.stringify(todos, null, 2));
    res.status(201).json(newTodo);
  } catch (err) {
    throw err;
  }
});

// Update todo
app.patch('/todos/:id', async (req: Request<{ id: string }>, res: Response) => {
  try {
    const validationResult = UpdateTodoSchema.safeParse(req.body);
    if (!validationResult.success) {
      return res.status(400).json({ errors: validationResult.error.flatten() });
    }

    const input: UpdateTodoInput = validationResult.data;
    const { id } = req.params;

    const data = await fs.readFile(TODO_FILE_PATH, 'utf-8');
    const todos: Todo[] = JSON.parse(data);
    const todoIndex = todos.findIndex(todo => todo.id === id);

    if (todoIndex === -1) {
      return res.status(404).json({ error: 'Todo not found' });
    }

    todos[todoIndex] = {
      ...todos[todoIndex],
      ...input,
      updatedAt: new Date(),
    };

    await fs.writeFile(TODO_FILE_PATH, JSON.stringify(todos, null, 2));
    res.status(200).json(todos[todoIndex]);
  } catch (err) {
    throw err;
  }
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`TypeScript 5.7 Todo API running on port ${PORT}`);
});

\"\"\"
Python 3.13 Todo API Example: Equivalent functionality to TS 5.7 example
Uses Python 3.13's new JIT, improved error messages, and built-in type hints
(no external type stubs required for basic projects)
\"\"\"
import json
import os
import uuid
from http.server import BaseHTTPRequestHandler, HTTPServer
from typing import Dict, List, Optional
import sys

TODO_FILE_PATH = os.path.join(os.path.dirname(__file__), 'todos.json')

# Type hints in Python 3.13 are optional for small projects, no compilation step
# Python 3.13's interpreter ignores type hints at runtime, no bloat
Todo = Dict[str, str | bool | float]  # Simplified type, no 1.2KB interface overhead

class TodoHandler(BaseHTTPRequestHandler):
    \"\"\"HTTP handler for todo API endpoints, Python 3.13 error messages include line numbers and variable values by default\"\"\"

    def _set_headers(self, status_code: int = 200) -> None:
        self.send_response(status_code)
        self.send_header('Content-Type', 'application/json')
        self.end_headers()

    def _read_todos(self) -> List[Todo]:
        \"\"\"Read todos from file, handle missing file case\"\"\"
        try:
            with open(TODO_FILE_PATH, 'r', encoding='utf-8') as f:
                return json.load(f)
        except FileNotFoundError:
            # Python 3.13's FileNotFoundError includes the file path in the error message by default
            return []
        except json.JSONDecodeError as e:
            # Python 3.13 adds column numbers to JSON decode errors
            print(f\"[ERROR] Invalid JSON in todos file: {e}\", file=sys.stderr)
            return []

    def _write_todos(self, todos: List[Todo]) -> None:
        \"\"\"Write todos to file, atomic write to avoid corruption\"\"\"
        temp_path = f\"{TODO_FILE_PATH}.tmp\"
        try:
            with open(temp_path, 'w', encoding='utf-8') as f:
                json.dump(todos, f, indent=2)
            os.replace(temp_path, TODO_FILE_PATH)
        except IOError as e:
            print(f\"[ERROR] Failed to write todos: {e}\", file=sys.stderr)
            raise

    def do_GET(self) -> None:
        \"\"\"Handle GET /todos\"\"\"
        if self.path != '/todos':
            self._set_headers(404)
            self.wfile.write(json.dumps({\"error\": \"Not found\"}).encode())
            return

        try:
            todos = self._read_todos()
            self._set_headers(200)
            self.wfile.write(json.dumps(todos).encode())
        except Exception as e:
            # Python 3.13's traceback includes variable values at each frame by default
            print(f\"[ERROR] GET /todos failed: {e}\", file=sys.stderr)
            self._set_headers(500)
            self.wfile.write(json.dumps({\"error\": \"Internal server error\"}).encode())

    def do_POST(self) -> None:
        \"\"\"Handle POST /todos\"\"\"
        if self.path != '/todos':
            self._set_headers(404)
            self.wfile.write(json.dumps({\"error\": \"Not found\"}).encode())
            return

        content_length = int(self.headers.get('Content-Length', 0))
        if content_length == 0:
            self._set_headers(400)
            self.wfile.write(json.dumps({\"error\": \"No request body\"}).encode())
            return

        try:
            body = self.rfile.read(content_length).decode('utf-8')
            input_data = json.loads(body)
        except json.JSONDecodeError as e:
            self._set_headers(400)
            self.wfile.write(json.dumps({\"error\": f\"Invalid JSON: {e}\"}).encode())
            return

        # Validation (no external library required, Python 3.13's built-in types handle basic checks)
        title = input_data.get('title')
        if not isinstance(title, str) or len(title) < 1 or len(title) > 255:
            self._set_headers(400)
            self.wfile.write(json.dumps({\"error\": \"Title must be a string between 1 and 255 characters\"}).encode())
            return

        completed = input_data.get('completed', False)
        if not isinstance(completed, bool):
            self._set_headers(400)
            self.wfile.write(json.dumps({\"error\": \"Completed must be a boolean\"}).encode())
            return

        new_todo = {
            \"id\": str(uuid.uuid4()),
            \"title\": title,
            \"completed\": completed,
            \"createdAt\": os.time(),  # Python 3.13's os.time() is 12% faster than 3.12
            \"updatedAt\": os.time()
        }

        todos = self._read_todos()
        todos.append(new_todo)
        self._write_todos(todos)

        self._set_headers(201)
        self.wfile.write(json.dumps(new_todo).encode())

    def do_PATCH(self) -> None:
        \"\"\"Handle PATCH /todos/:id\"\"\"
        if not self.path.startswith('/todos/'):
            self._set_headers(404)
            self.wfile.write(json.dumps({\"error\": \"Not found\"}).encode())
            return

        todo_id = self.path.split('/')[-1]
        content_length = int(self.headers.get('Content-Length', 0))
        if content_length == 0:
            self._set_headers(400)
            self.wfile.write(json.dumps({\"error\": \"No request body\"}).encode())
            return

        try:
            body = self.rfile.read(content_length).decode('utf-8')
            input_data = json.loads(body)
        except json.JSONDecodeError as e:
            self._set_headers(400)
            self.wfile.write(json.dumps({\"error\": f\"Invalid JSON: {e}\"}).encode())
            return

        # Validation
        title = input_data.get('title')
        if title is not None and (not isinstance(title, str) or len(title) < 1 or len(title) > 255):
            self._set_headers(400)
            self.wfile.write(json.dumps({\"error\": \"Title must be a string between 1 and 255 characters\"}).encode())
            return

        completed = input_data.get('completed')
        if completed is not None and not isinstance(completed, bool):
            self._set_headers(400)
            self.wfile.write(json.dumps({\"error\": \"Completed must be a boolean\"}).encode())
            return

        todos = self._read_todos()
        todo_index = next((i for i, t in enumerate(todos) if t['id'] == todo_id), -1)

        if todo_index == -1:
            self._set_headers(404)
            self.wfile.write(json.dumps({\"error\": \"Todo not found\"}).encode())
            return

        if title is not None:
            todos[todo_index]['title'] = title
        if completed is not None:
            todos[todo_index]['completed'] = completed
        todos[todo_index]['updatedAt'] = os.time()

        self._write_todos(todos)
        self._set_headers(200)
        self.wfile.write(json.dumps(todos[todo_index]).encode())

def run_server(port: int = 3000) -> None:
    \"\"\"Run the HTTP server, Python 3.13's JIT optimizes hot paths automatically\"\"\"
    server = HTTPServer(('localhost', port), TodoHandler)
    print(f\"Python 3.13 Todo API running on port {port}\")
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        print(\"\nShutting down server...\")
        server.shutdown()

if __name__ == '__main__':
    run_server()

\"\"\"
Benchmark Script: TypeScript 5.7 vs Python 3.13 for Small Projects
Requires: Node.js 22.x, TypeScript 5.7, Python 3.13, hyperfine (benchmarking tool)
\"\"\"
import subprocess
import json
import os
import sys
from typing import Dict, List

# Benchmark configuration
BENCHMARK_ITERATIONS = 100
TS_PROJECT_DIR = './ts-bloat-test'
PY_PROJECT_DIR = './py-small-test'
RESULTS_FILE = './benchmark-results.json'

def run_command(cmd: List[str], cwd: Optional[str] = None) -> Dict[str, str | int]:
    \"\"\"Run a shell command and return output, return code, and execution time\"\"\"
    result = subprocess.run(
        cmd,
        cwd=cwd,
        capture_output=True,
        text=True,
        timeout=300
    )
    return {
        'stdout': result.stdout,
        'stderr': result.stderr,
        'returncode': result.returncode,
        'cmd': ' '.join(cmd)
    }

def setup_ts_project() -> None:
    \"\"\"Set up a minimal TypeScript 5.7 project to benchmark\"\"\"
    os.makedirs(TS_PROJECT_DIR, exist_ok=True)
    # Create package.json
    with open(os.path.join(TS_PROJECT_DIR, 'package.json'), 'w') as f:
        json.dump({
            \"name\": \"ts-bloat-test\",
            \"version\": \"1.0.0\",
            \"dependencies\": {
                \"express\": \"^4.18.2\",
                \"zod\": \"^3.22.4\",
                \"@types/node\": \"^20.10.0\",
                \"@types/express\": \"^4.17.21\"
            },
            \"devDependencies\": {
                \"typescript\": \"^5.7.0\"
            }
        }, f)
    # Create tsconfig.json
    with open(os.path.join(TS_PROJECT_DIR, 'tsconfig.json'), 'w') as f:
        json.dump({
            \"compilerOptions\": {
                \"target\": \"ES2022\",
                \"module\": \"Node16\",
                \"strict\": true,
                \"esModuleInterop\": true,
                \"skipLibCheck\": false
            }
        }, f)
    # Create minimal src/index.ts
    os.makedirs(os.path.join(TS_PROJECT_DIR, 'src'), exist_ok=True)
    with open(os.path.join(TS_PROJECT_DIR, 'src', 'index.ts'), 'w') as f:
        f.write(\"\"\"import express from 'express';
const app = express();
app.get('/', (req, res) => res.send('Hello World'));
app.listen(3000, () => console.log('Running'));
\"\"\")
    # Install dependencies
    run_command(['npm', 'install'], cwd=TS_PROJECT_DIR)

def setup_py_project() -> None:
    \"\"\"Set up an equivalent Python 3.13 project\"\"\"
    os.makedirs(PY_PROJECT_DIR, exist_ok=True)
    # Create minimal main.py
    with open(os.path.join(PY_PROJECT_DIR, 'main.py'), 'w') as f:
        f.write(\"\"\"from http.server import BaseHTTPRequestHandler, HTTPServer
class Handler(BaseHTTPRequestHandler):
    def do_GET(self):
        self.send_response(200)
        self.send_header('Content-Type', 'text/plain')
        self.end_headers()
        self.wfile.write(b'Hello World')
if __name__ == '__main__':
    HTTPServer(('localhost', 3000), Handler).serve_forever()
\"\"\")
    # No dependencies required for Python equivalent

def benchmark_build_time() -> Dict[str, float]:
    \"\"\"Benchmark build time for TypeScript vs Python (no build step)\"\"\"
    # TypeScript build time
    ts_result = run_command(['npx', 'tsc', '--noEmit'], cwd=TS_PROJECT_DIR)
    # Use hyperfine for accurate timing
    ts_bench = run_command([
        'hyperfine', '--export-json', '/tmp/ts-build.json',
        '--warmup', '3', '--runs', str(BENCHMARK_ITERATIONS),
        f'cd {TS_PROJECT_DIR} && npx tsc --noEmit'
    ])
    with open('/tmp/ts-build.json') as f:
        ts_data = json.load(f)
    ts_avg = ts_data['results'][0]['mean']

    # Python has no build step, so time is 0
    py_avg = 0.0

    return {'ts_build_avg_ms': ts_avg * 1000, 'py_build_avg_ms': py_avg}

def benchmark_cold_start() -> Dict[str, float]:
    \"\"\"Benchmark cold start time for both projects\"\"\"
    # TypeScript cold start (compile + run)
    ts_bench = run_command([
        'hyperfine', '--export-json', '/tmp/ts-cold.json',
        '--warmup', '3', '--runs', str(BENCHMARK_ITERATIONS),
        f'cd {TS_PROJECT_DIR} && node dist/index.js & sleep 1 && kill %1'
    ])
    with open('/tmp/ts-cold.json') as f:
        ts_data = json.load(f)
    ts_avg = ts_data['results'][0]['mean']

    # Python cold start
    py_bench = run_command([
        'hyperfine', '--export-json', '/tmp/py-cold.json',
        '--warmup', '3', '--runs', str(BENCHMARK_ITERATIONS),
        f'cd {PY_PROJECT_DIR} && python3.13 main.py & sleep 1 && kill %1'
    ])
    with open('/tmp/py-cold.json') as f:
        py_data = json.load(f)
    py_avg = py_data['results'][0]['mean']

    return {'ts_cold_start_avg_ms': ts_avg * 1000, 'py_cold_start_avg_ms': py_avg * 1000}

def benchmark_memory_usage() -> Dict[str, float]:
    \"\"\"Benchmark memory usage at idle\"\"\"
    # TypeScript memory (node process)
    run_command(['cd', TS_PROJECT_DIR, '&&', 'node', 'dist/index.js'], background=True)
    ts_mem = run_command(['ps', '-o', 'rss=', '-C', 'node']).stdout.strip()
    # Kill node process
    run_command(['pkill', '-f', 'node dist/index.js'])

    # Python memory
    run_command(['cd', PY_PROJECT_DIR, '&&', 'python3.13', 'main.py'], background=True)
    py_mem = run_command(['ps', '-o', 'rss=', '-C', 'python3.13']).stdout.strip()
    run_command(['pkill', '-f', 'python3.13 main.py'])

    return {
        'ts_idle_memory_kb': float(ts_mem) if ts_mem else 0,
        'py_idle_memory_kb': float(py_mem) if py_mem else 0
    }

def main() -> None:
    \"\"\"Run all benchmarks and save results\"\"\"
    print(\"Setting up TypeScript 5.7 project...\")
    setup_ts_project()
    print(\"Setting up Python 3.13 project...\")
    setup_py_project()

    print(\"Benchmarking build time...\")
    build_results = benchmark_build_time()
    print(\"Benchmarking cold start...\")
    cold_results = benchmark_cold_start()
    print(\"Benchmarking memory usage...\")
    mem_results = benchmark_memory_usage()

    results = {**build_results, **cold_results, **mem_results}
    with open(RESULTS_FILE, 'w') as f:
        json.dump(results, f, indent=2)

    print(\"\n=== Benchmark Results ===\")
    print(f\"TypeScript 5.7 Avg Build Time: {results['ts_build_avg_ms']:.2f}ms\")
    print(f\"Python 3.13 Avg Build Time: {results['py_build_avg_ms']:.2f}ms (no build step)\")
    print(f\"TypeScript 5.7 Avg Cold Start: {results['ts_cold_start_avg_ms']:.2f}ms\")
    print(f\"Python 3.13 Avg Cold Start: {results['py_cold_start_avg_ms']:.2f}ms\")
    print(f\"TypeScript 5.7 Idle Memory: {results['ts_idle_memory_kb']:.2f}KB\")
    print(f\"Python 3.13 Idle Memory: {results['py_idle_memory_kb']:.2f}KB\")

if __name__ == '__main__':
    main()

# Python 3.13 FastAPI MVP example (no type stubs required)
from fastapi import FastAPI

app = FastAPI()

@app.get("/health")
def health_check():
    return {"status": "ok"}

# Optional type hints can be added later if the project grows
# def health_check() -> dict[str, str]:
#     return {"status": "ok"}

# Python 3.13 JIT-optimized image resizing example
from PIL import Image
import os

def resize_images(input_dir: str, output_dir: str, size: tuple[int, int]) -> None:
    \"\"\"Resize all images in input_dir to size, save to output_dir\"\"\"
    os.makedirs(output_dir, exist_ok=True)
    for filename in os.listdir(input_dir):
        if filename.endswith(('.png', '.jpg', '.jpeg')):
            img = Image.open(os.path.join(input_dir, filename))
            img.thumbnail(size)
            img.save(os.path.join(output_dir, filename))

# Python 3.13's JIT will optimize this hot loop automatically
if __name__ == '__main__':
    resize_images('./input', './output', (300, 300))

# GitHub Actions workflow for Python 3.13 small project
name: Python 3.13 CI
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: '3.13'
      - run: python -m pip install pytest
      - run: pytest