// Node.js — a first HTTP server
// File: server.js

const http = require("http");

const server = http.createServer((req, res) => {
  if (req.url === "/") {
    res.writeHead(200, { "Content-Type": "application/json" });
    res.end(JSON.stringify({ message: "Hello, Node!" }));
  } else {
    res.writeHead(404);
    res.end("Not found");
  }
});

const PORT = 3000;
server.listen(PORT, () => {
  console.log(`Server running at http://localhost:${PORT}`);
});

// Run: node server.js
// This is enough to serve an API —
// no frameworks, no setup, just JavaScript.

// Node.js + Express — a tiny REST API
// File: app.js

const express = require("express");
const app = express();

app.use(express.json());

let todos = [
  { id: 1, title: "Learn Node.js", done: false },
];

// GET all
app.get("/todos", (req, res) => {
  res.json(todos);
});

// POST one
app.post("/todos", (req, res) => {
  const { title } = req.body;
  if (!title) return res.status(400).json({ error: "title required" });

  const todo = { id: Date.now(), title, done: false };
  todos.push(todo);
  res.status(201).json(todo);
});

app.listen(3000, () => console.log("Listening on :3000"));

// Run: npm init -y
//      npm install express
//      node app.js

// Node.js — async I/O is its superpower
// Reading multiple files concurrently

const fs = require("fs/promises");

async function loadAll() {
  const [users, orders, products] = await Promise.all([
    fs.readFile("users.json", "utf8"),
    fs.readFile("orders.json", "utf8"),
    fs.readFile("products.json", "utf8"),
  ]);

  return {
    users: JSON.parse(users),
    orders: JSON.parse(orders),
    products: JSON.parse(products),
  };
}

loadAll()
  .then((data) => {
    console.log("Users:", data.users.length);
    console.log("Orders:", data.orders.length);
    console.log("Products:", data.products.length);
  })
  .catch((err) => console.error("Error:", err));

// Node shines at I/O-heavy work — APIs, files,
// DBs. That's why it's the default for web backends.

# PyTorch — tensors (the foundation)
import torch

x = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
y = torch.ones_like(x)

print("x:\n", x)
print("y:\n", y)
print("x + y:\n", x + y)
print("x @ y:\n", x @ y)   # matrix multiply

# GPU if available
device = "cuda" if torch.cuda.is_available() else "cpu"
x = x.to(device)
print("Device:", device, "| On device:", x.device)

# PyTorch — a minimal training loop
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import TensorDataset, DataLoader

# Tiny synthetic dataset
X = torch.randn(1000, 10)
y = (X.sum(dim=1) > 0).long()

loader = DataLoader(TensorDataset(X, y), batch_size=32, shuffle=True)

model = nn.Sequential(
    nn.Linear(10, 32),
    nn.ReLU(),
    nn.Linear(32, 2),
)

loss_fn = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)

for epoch in range(3):
    epoch_loss = 0
    for xb, yb in loader:
        logits = model(xb)
        loss = loss_fn(logits, yb)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        epoch_loss += loss.item()

    print(f"Epoch {epoch+1}: loss={epoch_loss/len(loader):.4f}")

# PyTorch — save and load models
import torch
import torch.nn as nn

# Save only the learned parameters (recommended)
torch.save(model.state_dict(), "model.pt")

# Recreate the model architecture, then load weights
model2 = nn.Sequential(
    nn.Linear(10, 32),
    nn.ReLU(),
    nn.Linear(32, 2),
)
model2.load_state_dict(torch.load("model.pt", weights_only=True))
model2.eval()

# Save / load the full model object (for quick prototyping)
torch.save(model, "model_full.pt")
model3 = torch.load("model_full.pt", weights_only=False)

# In production, always ship:
# 1. The state_dict
# 2. The model architecture code
# 3. The preprocessing pipeline
# — usually packaged with the codebase in Git.

Node.js — 30-day beginner plan:
Week 1: JS basics, async/await, npm, first server
Week 2: Express, middleware, REST APIs
Week 3: Databases (MongoDB or Postgres), auth
Week 4: Deploy a real API + small frontend

Result: Interview-ready for junior Node roles.

PyTorch — 30-day plan (assumes Python basics):
Week 1: Tensors, devices, autograd
Week 2: nn.Module, layers, loss functions
Week 3: Training loop, optimizers, metrics
Week 4: Real dataset project (MNIST or tabular)

Result: Can build a small model end-to-end.

Not recommended without:
- Python fundamentals
- Basic linear algebra
- Familiarity with NumPy
- Git (so you can share your work)

Web / backend path (recommended order):
1. JavaScript fundamentals   (3-4 weeks)
2. Node.js + Express          (4 weeks)
3. Databases (Mongo or Postgres) (2-3 weeks)
4. Auth + deployment          (2 weeks)
5. React / Next.js            (4-6 weeks)
6. Git + CI/CD                (ongoing)

Roles: Backend Developer, Full-Stack Developer,
       Web Engineer, Node.js Developer.

AI / ML path (recommended order):
1. Python fundamentals   (4-8 weeks)
2. NumPy + math basics   (2-4 weeks)
3. ML fundamentals       (4-8 weeks)
4. PyTorch               (4-8 weeks)
5. Hugging Face + LLMs   (2-4 weeks)
6. Deployment + MLOps    (4-8 weeks)

Roles: ML Engineer, AI Engineer,
       Research Engineer, MLOps Engineer.