Learning Tracks

int main(void) {
    char *you = "future C programmer";
    printf("Hello, %s!\n", you);
    return 0;

int main() {
    std::cout << "Modern C++ starts here\n";
}

class Program
{
    static void Main()
    {

const learner = "you";
console.log(`Hello, ${learner}!`);

name = "you"
print(f"Hello, {name}!")

        System.out.println("Hello, Java!");
    }
}

let name = "Swift"
print("Hello, \(name)!")

fn main() {
    println!("Hello, Rust!");
}

import "fmt"

func main() {
    fmt.Println("Hello, Go!")

puts "Hello, Ruby!"

  <body>
    <h1>Hello, web!</h1>
    <p>Your first page starts here.</p>
  </body>

  font-family: system-ui, sans-serif;
}

.card {

SELECT name, city
FROM customers
WHERE city = 'Boston'
ORDER BY name;

import statistics
minutes = [12, 15, 18, 20, 75]
print(statistics.mean(minutes), statistics.median(minutes))

from collections import Counter
words = "words make text".split()
print(Counter(words))

image = [[0, 40, 255], [20, 180, 255]]
print(len(image), len(image[0]))

chunks = {"returns#2": "Opened electronics: 14 days"}
best = max(chunks, key=lambda chunk: "electronics" in chunks[chunk])
print(chunks[best], f"[{best}]")

import json
print(json.dumps({"jsonrpc": "2.0", "id": 1, "method": "tools/list"}))

import math
probabilities = [0.5, 0.25, 0.8, 0.1]
loss = sum(-math.log(p) for p in probabilities) / len(probabilities)
print(f"perplexity: {math.exp(loss):.2f}")

parts = {"task": "Summarize the release notes", "format": "3 bullet points"}
print("
".join(f"<{name}>{text}</{name}>" for name, text in parts.items()))

    steps += 1
    failing -= 1
print(f"done in {steps} steps")

w = b = 0.0
for _ in range(500):
    error = w * x + b - y
    w -= 0.1 * 2 * np.mean(error * x)

W1, b1 = np.array([[1, 1], [1, 1]]), np.array([-0.5, -1.5])
hidden = (x @ W1 + b1 > 0) * 1
print((hidden @ [1, -1] - 0.5 > 0) * 1)

inputs = [1, 1, 0]
score = sum(w * x for w, x in zip(weights, inputs)) + bias
print("go outside!" if score > 0 else "stay in")

git status --short
git log --oneline -2

commits = ["feat: boss battles", "fix: wall clipping", "docs: controls"]
kinds = {c.split(":")[0] for c in commits}
major, minor, patch = 1, 4, 2
print(f"v{major}.{minor + 1}.0" if "feat" in kinds else f"v{major}.{minor}.{patch + 1}")

grep ERROR station.log | cut -d" " -f2 | sort | uniq -c | sort -nr | head -n 1

Import-Csv dragons.csv | Where-Object Temperament -eq 'grumpy' |
  Sort-Object { [int]$_.Wingspan } -Descending | Select-Object -First 1 -ExpandProperty Name

destination = "learn.example"
address = "203.0.113.8"
print(f"{destination} → {address}")

daily_users = 100_000_000
requests_per_user = 10
qps = daily_users * requests_per_user // 86_400
print(f"~{qps:,} requests/second")

nodes = 5
majority = nodes // 2 + 1
print(f"quorum: {majority} nodes")

saga = [("orders", "create"), ("payments", "charge"), ("kitchen", "cook")]
failed = 2
for service, action in reversed(saga[:failed]):
    print(f"{service}: undo {action}")

stages = ["build", "test", "scan", "deploy"]
for stage in stages:
    print(f"{stage:<7} ✓")
print("Byte Bakery is live!")

healthy = ["app-a", "app-b"]
backend = healthy[0]
print(f"route request -> {backend}")

host_cores = 8
allocated_vcpus = 12
print(f"overcommit={allocated_vcpus / host_cores:.2f}")

risks = {"phishing": 5 * 4, "laptop theft": 3 * 3}
print(max(risks, key=risks.get))

identity = "analyst"
action = "read_report"
allowed = check_access(identity, action)

    for i, num in enumerate(nums):
        if target - num in seen:
            return [seen[target - num], i]
        seen[num] = i

star = ["Situation", "Task", "Action", "Result"]
print(" -> ".join(star))

base, bonus_pct = 160_000, 10
equity_per_year = 240_000 // 4
total = base + base * bonus_pct // 100 + equity_per_year
print(f"Total compensation: {total:,}")