Go — Beginner to Advanced (from TypeScript & Python)

package main

import (
    "encoding/json"
    "log"
    "net/http"
)

func healthz(w http.ResponseWriter, r *http.Request) {
    _ = r.Context()
    w.Header().Set("Content-Type", "application/json")
    _ = json.NewEncoder(w).Encode(map[string]string{"ok": "true"})
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("GET /healthz", healthz)
    log.Fatal(http.ListenAndServe(":8080", mux))
}

import express from "express";

const app = express();
app.get("/healthz", (_req, res) => {
  res.json({ ok: "true" });
});
app.listen(8080);

from fastapi import FastAPI

app = FastAPI()

@app.get("/healthz")
def healthz():
    return {"ok": "true"}

package config

import (
    "errors"
    "fmt"
    "os"
)

var ErrMissing = errors.New("missing config")

func Load(path string) ([]byte, error) {
    b, err := os.ReadFile(path)
    if err != nil {
        return nil, fmt.Errorf("load %s: %w", path, err)
    }
    if len(b) == 0 {
        return nil, ErrMissing
    }
    return b, nil
}

export class MissingConfigError extends Error {}

export async function load(path: string): Promise<Uint8Array> {
  try {
    const buf = await Deno.readFile(path);
    if (buf.byteLength === 0) throw new MissingConfigError("missing config");
    return buf;
  } catch (e) {
    throw new Error(`load ${path}`, { cause: e });
  }
}

class MissingConfigError(Exception):
    pass

def load(path: str) -> bytes:
    try:
        with open(path, "rb") as f:
            data = f.read()
    except OSError as exc:
        raise RuntimeError(f"load {path}") from exc
    if not data:
        raise MissingConfigError("missing config")
    return data

package fan

import (
    "context"
    "sync"
)

func FetchAll(ctx context.Context, urls []string, fetch func(context.Context, string) (string, error)) ([]string, error) {
    out := make([]string, len(urls))
    errCh := make(chan error, len(urls))
    var wg sync.WaitGroup
    for i, u := range urls {
        wg.Add(1)
        go func(i int, u string) {
            defer wg.Done()
            v, err := fetch(ctx, u)
            if err != nil {
                errCh <- err
                return
            }
            out[i] = v
        }(i, u)
    }
    wg.Wait()
    close(errCh)
    for err := range errCh {
        return nil, err
    }
    return out, nil
}

export async function fetchAll(
  urls: string[],
  fetchOne: (u: string, signal: AbortSignal) => Promise<string>,
  signal: AbortSignal,
): Promise<string[]> {
  return Promise.all(urls.map((u) => fetchOne(u, signal)));
}

import asyncio
from collections.abc import Awaitable, Callable

async def fetch_all(urls: list[str], fetch: Callable[[str], Awaitable[str]]) -> list[str]:
    return list(await asyncio.gather(*(fetch(u) for u in urls)))