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
wkstartet mitwk <nr>und stoppt mitwk. 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; wkErwartet:
⏱ 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.jsonlErwartet (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 TODOErwartet:
// 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 wideAufgabe: 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 -3Erwartet (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 && pwdErwartet:
/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.jsonlErwartet:
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⌃Eoder↑: erstselect, dann das Feld, dann die Pipe. Wer oft so arbeitet, nimmt das interaktivejnvoderfxdazu.
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 .1Prü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 -1Erwartet (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-refsziehtrebase.updateRefs = trueaus der Lab-Gitconfig jeden Branch mit, der auf einen umgeschriebenen Commit zeigt. Hier wäre dasmain. Prüfe nach jedem Rebase mitgit 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-bastionErwartet (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-appundlab-bastionhaben denselben Host, Port und User. Darum teilen sie sich über%Csogar 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/dotfileschezmoi 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)/BrewfileErwartet (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
wkstandErwartet (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")" = 600Erwartet:
✔ 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 .1Prü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--readonlyaus 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.