the dead
basics

#!/usr/bin/env python3          ← shebang: "use whichever python3 is on PATH"
import sys, os                  ← modules: code someone else wrote, pulled in by name

name = sys.argv[1] if len(sys.argv) > 1 else "world"   ← argv[0] is the script itself
mode = os.environ.get("MODE", "dev")                      ← env var with a default
print(f"hello {name} ({mode})")                          ← writes to stdout
sys.exit(0 if name != "nobody" else 1)                   ← the exit code

# three ways to run the same file:
#   python3 hello.py jamal        → interpreter reads the file
#   chmod +x hello.py && ./hello.py jamal   → shell reads the shebang, finds python3
#   MODE=prod ./hello.py jamal && echo "ok"  → env var set for one run; echo only fires if exit was 0

def in_ring(lon, lat, ring):                    ← a function: name, inputs, one job
    """ray-cast point-in-polygon. crossings odd → inside."""
    inside = False
    j = len(ring) - 1                           ← len() works on any sequence
    for i in range(len(ring)):                  ← loop by index because we need i and j
        xi, yi = ring[i][0], ring[i][1]           ← unpacking: two names from two values
        xj, yj = ring[j][0], ring[j][1]
        if (yi > lat) != (yj > lat) and lon < (xj - xi) * (lat - yi) / (yj - yi) + xi:
            inside = not inside                 ← flip on every edge crossing
        j = i
    return inside

owners = {}                                     ← a dict, filled as we go
for v in vignettes:                             ← vignettes is a list of dicts from json
    near = {f["properties"]["id"]                 ← a set comprehension: build the set in one expression
            for f in feats
            if in_ring(v["lon"], v["lat"], f["geometry"]["coordinates"][0])}
    owners[v["id"]] = near or {nearest(feats, v)}  ← "or": empty set is falsy, so fall back
print(f"{len(owners)} vignettes mapped")

async function loadVignettes() {                      ← async: this function can await
  const res = await fetch("/data/vignettes.json");      ← hands off to the network, this function pauses
  if (!res.ok) throw new Error(`http ${res.status}`);   ← 404, 500: ok is false, so bail loudly
  return res.json();                                  ← also a promise; caller awaits it
}

const vignettes = await loadVignettes();
const byId = Object.fromEntries(vignettes.map(v => [v.id, v]));   ← array → object in one line

canvas.addEventListener("pointermove", (e) => {        ← the DOM: react to the user
  requestAnimationFrame(() => {                        ← "do this on the next painted frame"
    const hit = pick(e.clientX, e.clientY);            ← raycast; expensive, so once per frame max
    setHover(hit ? hit.id : null);
  });
});

export interface VignetteDef {                 ← a named shape
  id: string; lon: number; lat: number;
  needs: "land" | "water";                       ← a union of two literal strings
}

export function vignetteRegionMap(
  peoples: PeopleFeature[],                     ← array of a shape
  vignettes: VignetteDef[],
): Map<string, Set<string>> { /* … */ }         ← generic: map of id → set of ids

// the consumer, before the fix. `owners` is a Set<string>, hoverId is string | null.
const owners = regionOf.get(v.id);
if (owners !== hoverId) return null;            ← a Set is never === a string. always true. nothing ever rendered.

// after. membership, not equality.
const shown = owners != null && hoverId != null && owners.has(hoverId);   ← narrowing: inside this expression hoverId is a string

// server: a next.js route handler. this file IS the endpoint.
export async function GET() {
  const ok = await db.ping();
  return Response.json({ ok, at: Date.now() }, { status: ok ? 200 : 503 });   ← 503: "we are not fine"
}

// browser: a react component. state in, markup out.
function Health() {
  const [status, setStatus] = useState<"…" | "ok" | "down">("…");   ← state: changing it re-renders
  useEffect(() => {                                     ← effect: runs after render, once ([])
    fetch("/api/health").then(r => setStatus(r.ok ? "ok" : "down"));
  }, []);
  return <span data-status={status}>{status}</span>;     ← jsx: markup as a return value
}

# pipe: list files, keep the ones that look like a CV, show the newest
ls -lt ~/Downloads | grep -iE 'cv|resume' | head -3

# chain: only deploy if typecheck AND build both exited 0
npx tsc --noEmit && npm run build && npx wrangler pages deploy dist

# surgical undo: bring ONE file back from an old commit, keep everything else
git checkout a8a7c09 -- src/ui/Chrome.tsx           ← the attribution rollback
git commit -m "Roll back on-page model attribution"   ← history moves forward, nothing rewritten

# the one you do not run on a tree holding someone else's work
git reset --hard origin/main                          ← uncommitted changes are gone. no undo.

FROM python:3.12-slim                   ← start from an image someone maintains
WORKDIR /app
COPY requirements.txt .                 ← copy deps first so this layer caches
RUN pip install --no-cache-dir -r requirements.txt
COPY . .                                ← now the code; changes here do not re-run pip
ENV PORT=8080
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8080"]   ← the process the container runs

# deployment.yaml · "keep three of these alive, roll them one at a time"
apiVersion: apps/v1
kind: Deployment
metadata: { name: ava }
spec:
  replicas: 3                           ← three pods; one dies, kubernetes starts another
  selector: { matchLabels: { app: ava } }
  template:
    metadata: { labels: { app: ava } }
    spec:
      containers:
      - name: ava
        image: europe-docker.pkg.dev/stryde/ava:1.4.2   ← the image from the registry, pinned
        ports: [{ containerPort: 8080 }]
        envFrom: [{ secretRef: { name: ava-secrets } }]  ← secrets as env, never in the image
        resources: { limits: { memory: "512Mi", cpu: "500m" } }   ← the bill, in advance

alter table public.players enable row level security;   ← from now on, no policy = no rows

create policy "members read their club"
  on public.players for select
  using ( private.is_club_member(club_id) );           ← the policy is a boolean sql expression per row

grant execute on function private.is_club_member(uuid)
  to anon, authenticated, service_role;                ← roles: who is asking. these are not secrets.

-- the question the app asks, and what the database actually answers
select p.name, s.rpe, s.minutes
from players p
join session_loads s on s.player_id = p.id            ← join on the shared key
where s.logged_on > now() - interval '28 days'        ← the ACWR window; an index on logged_on makes this cheap
order by s.logged_on desc;