Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 15: Wettkampf – Speed-Drills

Ziel: Zehn Alltagsaufgaben auf Zeit lösen und messen, wie viel schneller du ohne Maus geworden bist. · Dauer: ca. 90 min · Voraussetzung: Tag 14

Briefing

  • Zehn Drills, jeder mit Ausgangslage, Zeitlimit und Lösungsweg. Erst selbst lösen, dann nachlesen.
  • Zwei Zeiten pro Drill: Die Maus-Variante ist der Referenzwert mit Finder, Klicks und Pfeiltasten. Die Profi-Variante ist dein Ziel.
  • Die Stoppuhr wk startet mit wk <nr> und stoppt mit wk. Jede Zeit landet in ~/term-lab/wettkampf.csv.
  • Vorbereitung zählt nicht zur Zeit. Die Uhr läuft ab dem ersten Tastendruck nach wk <nr>.
  • Getestet auf macOS 15.6.1 mit zsh 5.9, tmux 3.8, fzf 0.74, atuin 18.23, Neovim 0.12, Git 2.56 und chezmoi 2.73. Unter macOS 26 sollte alles gleich laufen.
 wk 3 ──► Aufgabe lösen ──► wk ──► wettkampf.csv ──► wkstand (Punkte)
          ⌃R  ⌥R  ⌥.  ⌃X⌃E  ⌃a |  z  frg  …

Vorbereitung

Starte die Lab-Shell (~/term-lab/lab) und lege die Wettkampf-Datei an. Sie bringt die Stoppuhr, den SSH-Alias aus Tag 12 und eine chezmoi-Funktion für den „neuen Mac” mit:

cat > ~/term-lab/config/zsh/wettkampf.zsh <<'EOF'
# wettkampf.zsh – Stoppuhr und Helfer für die Speed-Drills (Tag 15)
zmodload zsh/datetime
wk() {
  if [[ -n $1 ]]; then                         # wk 3  -> Start Drill 3
    typeset -g WK_NR=$1 WK_T0=$EPOCHREALTIME
    print "⏱  Drill $1 läuft – fertig? Dann: wk"
  elif [[ -n $WK_T0 ]]; then                   # wk    -> Stopp + Protokoll
    local s=$(( EPOCHREALTIME - WK_T0 ))
    printf '✔ Drill %s: %.0f s\n' $WK_NR $s
    printf '%s;%s;%.0f\n' "$(date +%F)" $WK_NR $s >> $LAB/wettkampf.csv
    unset WK_T0
  else
    print -u2 "usage: wk <nr> (Start) | wk (Stopp)"; return 2
  fi
}

# SSH mit Lab-Konfiguration (Tag 12)
alias lssh='ssh -F ~/term-lab/ssh/config'

# chezmoi für den "neuen Mac" (Drill 10): leeres Home unter $LAB/wk/neu
czneu() {
  local N=$LAB/wk/neu
  chezmoi --source $N/src --destination $N/home --config $N/cfg/chezmoi.toml \
    --persistent-state $N/cfg/state.boltdb --cache $N/cfg/cache "$@"
}
EOF
reload
wk 0; sleep 1; wk

Erwartet:

⏱  Drill 0 läuft – fertig? Dann: wk
✔ Drill 0: 1 s

Den Probelauf löschst du wieder: sed -i '' '/;0;/d' ~/term-lab/wettkampf.csv.

Jetzt das Gelände. Ein eigener Branch schützt main, die Logs gibt es zusätzlich als JSON, zoxide kennt die Sprungziele, der Übungs-sshd aus Tag 12 läuft wieder, und ein kleines Dotfiles-Repo wartet auf den neuen Mac:

cd ~/term-lab/projekt
git switch main && git switch -c speed/fixup
jq -Rc 'split(" ") | {ts: .[0], mod: .[1], level: .[2],
  req: (.[3] | ltrimstr("request_id=")), user: (.[4] | ltrimstr("user="))}' \
  logs/app.log > logs/app.jsonl
zoxide add ~/term-lab/projekt{,/internal/cart,/deploy/k8s,/scripts} \
  ~/term-lab/config/zsh
/usr/sbin/sshd -f ~/term-lab/ssh/sshd_config -E ~/term-lab/ssh/sshd.log
lssh lab-bastion true
mkdir -p ~/term-lab/wk/neu/home ~/term-lab/wk/download
cp -R $BUCH/chezmoi/src ~/term-lab/wk/dotfiles
git -C ~/term-lab/wk/dotfiles init -q
git -C ~/term-lab/wk/dotfiles add -A
git -C ~/term-lab/wk/dotfiles commit -qm "Dotfiles (Lab)"
head -1 logs/app.jsonl

Erwartet (erste Zeile je nach Stand auch „Bereits auf ‘main’“):

Zu Branch 'main' gewechselt
Zu neuem Branch 'speed/fixup' gewechselt
{"ts":"2026-10-05T08:00:00","mod":"cart","level":"INFO","req":"r0000","user":"u00"}

Fehlt ~/term-lab/ssh/sshd_config, wiederhole Tag 12, Drill 1 und 2. Alle Logs sind Lab-Daten, die Datei app.jsonl steht dank logs/ in .gitignore nicht im Git-Status.

Drill 1: TODO finden und beheben

Ausgangslage: Du stehst in ~/term-lab/projekt. Irgendwo steht ein TODO zu Rabatten.

Aufgabe: Finde es, mach im Editor aus TODO ein NOTE, speichere. Danach gibt es im Projekt nur noch zwei TODOs.

Zeitlimit: Maus-Variante 120 s · Profi-Variante 20 s

Lösungsweg:

Schritt Taste / Befehl Wirkung
1 wk 1 Uhr läuft
2 frg TODO⏎ rg-Treffer in fzf (Tag 7)
3 rab ⏎ Treffer cart.go:16 wählen, nv öffnet Zeile 16
4 /TODO⏎ Cursor auf das Wort
5 ciw NOTE ⎋ Wort ersetzen (Tag 11)
6 :wq⏎ speichern, zurück in die Shell
7 wk Uhr stoppen
sed -n 16p internal/cart/cart.go
rg -c TODO

Erwartet:

    // NOTE: Rabatte berücksichtigen
scripts/report.py:1
cmd/shop/main.go:1

Ohne frg geht es fast genauso schnell mit der Quickfix-Liste: nv -q <(rg --vimgrep TODO) und :cn bis zum Rabatt-Treffer. Die Maus-Variante: Projekt im GUI-Editor öffnen, globale Suche, Treffer anklicken, Wort markieren, tippen, ⌘S.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Eine lange Befehlszeile umbauen

Ausgangslage: Am Prompt steht (noch nicht ausgeführt):

kubectl --context kunde-dev --namespace shop get pods -o wide

Aufgabe: Mach daraus ohne Pfeiltasten und ohne Neutippen kubectl --context kind-lab --namespace shop get deploy -o yaml.

Zeitlimit: Maus-Variante 45 s · Profi-Variante 10 s

Lösungsweg: Der Cursor steht am Zeilenende. Seit Tag 3 trennen - und / Wörter.

Schritt Tasten Puffer danach (Ausschnitt)
1 ⌃W yaml … get pods -o yaml
2 ⌥B ⌥B ⌥B Cursor vor pods
3 ⌥D deploy … get deploy -o yaml
4 ⌃A ⌥F ⌥F Cursor vor kunde-dev
5 ⌥D ⌥D kind-lab --context kind-lab --namespace …

Erwartet:

[lab] projekt % kubectl --context kind-lab --namespace shop get deploy -o yaml▮

Mit ⌃C verwerfen, ein Cluster ist nicht nötig. Zweiter Profi-Weg, wenn die alte Zeile schon in der History steht: History-Modifier hintereinander. HIST_VERIFY (Tag 4) zeigt das Ergebnis, erst das zweite ⏎ führt aus:

!!:s/kunde-dev/kind-lab/:s/pods/deploy/:s/wide/yaml/

Erwartet:

[lab] projekt % kubectl --context kind-lab --namespace shop get deploy -o yaml

Dritter Weg für noch längere Zeilen: ⌃X⌃E und in nv :s/kunde-dev/kind-lab/ (Tag 3). Die Maus-Variante: Pfeiltasten gedrückt halten, Zeichen für Zeichen löschen.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Einen Befehl aus der History retten

Ausgangslage: An Tag 6 hast du replicas per yq auf 5 gesetzt und nach rg gepipt. Seitdem liegen Hunderte Befehle dazwischen. Fehlt er in deiner History (neue Maschine), leg ihn vorher an: print -s "yq '.spec.replicas = 5' deploy/k8s/deployment.yaml | rg replicas".

Aufgabe: (a) Hol den Befehl zurück und führe ihn aus. (b) Finde den letzten fehlgeschlagenen Befehl, den du in ~/term-lab/projekt getippt hast.

Zeitlimit: Maus-Variante 60 s · Profi-Variante 5 s pro Teil

Lösungsweg:

Teil Tasten Wirkung
a ⌃R yq rep 5 ⏎ ⏎ fzf-History (Tag 7), Wortfetzen in beliebiger Reihenfolge
a yq ↑ Alternative: Präfix-Suche (Tag 4)
b ⌥R atuin öffnen (Tag 4)
b ⌃R bis [ DIRECTORY ] nur Befehle aus diesem Ordner

Erwartet nach (a):

[lab] projekt % yq '.spec.replicas = 5' deploy/k8s/deployment.yaml | rg replicas
  replicas: 5

In atuin sind fehlgeschlagene Befehle rot markiert. Als Einzeiler für Skripte und Runbooks geht (b) auch ohne Oberfläche:

atuin search --cwd $PWD --exclude-exit 0 --format "{exit}  {command}" | tail -3

Erwartet (deine Befehle weichen ab):

1  cat gibtsnicht.txt
1  kubectl --context kunde-dev get pods -n shop --request-timeout=1s
-1  atuin search --cwd $PWD --exclude-exit 0 --format "{exit}  {command}"

Der laufende Befehl selbst steht mit -1 am Ende, er hat noch keinen Exit-Code. Die Maus-Variante: im Terminal scrollen, ⌘F, markieren, kopieren, einfügen.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Fünf Verzeichnisse in zehn Sekunden

Ausgangslage: Du stehst in /tmp. Die Ziele kennt zoxide seit der Vorbereitung.

Aufgabe: Springe nacheinander nach internal/cart, deploy/k8s, ~/term-lab/config/zsh, projekt/scripts und zurück in die Projektwurzel. In jedem Ziel einmal pwd.

Zeitlimit: Maus-Variante 60 s · Profi-Variante 10 s

Lösungsweg:

z cart && pwd
z k8s && pwd
z conf zsh && pwd
z scr && pwd
z projekt && pwd

Erwartet:

/Users/du/term-lab/projekt/internal/cart
/Users/du/term-lab/projekt/deploy/k8s
/Users/du/term-lab/config/zsh
/Users/du/term-lab/projekt/scripts
/Users/du/term-lab/projekt

Mehrere Wörter grenzen ein: Das letzte muss im letzten Pfadteil stehen, darum conf zsh und nicht zsh conf. Bei Gleichstand öffnet zi die fzf-Auswahl, ⌥C sucht unterhalb des aktuellen Ordners (Tag 7). Die Maus-Variante: Finder, Ordner doppelklicken, Rechtsklick „Neues Terminal beim Ordner”.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Felder aus JSON-Logs ziehen

Ausgangslage: logs/app.jsonl aus der Vorbereitung, eine JSON-Zeile pro Logeintrag.

Aufgabe: (a) Zähle WARN- und ERROR-Einträge pro Komponente. (b) Gib die Request-IDs aller ERRORs von User u06 als kommagetrennte Liste aus. (c) Wann war der erste und wann der letzte ERROR?

Zeitlimit: Maus-Variante 300 s · Profi-Variante 60 s

Lösungsweg:

jq -r 'select(.level | test("WARN|ERROR")) | "\(.mod) \(.level)"' logs/app.jsonl |
  sort | uniq -c
jq -r 'select(.level == "ERROR" and .user == "u06") | .req' logs/app.jsonl |
  paste -sd, -
jq -sr 'map(select(.level == "ERROR"))
  | "\(length) Fehler, erster \(.[0].ts), letzter \(.[-1].ts)"' logs/app.jsonl

Erwartet:

  50 checkout ERROR
  50 http WARN
r0006,r0236,r0466
50 Fehler, erster 2026-10-05T08:06:42, letzter 2026-10-05T16:16:52

select() filtert Zeile für Zeile, -s (slurp) liest alles in ein Array, damit length, .[0] und .[-1] funktionieren. "\(.feld)" baut Text, -r gibt ihn ohne Anführungszeichen aus. Für (b) geht es auch rein in jq: jq -sr '[.[] | select(.level == "ERROR" and .user == "u06") | .req] | join(",")'. Die Maus-Variante: Datei in einen Editor laden, suchen, Treffer von Hand abzählen.

Tipp: Baue jq-Filter schrittweise mit ⌃X⌃E oder ↑: erst select, dann das Feld, dann die Pipe. Wer oft so arbeitet, nimmt das interaktive jnv oder fx dazu.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Projekt-Session mit drei Panes in einem Befehl

Ausgangslage: Du bist außerhalb von tmux, im Projektordner. Auf dem Lab-Server gibt es noch keine Session shop (tl kill-session -t shop räumt sie sonst ab).

Aufgabe: Ein einziger Befehl baut die Session shop: Fenster main, links ein großes Pane, rechts zwei übereinander, alle im Projektordner, der Cursor links.

Zeitlimit: Maus-Variante 90 s · Profi-Variante 10 s

Lösungsweg:

cd ~/term-lab/projekt
tl new -s shop -n main \; split-window -h \; split-window -v \; \
  select-layout main-vertical \; select-pane -t .1

Prüfen kannst du von innen mit:

tmux list-panes -F '#{pane_index} #{pane_width}x#{pane_height} #{pane_current_path}'

Erwartet (Größen hängen vom Fenster ab):

1 95x40 /Users/du/term-lab/projekt
2 64x20 /Users/du/term-lab/projekt
3 64x19 /Users/du/term-lab/projekt

\; trennt tmux-Befehle in einem Aufruf, der Backslash schützt das Semikolon vor der zsh. Neue Panes erben das Arbeitsverzeichnis des tmux-Clients, darum zuerst cd. Bist du schon in tmux, hängst du -d an new und springst mit tmux switch-client -t shop. Für jeden Tag gilt weiter tp aus Tag 9. Die Maus-Variante: iTerm2-Splits per Menü und dreimal cd.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Einen alten Commit reparieren

Ausgangslage: Auf speed/fixup ist internal/cart/cart.go aus Drill 1 geändert, noch nicht committet. Die Datei gehört zum Commit feat: Warenkorb und HTTP-Server, zwei Commits zurück.

Aufgabe: Falte die Änderung in diesen alten Commit, ohne Hash zu kopieren. main darf sich nicht bewegen.

Zeitlimit: Maus-Variante 300 s · Profi-Variante 45 s

Lösungsweg:

git add internal/cart/cart.go
git fixup ":/feat: Warenkorb"
GIT_SEQUENCE_EDITOR=: git ri --no-update-refs HEAD~3
git ll | head -3
git ll main | head -1

Erwartet (Hashes auf speed/fixup weichen ab):

[speed/fixup 22f86e0] fixup! feat: Warenkorb und HTTP-Server
 1 file changed, 1 insertion(+), 1 deletion(-)
Erfolgreich Rebase ausgeführt und refs/heads/speed/fixup aktualisiert.
519adf1 chore: Config, Manifeste, Report
121b13d feat: Warenkorb und HTTP-Server
1dc0abc init: Projektgerüst
2e4e6aa chore: Config, Manifeste, Report

git fixup und git ri sind die Aliase aus Tag 10. HEAD~3 ist der Commit vor dem Ziel. GIT_SEQUENCE_EDITOR=: übernimmt die sortierte Todo-Liste ohne Editor. Im Alltag lässt du die Variable weg, prüfst die Liste in nv und speicherst mit :wq.

Achtung: Ohne --no-update-refs zieht rebase.updateRefs = true aus der Lab-Gitconfig jeden Branch mit, der auf einen umgeschriebenen Commit zeigt. Hier wäre das main. Prüfe nach jedem Rebase mit git ll main, ob andere Branches gewandert sind.

Die Maus-Variante: lazygit oder eine GUI, Commit suchen, „Fixup”, Rebase anklicken. In lazygit geht es auch flott: Datei stagen mit space, Panel 4, Ziel-Commit wählen, F.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Port belegt – Prozess finden und beenden

Ausgangslage: Ein vergessener Testserver blockiert Port 8765. Starte ihn vor der Uhr:

python3 -m http.server 8765 --bind 127.0.0.1 -d ~/term-lab/projekt >/dev/null 2>&1 &!

&! startet im Hintergrund und löst den Job von der Shell. Er taucht in jobs nicht auf, kill %1 greift also nicht.

Aufgabe: Finde heraus, welcher Prozess auf 8765 lauscht, und beende ihn.

Zeitlimit: Maus-Variante 120 s · Profi-Variante 15 s

Lösungsweg:

port 8765
kill $(lsof -ti tcp:8765 -sTCP:LISTEN)
port 8765; echo "rc=$?"

Erwartet (PID weicht ab):

COMMAND   PID USER FD   TYPE             DEVICE SIZE/OFF NODE NAME
Python  44535 du    3u  IPv4 0xe93b2b70de3a3a0c      0t0  TCP 127.0.0.1:8765 (LISTEN)
rc=1

port ist die Funktion aus Tag 5. lsof -t gibt nur PIDs aus und passt damit direkt in kill. Interaktiv geht es auch mit fkill (Tag 7): 8765 tippen, ⏎. Die Maus-Variante: Aktivitätsanzeige, nach „Python” suchen, raten, welcher es ist, „Beenden”.

Fortschritt speichern? Kostenlos registrieren

Drill 9: SSH über die Bastion

Ausgangslage: Der Übungs-sshd aus Tag 12 läuft (Vorbereitung). lab-app erreichst du laut ~/term-lab/ssh/config nur über lab-bastion.

Aufgabe: (a) Zähle auf lab-app die ERROR-Zeilen in ~/term-lab/projekt/logs/app.log. (b) Hol die Datei nach ~/term-lab/wk/download/. (c) Prüfe, ob die Master-Verbindung steht.

Zeitlimit: Maus-Variante 180 s · Profi-Variante 20 s

Lösungsweg:

lssh lab-app 'grep -c ERROR ~/term-lab/projekt/logs/app.log'
scp -O -q -F ~/term-lab/ssh/config \
  lab-app:term-lab/projekt/logs/app.log ~/term-lab/wk/download/
wc -l < ~/term-lab/wk/download/app.log
lssh -O check lab-bastion

Erwartet (PID weicht ab):

50
     500
Master running (pid=44787)

Warum scp -O? Der Übungs-sshd hat kein SFTP-Subsystem konfiguriert, und neuere scp-Versionen nutzen standardmäßig SFTP. -O schaltet auf das alte Protokoll. Gegen echte Server lässt du -O weg. Ohne Konfiguration hilft -J: ssh -J bastion app-web01 (Tag 12). Die Maus-Variante: zwei Terminalfenster, erst Bastion, dann von dort weiter, Datei per Zwischenablage kopieren.

Tipp: lab-app und lab-bastion haben denselben Host, Port und User. Darum teilen sie sich über %C sogar den Master-Socket. Bei echten Servern hat jeder Host seinen eigenen.

Fortschritt speichern? Kostenlos registrieren

Drill 10: Neuer Mac – Dotfiles in einem Befehl

Ausgangslage: ~/term-lab/wk/neu/home ist das leere Home eines frischen Macs. ~/term-lab/wk/dotfiles ist dein Dotfiles-Repo (Kopie aus $BUCH/chezmoi/src).

Aufgabe: Bring Dotfiles und Git-Konfiguration für einen privaten Rechner auf den neuen Mac, ohne Pakete zu installieren. Prüfe danach Rechte, Drift und Brewfile.

Zeitlimit: Maus-Variante 1800 s · Profi-Variante 120 s

Lösungsweg:

czneu init --apply --exclude=scripts ~/term-lab/wk/dotfiles

chezmoi fragt einmal nach Rechnerart (privat) und Git-E-Mail. Für Skripte beantwortest du beides vorab mit --promptChoice Rechnerart=privat --promptString Git-E-Mail=… (Tag 13).

find ~/term-lab/wk/neu/home -type f | sed "s#$HOME/term-lab/wk/neu/##"
stat -f %Lp ~/term-lab/wk/neu/home/.config/termlab/secrets.env
czneu status
brew bundle check --no-upgrade --file=$(czneu source-path)/Brewfile

Erwartet (gekürzt):

Klone nach '/Users/du/term-lab/wk/neu/src'...
home/.config/termlab/secrets.env
home/.config/zsh/aliases.zsh
home/.gitconfig
home/.zshrc
600
 R .chezmoiscripts/10-brew.sh
The Brewfile's dependencies are satisfied.

init --apply klont das Repo, erzeugt die Konfiguration aus .chezmoi.toml.tmpl und schreibt alle Dateien. --exclude=scripts hält das brew bundle-Skript zurück, R in status zeigt: Es würde noch laufen. Auf einem echten Mac ist das genau der gewollte nächste Schritt, dort heißt der Befehl schlicht chezmoi init --apply <repo> (Tag 13, Drill 8). Die Maus-Variante: alter Mac, Finder, versteckte Dateien zeigen (⌘⇧.), einzeln per AirDrop kopieren und von Hand anpassen.

Fortschritt speichern? Kostenlos registrieren

Shortcut-Tabelle

Taste Wirkung Merkhilfe
⌃R / ⌥R History mit fzf / atuin Replay
⌃W / ⌥D Wort links / rechts löschen Wort, Delete
⌥B / ⌥F Wort zurück / vor Back, Forward
⌃X⌃E Zeile im Editor bauen eXtern Editieren
⌥C / z Ordner per fzf / zoxide Change dir
ciw Wort im Editor ersetzen change inner word
⌃a | / ⌃a - tmux-Split sieht aus wie der Schnitt
F in lazygit Fixup auf markierten Commit Fixup

Wertung

Die Stoppuhr hat jede Runde protokolliert. Eine kleine Funktion rechnet die beste Zeit pro Drill in Punkte um:

cat >> ~/term-lab/config/zsh/wettkampf.zsh <<'EOF'

# wkstand – beste Zeit je Drill, Punkte und Summe aus wettkampf.csv
wkstand() {
  awk -F';' '
    BEGIN { split("20 10 5 10 60 10 45 15 20 120", pro, " ")
            split("120 45 60 60 300 90 300 120 180 1800", maus, " ") }
    $2 > 0 && (!($2 in best) || $3 < best[$2]) { best[$2] = $3 }
    END {
      for (d = 1; d <= 10; d++) {
        if (!(d in best)) { printf "Drill %2d      –\n", d; continue }
        t = best[d]
        p = t <= pro[d] ? 3 : t <= 2 * pro[d] ? 2 : t <= maus[d] ? 1 : 0
        s += p
        printf "Drill %2d %5d s  Profi %4d s  %d P\n", d, t, pro[d], p
      }
      printf "Summe: %d von 30 Punkten\n", s
    }' "$LAB/wettkampf.csv"
}
EOF
reload
wkstand

Erwartet (Beispiel mit vier gemessenen Drills):

Drill  1    18 s  Profi   20 s  3 P
Drill  2     9 s  Profi   10 s  3 P
Drill  3      –
...
Drill  5   400 s  Profi   60 s  0 P
...
Drill 10   110 s  Profi  120 s  3 P
Summe: 9 von 30 Punkten
Zeit Punkte Bedeutung
bis Profi-Zeit 3 sitzt in den Fingern
bis doppelte Profi-Zeit 2 Weg klar, Hände noch langsam
bis Maus-Zeit 1 gelöst, aber nicht schneller als vorher
darüber 0 Tag zum Drill noch einmal machen

24 bis 30 Punkte: Senior-Tempo. 15 bis 23: solide, die schwächsten drei Drills eine Woche lang täglich wiederholen. Unter 15: Teil A (Tag 1 bis 4) noch einmal, dann neu messen. Jede Wiederholung landet in der CSV, wkstand nimmt immer die beste Zeit. So siehst du dein Vorher und Nachher.

Kontrollpunkt

Nach allen zehn Drills, in der Lab-Shell:

LAB=${LAB:-~/term-lab}; P=$LAB/projekt
SE=$LAB/wk/neu/home/.config/termlab/secrets.env
ok() { local m=$1; shift; "$@" >/dev/null 2>&1 && echo "✔ $m" || echo "✘ $m"; }
drills=$(cut -d';' -f2 "$LAB/wettkampf.csv" | grep -vx 0 | sort -u | wc -l)
ok "10 Drills gemessen"     test "$drills" -ge 10
ok "main unverändert"       test "$(git -C "$P" rev-parse --short main)" = 2e4e6aa
ok "kein fixup! übrig"      sh -c "! git -C '$P' log --format=%s main~2..speed/fixup |
                                   grep -q '^fixup!'"
ok "NOTE im alten Commit"   sh -c "git -C '$P' show \
                                   speed/fixup~1:internal/cart/cart.go | grep -q NOTE"
ok "JSON-Log komplett"      test "$(jq -s length "$P/logs/app.jsonl")" = 500
ok "zoxide kennt die Ziele" sh -c "_ZO_DATA_DIR='$LAB/zoxide' zoxide query -l |
                                   grep -q 'config/zsh$'"
ok "Port 8765 frei"         sh -c '! lsof -ti tcp:8765 -sTCP:LISTEN'
ok "Session shop: 3 Panes"  test "$(tl list-panes -t shop | wc -l)" -eq 3
ok "neuer Mac: .gitconfig"  grep -q zachmann "$LAB/wk/neu/home/.gitconfig"
ok "secrets.env ist 0600"   test "$(stat -f %Lp "$SE")" = 600

Erwartet:

✔ 10 Drills gemessen
✔ main unverändert
✔ kein fixup! übrig
✔ NOTE im alten Commit
✔ JSON-Log komplett
✔ zoxide kennt die Ziele
✔ Port 8765 frei
✔ Session shop: 3 Panes
✔ neuer Mac: .gitconfig
✔ secrets.env ist 0600

Ein ✘ bei „Session shop” heißt meist: Drill 6 lief in einem anderen tmux-Server. tl ls zeigt, was auf dem Lab-Socket läuft.

Challenge

Kombiniere Drill 1 und Drill 6 zu einem einzigen Befehl: Die Session shop2 hat dieselben drei Panes, links öffnet nv direkt das TODO in cmd/shop/main.go, rechts unten läuft tail -f logs/app.log, rechts oben wartet eine freie Shell. Ziel: unter 5 Sekunden, inklusive Tippen per ⌃R, sobald der Befehl einmal in der History steht.

Hinweis: send-keys -t .1 '<befehl>' Enter tippt in Pane 1 des aktuellen Fensters, und das geht auch mitten in einer \;-Kette.

Lösung

cd ~/term-lab/projekt
tl new -s shop2 -n main \; split-window -h \; split-window -v \; \
  select-layout main-vertical \; \
  send-keys -t .1 'nv +13 cmd/shop/main.go' Enter \; \
  send-keys -t .3 'tail -f logs/app.log' Enter \; select-pane -t .1

Prüfen aus einem anderen Pane (⌃a l):

tmux list-panes -F '#{pane_index} #{pane_current_command} active=#{pane_active}'

Erwartet:

1 nvim active=0
2 zsh active=1
3 tail active=0

Wer das täglich braucht, gießt es in ein Skript in ~/term-lab/bin oder erweitert tp (Tag 9). Ab dann reicht ⌃a f und ein Wortfetzen.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Speed zählt nur mit Sicherheit: Befehle gegen Prod (kubectl, ssh, terraform) bleiben langsam und bewusst. Prod-Wächter, roter Prompt und --readonly aus Tag 14 gelten auch im Wettkampf.
  • Pair-Programming und Screen-Sharing: Ansagen, was du drückst („⌃R, yq“). Für Zuschauende sind Shortcuts sonst Magie. iTerm2-Präsentationsprofil mit großer Schrift bereithalten (Tag 1).
  • Die Drills eignen sich als Onboarding-Übung im Team: gleiche Lab-Umgebung, gleiche Aufgaben, Zeiten im Retro vergleichen, nicht bewerten.
  • History, tmux-Scrollback und resurrect-Sicherungen enthalten nach so einem Tag viele Befehle. Vor dem Teilen von Bildschirm oder Dateien Secrets prüfen (Tag 4, Tag 9).
  • Was du dreimal schnell getippt hast, gehört ins Repo: als Alias, Funktion, just-Rezept oder Runbook-Schritt (Tag 5, Tag 14).

Aufräumen nach dem Wettkampf: tl kill-session -t shop, tl kill-session -t shop2, kill "$(cat ~/term-lab/ssh/sshd.pid)" und git switch main im Projekt. Den Branch speed/fixup und ~/term-lab/wk darfst du für Anhang B behalten.