-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy paththesis.tex
2234 lines (1838 loc) · 90.5 KB
/
thesis.tex
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
\documentclass[oneside,bibliography=totocnumbered,BCOR=5mm]{scrbook}
\usepackage[ngerman]{babel}
\usepackage{fontspec}
% look up system fonts via fc-list
% \setmainfont
\setsansfont{SFNS Display}
\setmonofont{FuraCode Nerd Font Mono}
% see: jneidel.com/dot/.fonts
\usepackage[
backend=biber,
bibstyle=authoryear,
citestyle=authoryear,
autocite=footnote
]{biblatex}
\addbibresource{bibliography.bib}
\addbibresource{extra.bib}
\usepackage{graphicx}
\graphicspath{ {images/} }
\usepackage{float} % [H] on images to have them 'here'
\usepackage[newfloat]{minted}
\usepackage[hang, small,labelfont=bf,up,textfont=it,up]{caption}
\newenvironment{code}{\captionsetup{type=listing, skip=0pt}}{}
\SetupFloatingEnvironment{listing}{name=Listing}
\newminted{shell}{
linenos,
numbersep=6pt,
frame=lines,
framesep=2mm,
fontsize=\footnotesize
}
\newminted{javascript}{
linenos,
numbersep=6pt,
frame=lines,
framesep=2mm,
fontsize=\footnotesize
}
\newmintinline[codeinline]{shell}{
fontsize=\small
}
\newmintinline[codeinlinefn]{shell}{ % footnote
fontsize=\scriptsize
}
\usepackage{marvosym}
\usepackage{csquotes}
\usepackage{hyperref}
\usepackage{microtype} % Slightly tweak font spacing for aesthetics
\usepackage{nameref}
\usepackage[hmarginratio=1:1,top=32mm,columnsep=20pt]{geometry} % Document margins
\usepackage{booktabs} % Horizontal rules in tables
\usepackage{lettrine} % The lettrine is the first enlarged letter at the beginning of the text
\usepackage{enumitem} % Customized lists
\setlist[itemize]{noitemsep} % Make itemize lists more compact
\usepackage{fancyhdr} % Headers and footers
% \pagestyle{fancy} % All pages have headers and footers
\fancyhead{} % Blank out the default header
\fancyfoot{} % Blank out the default footer
\usepackage{titling} % Customizing the title section
\begin{document}
% Titelseite
% \pagestyle{empty} % keine Seitennummer
\begin{titlepage}
\begin{center}
\includegraphics{htw-logo.jpg}
\linebreak[4]
\linebreak[4]
\linebreak[4]
\linebreak[4]
\textit{\large Entwicklung und Evaluation von Methoden zur Absenkung der Nutzungsschwelle von Kommandozeilen-Interfaces}
\linebreak[4]
\linebreak[4]
\linebreak[4]
Abschlussarbeit
\linebreak[4]
\linebreak[4]
zur Erlangung des akademischen Grades:
\linebreak[4]
\linebreak[4]
\textbf{Bachelor of Science (B.Sc.)}
\linebreak[4]
\linebreak[4]
an der
\linebreak[4]
\linebreak[4]
Hochschule f\"ur Technik und Wirtschaft (HTW) Berlin
\linebreak[4]
Fachbereich 4: Informatik, Kommunikation und Wirtschaft
\linebreak[4]
Studiengang \textit{Angewandte Informatik}
\linebreak[4]
\linebreak[4]
\linebreak[4]
1. Gutachter: Prof. Dr.-Ing. Johann Habakuk Israel\linebreak[4]
2. Gutachter: B.Sc. Moritz Wachter\linebreak[4]
\linebreak[4]
\linebreak[4]
\linebreak[4]
\linebreak[4]
Eingereicht von Jonathan Neidel \textit{(573619)}
\linebreak[4]
\linebreak[4]
\linebreak[4]
\linebreak[4]
13. Februar 2023
\end{center}
\end{titlepage}
\newpage
\thispagestyle{empty}
\vspace*{2.2cm}
\noindent
{\Huge Danksagung}\\
\vspace*{1.6cm} \\
%\pagestyle{headings} % Kopfzeilen (automatisch erzeugt)
An Endava für die Möglichkeit diese Arbeit im Betrieb zu schreiben.
\medskip
An Moritz der dies ermöglicht hat und mir helfend zur Seite stand.
\medskip
An Herr Israel für die Beantwortung aller aufkommenden Fragen.
\medskip
An Sven für die kurzfristige Hilfe mit dem Abstract.
\medskip
An Francis und meine Mutter für den moralischen Support.
\newpage
\thispagestyle{empty}
\section*{Abstract}
Diese Arbeit beschäftigt sich mit der Verbesserung von Anwendungen mit
Kommandozeilen-Inferfaces, kurz CLI Apps. Zur Optimierung deren Usability wurden
die zwei zugrunde liegenden Probleme aufgezeigt. Es wurden anwendbare Methoden
erarbeitet, welche diese Probleme mitigieren sollen.
Die Umsetzung dieser Methoden wurde an einer Beispielanwendung durchgeführt, um
Details und Komplikationen in der Implementierung aufzuzeigen. Darüber hinaus
wurden Performance und Attraktivität verglichen, indem die Kommandozeilen
Anwendung einer grafischen gegenüber gestellt wurde.
Im Vergleich bevorzugten die sechs Teilnehmer die vergleichbare Performance als
auch die bessere Nutzbarkeit des Kommandozeilen-Interfaces.
\clearpage
\pagenumbering{roman}
\tableofcontents
.
\newpage
\pagenumbering{arabic}
\chapter{Einleitung}
\label{sec:einleitung}
\section{Hintergrund der Arbeit}
Diese Arbeit setzt sich mit dem Kommandozeilen-Interface auseinander. Laut
\cite{Raskin_2008} ist es ``still one of the most powerful interface paradigms
we have for controlling our computers.''. Gleichzeitig ist es aber auch als
traditionelles Interface Teil der Computergeschichte \parencite{nielson1993}.
Damit einher gehen Probleme und Schwächen.
\section{Problem- und Zielstellung}
% [Beschreibung der Problemstellung sowie der sich daraus ergebenden Teilprobleme,-ziele und Forschungsfrage(n), welche Sie mit Ihrer Arbeit addressieren]
\label{sec:problem}
Das Kommandozeilen-Interface ist heutzutage ein wenig verbreitetes
Anwendungs-Interface. Besonders in der allgemeinen Bevölkerung, aber selbst
unter Entwicklern werden für die meisten Anwendungsfälle grafische Apps
bevorzugt.
Das sich daraus ergebende Problem ist: Wie kann das Kommandozeilen-Interface
Entwicklern oder der Allgemeinheit näher gebracht werden? Das Teilproblem
im Fokus dieser Arbeit sind die Probleme in der Nutzbarkeit die ein
Kommandozeilen-Interface mit sich bringen kann.
Ziel ist es implementierbare Methoden zum Verbessern der Usability von
Anwendungen mit Kommandozeilen-Interface zu entwickeln. Die Anwendung dieser
sollte die Nutzungsschwelle von Kommandozeilen Apps abzusenken und an die
Usability von alternativen, meist grafischen Anwendungen angleichen. Um dies
zu demonstrieren sollen die entwickelten Methoden in einem Anwendungsbeispiel
implementiert und in einer Evaluation mit einer grafischen Alternative
verglichen werden.
\newpage
\section{Aufbau der Arbeit}
\begin{enumerate}
\item \textbf{\nameref{sec:einleitung}}
\smallbreak
Definieren der Ziele und Struktur.
\item \textbf{\nameref{sec:grundlagen}}
\smallbreak
Beschreiben grundlegenden Wissens.
\item \textbf{\nameref{sec:cli-problems}}
\smallbreak
Zusammenfassen von Problemen, welche das Nutzen von Kommandozeilen-Interfaces erschweren.
\item \textbf{\nameref{sec:methods}}
\smallbreak
Formulieren von Methoden um die zuvor geschilderten Probleme adressieren.
\item \textbf{\nameref{sec:beispiel-anwendung}}
\smallbreak
Definieren und Bauen einer CLI App als Beispiel zur Anwendung der Methoden.
\item \textbf{\nameref{sec:implementation}}
\smallbreak
Beschreiben von Details und Schwierigkeiten bei der Implementierung der Methoden.
\item \textbf{\nameref{sec:evaluation}}
\smallbreak
Durchführen einer vergleichenden Studie zwischen der implementierten CLI App
und einer funktionell gleichen\footnote{Im Kontext der Studie wird nur die von
beiden Anwendungen überlappende Funktionalität getestet und verglichen.} GUI
Webapp.
\item \textbf{\nameref{sec:zusammenfassung}}
\smallbreak
Ziehen einer Schlußfolgerung.
\end{enumerate}
\chapter{Grundlagen}
\label{sec:grundlagen}
\section{Historischer Kontext}
\label{sec:historic-context}
Die Kommandozeile ist ein Produkt der Evolution von Computern. Die ersten
Formen der Interaktion in Echtzeit kamen zusammen mit dem `teletypewriter'
(TTY), einem Schreibmaschinen-ähnlichem Gerät. Erstmals konnten Menschen
ihre Befehle eingeben und die direkt die Resultate sehen. Das Papier und die
mechanischen TTY's wurden schließlich durch text-darstellende Displays und
elektronische Tastaturen ersetzt. Diese Interaktionsform mit Tastatur und
Textausgabe ist als \textbf{Kommandozeilen-Interface (CLI)} bekannt geworden
\parencite[35f]{nagarajan2018}. Und funktioniert wie folgt:
\begin{enumerate}
\item Das System fordert den Nutzer auf einen Programmaufruf zu schreiben. (`Read')
\item Das System führt den Befehl aus und zeigt das Resultat. (`Eval' und `Print')
\item Diese Sequenz wiederholt sich nun unendlich. (`Loop')
\end{enumerate}
Ein System das dieses Vorgehen implementiert, wird auch als REPL
(`Read-eval-print loop`) Umgebung bezeichnet.
Um die Limitation der Kommandozeile\footnote{Im Kapitel \ref{sec:cli-problems}
wird noch tiefer auf die Probleme eingegangen.} zu adressieren, wurde
unter anderem das grafische User Interface (\textbf{GUI}) entwickelt
\parencite{nielson1993}. Welches von dem text-basierten CLI zu dem
heute allgegenwärtigen Fenster, `Icons', Menüs und die Maus mit sich
brachte\footnote{Mehr zu den Weiterentwicklung des CLI in Kapitel
\ref{sec:weiterentwicklungen}.}
\section{Vorteile der Kommandozeile}
Das CLI bietet Experten viel Flexibilität konstruieren eines (komplexen)
Operation \parencite{Norman_1983}. Ein Beispiel für diese Flexibilität wäre
folgendes. Es sollen alle PDF Dateien aus dem Jahr 2021 gelöscht werden, diese
haben etwa Namen wie: \codeinline{20210819-Rechnung.pdf}. In der Kommandozeile
kann dies mit \codeinline{rm 2021*.pdf} erreicht werden. Im grafischen Interface
müssten die Dateien markiert und gelöscht werden. Mit einer steigender Anzahl
von Dateien steigt auch der Aufwand und die Chance einen Fehler zu machen.
In der Shell funktioniert \codeinline{rm} auch problemlos bei einer Million
Dateien.
Ein weiter Vorteil für Experten liegt in dem Erstellen von Skripten. Mit Hilfe
dieser können Operationen automatisiert werden. Wenn z.B. eine der Rechnungen
aus dem letzten Paragraphen heruntergeladen wurde, kann diese mittels Skript
umbenannt, in den richtigen Ordner verschoben und der Todoliste ein Eintrag à la
`Rechnung xy begleichen' hinzugefügt werden. In einer graphischen Umgebung ist
diese Art von präziser Automatisierung nicht so einfach möglich.
Experten mit viel Wissen und Erfahrung mit dem System wissen meist exakt
welche Operation angewandt werden muss. In der Kommandozeile kann dies einfach
und direkt eingetippt werden. Während selbst Experten in grafischen und
Menü-basierten Interfaces sich immer durch die gleichen Menüs und Untermenüs
klicken müssen.
Als Text-basiertes Interface kommt der Kommandozeile die Klarheit von Worten
zugute. Abstrakte Konzepte wie Marxismus lassen sich nur schwer bis gar nicht in
Bildern beschreiben \parencite{Raskin_2008}, sind aber als Wort sehr umgänglich.
\section{Die Terminal Umgebung}
\label{sec:term_umgegebung}
Die moderne Kommandozeile existiert nicht mehr in Isolation. Um auf diese in
einem grafischen Fenstersystem zugreifen zu können, wird ein \textbf{Terminal
Emulator} benötigt. Wie der Name schon preisgibt: es soll ein traditionelles
text-basiertes Terminal nachgebildet werden. Als grafische Anwendung besteht
aber der Vorteil die Maus zum Klicken oder Markieren verwenden zu können. In
diesem Terminal läuft eine Shell. So nennt man das Programm, welches die Befehle
entgegennimmt und deren Resultate ermittelt und ausgibt. Am weitesten verbreitet
sind Unix Shells wie \codeinline{bash} oder \codeinline{zsh}.
Die Sprache der Shell gesprochen ist `Shell Script'. Dessen Funktionsumfang
variiert je nach Shell-Dialekt. Die meisten Unix Shells implementieren aber den
POSIX Standard und teilen deshalb eine gewisse Grundfunktionalität. DOS und
andere Windows Shells sind hier außen vor. Diese teilen weder Funktionalität
noch Core Utilities mit den Unix Shells. Die \codeinline{coreutils} sind
Grundlegende Werkzeuge zur Datei- und Textmanipulation \parencite{coreutils},
wie z.B. \codeinline{ls}, \codeinline{cat} oder \codeinline{rm}.
Neben der Shell gibt es noch andere Kommandozeilen Umgebungen. So gibt es
für viele Programmiersprachen eine Kommandozeile (z.B. für Node.js, Python
oder Scala). In diesen können dann nach gleichem REPL Schema Befehle in der
Programmiersprache interaktiv geschrieben und ausgeführt werden.
\section{Begrifflichkeiten der Kommandozeile}
\label{sec:begriffe}
Für ein Verständnis des CLI sind ein paar Begriffe zu definieren. Ein Shell
Befehl kann auf seine Einzelteile herunter gebrochen werden:
\begin{code}
\begin{shellcode}
$ cd Downloads
$ git commit -m "Inital commit"
\end{shellcode}
\end{code}
Das \codeinline{$} zu Beginn bezeichnet, dass nachfolgend Shell Code kommt. In
der ersten Zeile ist \codeinline{cd} das Kommando, was verwendet werden soll,
gefolgt von einem Argument, etwas das dem Kommando übergeben wird, in diesem
Falle der Name eines Ordners (names \codeinline{Downloads}.) Die Reihenfolge
ist dabei bei mehreren Argumenten entscheidend. In der zweiten Zeile wird
dem \codeinline{git} Kommando das Subkommando \codeinline{commit} übergeben
(\textcite{nagarajan2018}, \textcite{clig}.)
Nicht alle Kommandozeilen Apps haben Subkommandos. \textcite{12factor} definiert
zwei verschiedene Arten von CLI Anwendungen: ``single and multi-command''. Also
klassische `UNIX-Style' Werkzeuge wie \codeinline{cd}, \codeinline{cp} oder
\codeinline{grep}. Und jene Apps mit Subkommandos wie \codeinline{npm} oder
\codeinline{git}, die meist moderner und komplexer sind.
Zurück zu obigen \codeinline{git} Befehl: Dem \codeinline{commit} Subkommando
wird die \codeinline{-m} Flagge und mit ihr ein Parameter (die Nachricht
\codeinline{Inital commit}) übergeben. Die \codeinline{-m} Flagge ist die
Kurzversion der langen \codeinline{--message} Flagge. Kurze Flaggen bestehen
immer aus Bindestrich und einem Buchstaben. Lange Flaggen starten mit zwei
Bindestrichen gefolgt von einem oder mehr Wörtern (meist sind mehrere Wörter
auch durch Bindestriche verbunden, z.B. \codeinline{--non-interactive}.)
Funktionell sind beide Flaggenvarianten identisch. Flaggen die keinen Parameter
erfordern, werden als Boolean Flagge bezeichnet, deren An- oder Abwesenheit
meist etwas an- oder abschaltet. Die Reihenfolge der Flaggen untereinander ist
irrelevant (\textcite{nagarajan2018}, \textcite{clig}.)
\section{Usability}
\label{sec:usability}
\textcite[26]{nielsen1993} definiert Usability als eine Kombination aus mehreren
Attributen:
\begin{enumerate}
\item \textbf{Erlernbarkeit}:
Das System sollte einfach erlernbar sein, sodass Nutzer schnell produktiv damit arbeiten können.
\item \textbf{Effizienz}:
Sobald der Nutzer das System erlernt hat sollte ein hohes Maß an Produktivität möglich sein.
\item \textbf{Erinnerbarkeit}:
Das System sollte einfach zu erinnern sein. Nach einem Zeitraum des nicht Nutzens sollte das System nicht erneut erlernt werden müssen.
\item \textbf{Fehler}:
Das System sollte eine geringe Fehlerquote haben. Das heißt der Nutzer macht wenig Fehler und kann bei deren Auftreten gut mit ihnen umgehen.
\item \textbf{Befriedigung}:
Das System sollte angenehm zu nutzen sein. Die Nutzer sind subjektiv befriedigt.
\end{enumerate}
\chapter{Probleme des Kommandozeilen-Interface}
\label{sec:cli-problems}
\newcounter{prob}
Die Usability Schwierigkeiten des Kommandozeilen-Interfaces lassen sich auf zwei
fundamentale Probleme zurückführen.
\section{Erinnern von Kommandos}
`Command Recall' beschreibt die Problematik, dass ein Nutzer zum Verwenden eines
Programmes in der Kommandozeile immer dessen Namen kennen muss. Dies gilt für
Kommandos, deren Subkommandos und Flaggen, aber auch für die Reihenfolge von
Argumenten \parencite{Raskin_2008}.
\bigskip
\newcommand{\refcr}[1]{\hyperref[prob:cr]{#1}}
\newcommand{\refcrr}{\hyperref[prob:cr]{`Command Recall'}}
\fbox{\parbox{\linewidth}{
\refstepcounter{prob}
\label{prob:cr}
\textbf{Problem~\ref{prob:cr}}: Erinnern von Kommandos, Subkommandos, Flaggen und Argumenten.
}}
\bigskip
Dieses fundamentale Problem bedeutet, dass sich die Nutzer immer erst mit einem
Kommando auseinander setzen müssen, bevor sie dieses verwenden können. Auch
spielt das Vergessen mit der Zeit eine große Rolle. \textcite{Raskin_2008} weißt
auch auf teilweise geringe Einprägsamkeit von Befehlen wie \codeinline{tar -xzf
FILE}\footnote{Entpacken einer `gzipped tar' Datei (\codeinlinefn{tar.gz}).}
hin.
\begin{figure}[H]
\centering
\includegraphics[scale=0.5]{empty-prompt.png}
\caption{Die Shell bietet nichts an. Ohne ein Kommando zu kennen, passiert nichts.}
\end{figure}
\textcite{Gentner_1996} beschreiben auch den Fakt, dass es keinen einfachen Weg
zum Auffinden von Kommandos gibt. Der Nutzer muss also den Namen des Programmes
kennen um dieses zu nutzen oder auf dessen Hilfsseite oder `man page' zugreifen
zu können.
\section{Syntax und Semantik}
``Commands and associated parameters must be typed, maintaining the correct
semantic content and syntactic form.'' \parencite[184]{Westerman_1997}
\bigskip
\newcommand{\refss}[1]{\hyperref[prob:ss]{#1}}
\fbox{\parbox{\linewidth}{
\refstepcounter{prob}
\label{prob:ss}
\textbf{Problem \ref{prob:ss}}: Einhalten der richtigen Syntax and Semantik.
}}
\bigskip
Die Kommandozeile gilt als sehr starr und wenig tolerant gegenüber imperfekter
Syntax \parencite{Gentner_1996}. Diese Syntaxfehler können vielerorts und sehr
einfach auftreten. Probleme entstehen etwa bei:
\begin{itemize}
\item Rechtschreibfehlern in Kommando, Subkommando, Flaggen oder übergebenen Dateien
\item Durch das Weglassen benötigter Argumente bei Flaggen oder (Sub-) Kommandos
\item Missachtung der Reihenfolge (von Argumenten oder Subkommandos, Flagge in Beziehung zu Subkommando oder Argument)
\item Missachtung der Shell Regeln (etwa durch Weglassen von Anführungszeichen bei Argument mit Leerzeichen)
\end{itemize}
Vor allem, wenn das Wissen um die impliziten Regeln der Shell fehlen, können
schnell komplizierte Fehler auftreten. Je nach Qualität der Fehlermeldung und
Erfahrung reißen die Syntaxfehler den Nutzer mehr oder weniger aus dem Flow.
\begin{code}
\begin{shellcode}
$ git comit -m "Add commit"
git: 'comit' is not a git command. See 'git --help'.
The most similar command is
commit
\end{shellcode}
\captionof{listing}{Fehlerhafter Subkommando Name bei \codeinline{git}. Mit hilfreicher Fehlermeldung.}
\medskip
\end{code}
\bigskip
Semantische Probleme können auch auftreten. Meist sind diese Folge eines
Logikfehlers oder dem Durcheinanderbringen der Reihenfolge.
\begin{code}
\begin{shellcode}
$ git add remote origin [email protected]:jneidel/oraclett.git
\end{shellcode}
\captionof{listing}{Ein syntaktisch valider \codeinline{git} Befehl, der aber nicht tut, was gemeint war.}
\label{lst:add-remote}
\medskip
\end{code}
Der Semantische Fehler im obigen Listing \ref{lst:add-remote} liegt im
durcheinanderbringen der \codeinline{add} und \codeinline{remote} Subkommandos.
\codeinline{git remote} ist zum Verwalten von `tracked repositories'.
\codeinline{git add} markiert eine Datei für den nächsten `commit'. Je nach
Kontext haben \codeinline{add} und \codeinline{remote} eine andere Bedeutung.
\codeinline{git remote add} fügt eine neue `repository' hinzu während
\codeinline{git add remote} aber eine Datei mit dem Namen \codeinline{./remote}
für den nächsten `commit' markiert.
Durch eine kleine Veränderung der Reihenfolge entsteht eine völlig andere
Bedeutung.
\section{Adressierung der Probleme durch Weiterentwicklungen}
\label{sec:weiterentwicklungen}
Die Lösungen zu den Problemen der Kommandozeile wurden vielfach in der Schöpfung
neuer Interface Typen gesucht, ob innerhalb des Terminals oder außerhalb der
Text-basierten Welt.
\subsection{Innerhalb des Terminals}
Obwohl diese Evolutionen in der Kommandozeilenumgebung blieben, brachen sie
trotzdem mit der klassischen CLI Tradition. Die Unterscheidungen zwischen
CLI und dem menu-basierten bzw. interaktivem Interface sind dabei trotzdem
nicht glasklar, sondern eher verschwommen \parencite{Paap_1988}. Auch weil
Aspekte des CLI (wie Hilfsseiten/man pages, Flaggen, etc.) weiterhin Teil dieser
Applikationen sind. Auch weil sich die verschiedenen Interfaces ergänzen und
zusammen besser seinen können als in ihrer Reinform.
\textcite{bland2007design} beispielsweise implementieren neben dem reinen
nicht-interaktiven CLI Workflow noch einen menü-basierten Modus in welchem der
Nutzer mit ``menus similar to those of the GUI'' durch den Prozess geführt wird.
\subsubsection{Menü-basiertes Interface}
\label{sec:def-menu}
Das Menü oder auch `Text-based user interface' (TUI) ähnelt dem GUI insofern,
als dass dem Nutzer die Optionen visuell präsentiert werden. Anders als beim GUI
werden dafür aber nur Textelemente verwendet. Mausinteraktion wird von modernen
TUI's aber unterstützt. Da zur Implementation historisch oft die `curses'
Bibliothek verwendet wurde, ist es auch als `curses' Interface bekannt.
\medskip
\begin{figure}[H]
\centering
\includegraphics[scale=.47]{menu-example.png}
\caption{Beispiel eines TUI: Emails im Terminal mit \codeinline{neomutt}.}
\label{fig:menu-example}
\end{figure}
Laut \textcite{Paap_1988} wandelt das Menü das Problem des
\hyperref[prob:cr]{`Command Recall'} in `Command
Recognition', ein Wiedererkennen, um. Auch werden die Anfälligkeit für
\hyperref[prob:ss]{Syntaxfehler} reduziert, weil der Nutzer vor
illegalen Optionen abgeschirmt wird \parencite{Kantorowitz_1989}.
Im einem vergleichenden Experiment mit der Kommandozeile stellte
\textcite{Westerman_1997} für manche Nutzergruppen unsignifikant bessere Performance
fest. Auch wurde bei freier Wahl das Menü über alle Nutzergruppen hinweg doppelt
so häufig zur Nutzung ausgewählt.
Verglichen mit dem GUI sind TUI's trotzdem für Anfänger trotzdem schlechter
(in Performance und Meinung). Bei Experten liegen beide gleichauf
\parencite{tuivsgui}.
\subsubsection{Interaktive CLI}
\label{sec:def-interactive}
\begin{figure}[H]
\centering
\includegraphics[scale=0.5]{interactive-example.png}
\caption{Ein Interaktives CLI leitet durch eine Pizza Bestellung.}
\label{fig:interactive-example}
\end{figure}
Das Interaktive CLI basiert auf einem ``question and answer model''
\parencite[42]{Spolsky_2001}. Dem Nutzer werden kontinuierlich Fragen gestellt
auf dieser er antwortet (siehe Abbildung \ref{fig:interactive-example}.) Durch
die hilfreichen Fragen entfällt der Bedarf sich an Kommandos erinnern zu müssen
(vgl. \hyperref[prob:cr]{`Command Recall'}.)
Je nach Bedarf kann der Nutzer nach einfachem Text-Input oder Zahlen
gefragt werden. Auch komplexeres, wie das Auswählen aus einer
Liste oder `multiple-choice` Fragen sind möglich (vgl. Abbildung
\ref{fig:interactive-example2}.)
\begin{figure}[H]
\centering
\includegraphics[scale=0.5]{interactive-example2.png}
\caption{Der Belag einer Pizza wird interaktiv zusammengestellt.}
\label{fig:interactive-example2}
\end{figure}
\subsection{Außerhalb des Terminals}
\label{sec:weiterentwicklung-ausser}
Historisch wurde die grafische Benutzeroberfläche als Lösung für die Probleme
des CLI gesehen (vgl. Kap. \ref{sec:historic-context}.) So wurden dem Nutzer die
möglichen Optionen grafisch präsentiert, anstatt diese nachschauen zu müssen.
(vgl. \hyperref[prob:cr]{`Command Recall'}.)
Es vollzog sich damit ein Wechsel von der funktionsorientierten
Kommandozeile hin zum objektorientierten GUI \parencite{nielson1993}. Die
Funktionsorientiertheit drückt sich etwa durch die in `single-command' CLI Apps
häufig vertretene Verb-Nomen Struktur aus. Beispielsweise in \codeinline{rm
FILE} oder \codeinline{cat FILE}. In der objektorientierten Welt gehen alle
Aktionen vom Objekt aus. So wird eine Datei in den Papierkorb gezogen (vgl.
\codeinline{rm FILE}) oder per Doppelklick angezeigt (vgl. \codeinline{cat
FILE}). Semantische Probleme (wie mit \codeinline{mv} die Reihenfolge
durcheinander zu bringen) sind damit passé. Und von der Textform befreit, sind
es auch die in der Kommandozeile prävalenten \hyperref[prob:ss]{Syntaxfehler}.
Aber auch das grafische User Interface hat seine Schwächen. Und diese werden vor
allem `at scale' sichtbar. Die Massen des Internets lassen sich nicht grafisch
darstellen und auch ein volles Email Postfach ist mit nur grafischen Werkzeugen
wenig durchsichtig. \textcite{Norman_2007} beschreibt wie Suchmaschinen hier einen
Ausweg bieten. Und nennt sie `answer engine'. Eine flexiblere, robustere und
getarnte Kommandozeile die mit Rechtschreibfehlern und Synonymen umgehen kann.
\chapter{Entwicklung von Methoden}
\label{sec:methods}
\section{Methodologie}
Nach Betrachtung der \hyperref[sec:cli-problems]{Probleme} sollten in
Literaturrecherche Lösungsansätze erarbeitet werden, welche zusammen mit einer
Erklärung als Methoden formuliert wurden.
Auf der Abstraktionsskala von Softwarekonzepten befindet sich die Methode in der
Mitte zwischen abstrakt und konkret.
\begin{code}
\begin{shellcode}
abstrakt <-----------------------> konkret
Prinzip <---> Methode <---> Werkzeug
\end{shellcode}
\captionof{listing}{Abstraktionsskala von Softwarekonzepten.}
\medskip
\end{code}
Das abstrakte und allgemeine Prinzip \parencite{Balzert_2009} wäre zu
philosophischer Natur gewesen um im nächsten Schritt angewandt zu werden.
Werkzeuge nach \textcite{Balzert_2009} sind zu konkret und real. Es nicht Ziel
für jeden Lösungsansatz ein direkt anwendbares Werkzeug zu kreieren.
Eine Methode nach \textcite{Balzert_2009} ist eine begründete Vorgehensweise zur
Erreichung festgelegter Ziele. Sie ist nicht deskriptiv wie ein Werkzeug, und
nicht philosophisch wie ein Prinzip, sondern gibt eine Handlungsanweisung die
dem Entwickler Spielraum in der Implementierung lässt.
Die zu formulierenden Methoden sollten sich daher: auf Probleme die durch sie
gelöst/gemindert werden beziehen. Und begründet darstellen, warum dieser Effekt
eintreten wird.
Nachfolgend nun die erarbeiteten Methoden.
\newcounter{meth}
\newcommand{\methbox}[2]{
\medskip
\medskip
\fbox{\parbox{\linewidth}{
\refstepcounter{meth}
\textbf{Methode~\themeth}: #2
\label{meth:#1}
}}
\medskip
}
\newcommand{\methref}[1]{
Methode~\ref{meth:#1}
}
\section{Flaggen anstatt Argumenten}
Sobald ein (Sub-) Kommando mehr als ein Argument annimmt, bietet sich die
Gelegenheit, die für Argumente relevante Reihenfolge durcheinander zu bringen
(vgl. \refss{Syntax/Semantik}.) \textcite{12factor} empfiehlt deshalb bei
zwei oder mehr Argumenten anstatt dieser Flaggen zu verwenden. Das ist etwas
mehr Aufwand zum Schreiben, eliminiert aber die Reihenfolge als Fehlerfaktor.
Außerdem können Flaggen auch mittels Autovervollständigung vorgeschlagen werden
(vgl.~\methref{autocomplete}).
\methbox{flags_over_arguments}{Verwende Flaggen, wenn mehr als ein Argument benötigt wird.}
Dies trifft vor allem zu wenn ein (Sub-) Kommando gleichzeitig Parameter über
Flaggen und Argumente entgegennimmt.
\begin{code}
\begin{shellcode}
# Argument und Flaggen Kombination
$ oraclett project add INTPD999DXD --taskDetail "01 - Career development"
# Nur Flaggen
$ oraclett project add --project INTPD999DXD --taskDetail "01 - Career development"
\end{shellcode}
\captionof{listing}{Argument ersetzt durch Flaggen: vorher und nachher}
\medskip
\end{code}
Außen vor sind Kommandos welche eine variable Anzahl von Argumenten annehmen.
Beispielsweise \codeinline{rm} dem mehrere Dateien zum Löschen übergeben
werden können. Hier handelt es sich aber nicht um Argumente mit verschiedenen
Bedeutungen (\textcite{12factor}.)
Ein weiter Vorteil ist das Erstellen von Aliasen zu vereinfachen. Das sind
Abkürzungen, die ein Nutzer sich innerhalb seiner Shell definieren kann. Etwa um
ein Kommando abzukürzen: \codeinline{alias v="nvim"} macht \codeinline{nvim} mit
dem Kommando \codeinline{v} nutzbar.
Man stelle sich vor eine CLI App nimmt ein eine Anzahl von Stunden und ein Datum:
\begin{code}
\begin{shellcode}
$ app HOURS DATE
\end{shellcode}
\end{code}
Der Nutzer möchte einen Alias mit dem für den heutigen Tag eine Anzahl von Stunden übergeben wird.
Gewünschte Nutzung des Alias sieht so aus:
\begin{code}
\begin{shellcode}
$ apptoday 8
\end{shellcode}
\end{code}
Um diesen Alias zu ermögliche muss aber eine kompliziertere\footnote{Neulinge
kommen mit der Alias Syntax meist früher in Kontakt. Neben unvertrauter Syntax
spielt mit hinein das Shell Argumente (\codeinlinefn{$1}) verwendet werden müssen und das die
Möglichkeit entfällt dynamisch weitere Flaggen zu übergeben.} Shell Funktion
definiert werden, weil das Argument an die richtige Stelle übergeben werden
muss:
\begin{code}
\begin{shellcode}
apptoday() {
app $1 today
}
\end{shellcode}
\end{code}
Würde \codeinline{app} anstatt der Argumente Flaggen annehmen:
\begin{code}
\begin{shellcode}
$ app --hour HOURS --date DATE
\end{shellcode}
\end{code}
Dann wäre der Alias viel leichter und flexibler zu definieren:
\begin{code}
\begin{shellcode}
$ alias apptoday="app --date today --hour"
\end{shellcode}
\end{code}
Wenn die Stunde anstatt des Tages durch den Alias festgeschrieben werden soll,
ist das mit der Flaggen-basierten Struktur auch kein Problem. Der Nutzer ist
unabhängig von der durch den Entwickler definierten Reihenfolge.
\section{Unterstützung aller Hilfs- und Versionsflaggen}
Der Großteil aller Apps bietet eine Hilfs- und eine Versionsseite. Hilfsseiten
beschreiben ähnlich wie eine `man page'\footnote{Einer über das \codeinlinefn{man}
Kommando verfügbaren Hilfsseite.} die Subkommandos, Flaggen und Syntax. Meist
sind diese auch relativ und beziehen sich auf das aktuelle Subkommando.
Versionsseiten geben die Version der App\footnote{Sowie ggf. eine Liste von
optionalen Features die mit einkompiliert wurden.} wieder.
\begin{code}
\begin{shellcode}
$ mullvad status --help
mullvad-status
View the state of the VPN tunnel
USAGE:
mullvad status [OPTIONS] [SUBCOMMAND]
OPTIONS:
--debug Enables debug output
-h, --help Print help information
-l, --location Prints the current location and IP. Based on GeoIP lookups
-v Enables verbose output
SUBCOMMANDS:
listen Listen for VPN tunnel state changes
\end{shellcode}
\captionof{listing}{Als Beispiel: Die gekürzte, relative Hilfsseite von \codeinline{mullvad status}.}
\medskip
\end{code}
Beim Aufrufen dieser Seiten haben Nutzer ihre Präferenzen wenn es darum geht
welche Flagge sie verwenden um diese angezeigt zu bekommen.
\begin{code}
\begin{shellcode}
$ app -h
$ app --help
$ app help
$ app -v
$ app -V
$ app --version
$ app -version
$ app version
\end{shellcode}
\captionof{listing}{Gängige Varianten der Hilfs- und Versionsflaggen.}
\medskip
\end{code}
Laut \textcite{12factor} sollten möglichst alle Varianten in von einer Anwendung
unterstützt werden. So kann vermieden werden, dass der Nutzer nicht das
angezeigt bekommt, wonach er sucht. Das Problem des \refcrr wird vermieden, weil
der Nutzer durch Probieren seiner präferierten Variante direkt zur Lösung kommt.
\methbox{support_all_help_version}{Unterstütze alle gängigen Formen der Hilfs- und Versionsflaggen.}
\newcommand\checkmark{\ttfamily{\char"2611}}
\newcommand\cross{\ttfamily{\char"2610}}
\begin{table}[h!]
\begin{center}
\label{tab:help_version}
\begin{tabular}{l | c c c | c c c c c}
Kommando & \codeinline{-h} & \codeinline{--help} & \codeinline{help} & \codeinline{-v} & \codeinline{-V} & \codeinline{--version} & \codeinline{-version} & \codeinline{version} \\
\hline
git & \checkmark & \checkmark & \checkmark & \checkmark & \cross & \checkmark & \cross & \checkmark\\
node & \checkmark & \checkmark & \cross & \checkmark & \cross & \checkmark & \cross & \cross\\
mullvad & \checkmark & \checkmark & \cross & \cross & \cross & \cross & \cross & \checkmark\\
grep & \cross & \checkmark & \cross & \cross & \checkmark & \checkmark & \cross & \cross\\
zathura & \checkmark & \checkmark & \cross & \checkmark & \cross & \checkmark & \cross & \cross\\
tsp & \checkmark & \cross & \cross & \cross & \checkmark & \cross & \cross & \cross\\
pubs & \checkmark & \checkmark & \cross & \checkmark & \cross & \checkmark & \cross & \cross\\
ffmpeg & \checkmark & \checkmark & \cross & \cross & \cross & \cross & \checkmark & \cross\\
systemctl & \checkmark & \checkmark & \cross & \cross & \cross & \checkmark & \cross & \cross\\
pacman & \checkmark & \checkmark & \cross & \cross & \checkmark & \checkmark & \cross & \cross\\
make & \checkmark & \checkmark & \cross & \checkmark & \cross & \checkmark & \checkmark & \cross\\
synctex & \checkmark & \checkmark & \checkmark & \checkmark & \checkmark & \checkmark & \checkmark & \checkmark\\
curl & \checkmark & \checkmark & \cross & \cross & \checkmark & \checkmark & \cross & \cross\\
ansible & \checkmark & \checkmark & \checkmark & \cross & \cross & \checkmark & \cross & \cross\\
nvim & \checkmark & \checkmark & \cross & \checkmark & \cross & \checkmark & \checkmark & \cross\\
\hline
Summe & 14 & 14 & 3 & 7 & 5 & 12 & 4 & 3 \\
\end{tabular}
\caption{Unterstützte Varianten von Hilfs- und Versionsflaggen bei einer Stichprobe von 15 Kommandos.}
\end{center}
\end{table}
In einer unrepresentativen Stichprobe (siehe Tabelle) wurde zusammengestellt,
welche Flaggen in 15 Anwendungen funktionieren bzw. nicht funktionieren. Dabei
stellte sich heraus, dass \codeinline{-h} und \codeinline{--help} praktisch
überall funktionieren. Mit \codeinline{--version} wird in den meisten Fällen
auch das gewünschte Ergebnis angezeigt. Aber wenn \codeinline{--version} nicht
zum Ziel führt ist durchprobieren angesagt.
Am wenigsten verbreitet sind \codeinline{help} und \codeinline{version},
welche aber auch etwas außen vor sind, weil das erste Argument bei vielen
`single-command' Kommandos eine `Input' Datei bezeichnet. Aber bei
`multi-command' Apps sollten auch diese Varianten unterstützt werden.
\section{Relevante Standardwerte}
Relevante `Defaults' sind nicht Kommandozeilen-spezifisch, können dort aber
wichtiger sein als in grafischen Anwendungen.
Dem Nutzer werden die Möglichkeiten eben nicht zur Auswahl gestellt und dieser
klickt die gewünschte Option an. Sondern ist das Auflisten der Möglichkeiten
i.d.R. ein separater Schritt, losgelöst von der eigentlich beabsichtigten
Aktion. Beispielsweise muss um sich mit \codeinline{cd} in einen Ordner
hineinzubewegen der Name dessen zuerst in Erfahrung gebracht werden (etwa mit
\codeinline{ls -d}.)
Es greift wieder das fundamentale Problem des \refcrr. Den Schritt des
Auflistens der Möglichkeiten (ähnlich wie das Auflisten von möglichen Kommandos)
ist ein extra Schritt der nur nötig ist weil der Nutzer sich nicht an die Option
erinnern kann die er verwenden möchte.
\bigskip
\methbox{relevant_defaults}{Biete relevante Standardwerte an.}
Dem Nutzer relevante Defaults anzubieten erlaubt es diesem weniger Argumente an
die CLI App übergeben zu müssen. Es gibt weniger Fehlermeldungen die den Nutzer
zurückweisen, weil dieser etwas vergessen hat.
Es ist aber auch elementar die Nutzung dieser Standardwerte zu kommunizieren.
Damit der Nutzer von ihnen nicht überrascht wird.
\section{Interaktives Nachfragen bei fehlendem Parameter}
Man stelle sich folgendes Szenario vor. Eine CLI App hat ein Subkommando welches
einen Parameter erfordert. Normalerweise erfolgt bei nicht-Übergabe dieses
Parameters eine Fehlermeldung welche darauf hinweist.
\begin{code}
\begin{shellcode}
$ mullvad relay set location
error: The following required arguments were not provided:
<country>
USAGE:
mullvad relay set location <country> [ARGS]
For more information try --help
\end{shellcode}
\captionof{listing}{Fehlermeldung bei fehlendem Parameter in \codeinline{mullvad}'s CLI.}
\label{lst:missing-param}
\medskip
\end{code}
Die Anwendung weiß aber bereits was der Nutzer tun möchte und könnte anstatt
der Fehlermeldung dem Nutzer mit einer Eingabeaufforderung (interaktivem
Nachfragen, vgl. Kapitel \ref{sec:def-interactive}) nach dem fehlenden
Parameter fragen \parencite{12factor}. Oder, je nach Kontext, diesem sogar
eine Liste von Vorschlägen geben, um daraus auswählen. Dem Nutzer wird erspart
sich damit auseinander zu setzen welche Parameter erfordert sind (vgl.
\hyperref[prob:cr]{`Command Recall'})
\methbox{interactive_missing_param}{Frage bei fehlendem Parameter interaktiv nach.}
\begin{code}
\begin{shellcode}
$ mullvad relay set location
Enter location country code:
\end{shellcode}
\captionof{listing}{Beispiel der Eingabeaufforderung zur Verbesserung von Listing \ref{lst:missing-param}.}
\medskip
\end{code}
Fairerweise ist zu bemerken das die mullvad CLI App dies auch, an anderer Stelle,
genau so handhabt. Bei \codeinline{mullvad account login} wird nach der
fehlenden Accountnummer gefragt.
Mit einer Fehlermeldung anstatt des interaktivem Nachfragens könnte der
Nutzer leichter auf die ggf. komplexere Verwendung des Kommandos hingewiesen
werden. So nimmt das mullvad Kommando aus dem ersten Beispiel neben der
Landeskennung auch noch optional die ein Stadt- und `Hostkennung'. Was aber
aus der Fehlermeldung auch nicht klar hervorgeht. Wenn unter Berücksichtigung
dieser Methode implementiert wird kann dieser Einwand aber auch mitigiert
werden. Entweder durch das Vereinfachen oder Umgestalten der Kommandos. Oder mit
Hinweisen auf die Hilfsseite, welche die Parameter vollumfänglich erklärt.
\section{Natürliche Sprache}
\label{sec:natural-lang}
\textcite{Raskin_2008} beschreibt die Kapazitäten linguistischer
Kommandozeilen, welche Normans Konzept der `answer engines' (vgl. Kapitel
\ref{sec:weiterentwicklung-ausser}) ähneln. Diese haben wie der Name schon
hergibt einen Fokus auf menschlicher Sprache\footnote{Die Linguistik ist das
Studium der menschlichen Sprache.}. Ein schönes, genanntes Beispiel von Google
Calendar für die Stärke solcher, auf natürlicher Sprache basierender Interfaces:
``Sunday dinner at 7:30 p.m. with Asa Jasa.'' Es werden keine Kommandos
verwendet. Das gewünschte wird einfach in natürlicher Sprache beschrieben.
Syntax ist nur insofern relevant, als das die menschliche Sprache ihre eigene
Syntax hat.
``Recently, there has been a growing movement that sees today's command line
as a human-first text-based UI, rather than a machine-first scripting platform
\parencite{clig}'' - \parencite{Schr_der_2021}
Die Syntax- und Semantikeinschränkungen des Kommandozeilen-Interfaces lassen
eine alleinig `human language'-gestützte Anwendung nicht zu. Zumindest nicht
der Reinform des CLI. Als `human-first` User Interface sollte trotzdem
zumindest eine eingschränkte Form natürlicher Spracheingabe unterstützt werden
\parencite{seneviratne2008new}.
\methbox{human_language}{Unterstütze Eingaben in natürlicher Sprache.}
\section{Fehlerkorrektur}
Diese Methode zeigt eine gewisse Nähe zur Unterstützung der natürlichen
Sprache (Kapitel \ref{sec:natural-lang}). So hob \textcite{Raskin_2008} für die
linguistische Kommandozeile die Verträglichkeit von Rechtschreibfehlern hervor.
Fehlertoleranz im Bezug auf Rechtschreibung würde auch das Problem der zu
\refss{strikten Syntax} zum Teil adressieren. Fehlermeldungen und die damit
einhergehende Frustration minimieren. \textcite{clig} empfehlen ganz konkret: ``If
the user did something wrong and you can guess what they meant, suggest it.''
Im Kontrast dazu soll nach der `Do what I mean' Philosophie der Fehler direkt
und ohne Nutzerfeedback ausgebessert werden \parencite{DWIM}. Was natürlich
schneller ist und den Nutzungsflow nicht unnötig unterbricht. \textcite{clig} weisen
aber auch darauf hin das eine fehlerhafte Eingabe neben Rechtschreibfehlern eben
auch aus logischen Fehler resultieren kann. Dann kann `Do what I mean' zu sehr
unerwartetem, gefährlichem Verhalten führen.
\methbox{typos}{Unterstütze (suggestive) Fehlerkorrektur.}
\begin{code}
\begin{shellcode}
heroku pss
› Warning: pss is not a heroku command.
Did you mean ps? [Y/n]:
\end{shellcode}
\captionof{listing}{Korrekturvorschlag eines Rechtschreibfehlers nach \textcite{clig}.}
\medskip
\end{code}
\section{Autovervollständigung}
`Auto-completion' in der Kommandozeile beschreibt das beim Drücken der `TAB' Taste
etwas ergänzt/vervollständigt wird.
In der Shell funktioniert dies etwa für Kommandos und Dateipfade:
\begin{code}
\begin{shellcode}
$ wg # Nutzer drückt TAB
$ wget
$ cat ./note # Nutzer drückt TAB
$ cat ./notes.md
\end{shellcode}
\captionof{listing}{Autovervollständigung in der Shell.}
\medskip
\end{code}
Innerhalb einer CLI App kann die Vervollständigung, neben Dateipfaden, auch