diff --git a/script/egal.txt b/script/egal.txt
new file mode 100644
index 0000000000000000000000000000000000000000..70fbe4a435e96acc7b3db8eefb8018eda4ab0e4d
--- /dev/null
+++ b/script/egal.txt
@@ -0,0 +1,37 @@
+GNU/Linux
+~~~~~~~~~
+Compilieren:  gcc -Wall -O cube-5.c opengl-magic.c \
+              -lGL -lGLU -lglut -o cube-5
+Aufrufen:     ./cube-5
+
+MacOS
+~~~~~
+Compilieren:  gcc -Wall -O cube-5.c opengl-magic.c \
+              -framework OpenGL -framework GLUT -o cube-5
+Aufrufen:     ./cube-5
+
+Cygwin mit X11
+~~~~~~~~~~~~~~
+Compilieren:  gcc -Wall -O cube-5.c opengl-magic.c \
+              -lGL -lGLU -lglut -o cube-5
+Aufrufen:     DISPLAY=:0.0 ./cube-5
+oder:
+  einmalig:   export DISPLAY=:0.0
+  danach:     ./cube-5
+
+Vorher einmalig: X-Server starten
+              XWin -multiwindow &
+
+Cygwin ohne X11
+~~~~~~~~~~~~~~~
+Compilieren:  i686-pc-mingw32-gcc -I freeglut/include -L freeglut/lib \
+              -Wall -O cube-5.c opengl-magic.c \
+              -lOpenGL32 -lGLU32 -lfreeglut -o cube-5
+Aufrufen:     ./cube-5
+
+MinGW ohne X11
+~~~~~~~~~~~~~~
+Compilieren:  gcc -I freeglut/include -L freeglut/lib \
+              -Wall -O cube-5.c opengl-magic.c \
+              -lOpenGL32 -lGLU32 -lfreeglut -o cube-5
+Aufrufen:     ./cube-5
diff --git a/script/fifo-8.c b/script/fifo-8.c
new file mode 100644
index 0000000000000000000000000000000000000000..5ee60f2325c170808389365a522d6e6cab0f1f45
--- /dev/null
+++ b/script/fifo-8.c
@@ -0,0 +1,49 @@
+#include <stdio.h>
+
+#define FIFO_SIZE 10
+
+int fifo[FIFO_SIZE];
+int fifo_read = 0;
+int fifo_write = 0;
+
+void push (int x)
+{
+  if ((fifo_write + 1) % FIFO_SIZE == fifo_read)
+    fprintf (stderr, "push(): FIFO is full\n");
+  else
+    {
+      fifo[fifo_write++] = x;
+      if (fifo_write >= FIFO_SIZE)
+        fifo_write = 0;
+    }
+}
+
+int pop (void)
+{
+  if (fifo_read == fifo_write)
+    {
+      fprintf (stderr, "pop(): FIFO is empty\n");
+      return -1;
+    }
+  else
+    {
+      int result = fifo[fifo_read++];
+      if (fifo_read >= FIFO_SIZE)
+        fifo_read = 0;
+      return result;
+    }
+}
+
+int main (void)
+{
+  push (3);
+  push (7);
+  push (137);
+  printf ("%d\n", pop ());
+  printf ("%d\n", pop ());
+  printf ("%d\n", pop ());
+  printf ("%d\n", pop ());
+  for (int i = 0; i < 15; i++)
+    push (i);
+  return 0;
+}
diff --git a/script/gtk-1.c b/script/gtk-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..884a14ea528431e54f8391c801958a6e494dfe43
--- /dev/null
+++ b/script/gtk-1.c
@@ -0,0 +1,11 @@
+#include <gtk/gtk.h>
+
+int main (int argc, char **argv)
+{
+  gtk_init (&argc, &argv);
+  GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_title (GTK_WINDOW (window), "Hello");
+  gtk_widget_show (window);
+  gtk_main ();
+  return 0;
+}
diff --git a/script/gtk-2.c b/script/gtk-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..c5db19f8d7e859ff12b08ffd6425b84deab35d07
--- /dev/null
+++ b/script/gtk-2.c
@@ -0,0 +1,12 @@
+#include <gtk/gtk.h>
+
+int main (int argc, char **argv)
+{
+  gtk_init (&argc, &argv);
+  GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_title (GTK_WINDOW (window), "Hello");
+  g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
+  gtk_widget_show (window);
+  gtk_main ();
+  return 0;
+}
diff --git a/script/gtk-3.c b/script/gtk-3.c
new file mode 100644
index 0000000000000000000000000000000000000000..26fcdd9bf83023b4f3e704a93218134149829f83
--- /dev/null
+++ b/script/gtk-3.c
@@ -0,0 +1,16 @@
+#include <gtk/gtk.h>
+
+int main (int argc, char **argv)
+{
+  gtk_init (&argc, &argv);
+  GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_title (GTK_WINDOW (window), "Hello");
+  g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
+  GtkWidget *button = gtk_button_new_with_label ("Quit");
+  g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL);
+  gtk_container_add (GTK_CONTAINER (window), button);
+  gtk_widget_show (button);
+  gtk_widget_show (window);
+  gtk_main ();
+  return 0;
+}
diff --git a/script/gtk-4.c b/script/gtk-4.c
new file mode 100644
index 0000000000000000000000000000000000000000..3e15b640a0f1503294f93bb69fa0b457d60288e4
--- /dev/null
+++ b/script/gtk-4.c
@@ -0,0 +1,25 @@
+#include <gtk/gtk.h>
+
+int main (int argc, char **argv)
+{
+  gtk_init (&argc, &argv);
+  GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_title (GTK_WINDOW (window), "Hello");
+  g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
+
+  GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
+  gtk_container_add (GTK_CONTAINER (window), vbox);
+
+  GtkWidget *button = gtk_button_new_with_label ("Quit");
+  g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL);
+  gtk_container_add (GTK_CONTAINER (vbox), button);
+
+  GtkWidget *drawing_area = gtk_drawing_area_new ();
+  gtk_container_add (GTK_CONTAINER (vbox), drawing_area);
+
+  gtk_widget_show (button);
+  gtk_widget_show (vbox);
+  gtk_widget_show (window);
+  gtk_main ();
+  return 0;
+}
diff --git a/script/gtk-5.c b/script/gtk-5.c
new file mode 100644
index 0000000000000000000000000000000000000000..132dbcb61fb979372da88225e8cb881d2b81a2d4
--- /dev/null
+++ b/script/gtk-5.c
@@ -0,0 +1,26 @@
+#include <gtk/gtk.h>
+
+int main (int argc, char **argv)
+{
+  gtk_init (&argc, &argv);
+  GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_title (GTK_WINDOW (window), "Hello");
+  g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
+
+  GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
+  gtk_container_add (GTK_CONTAINER (window), vbox);
+
+  GtkWidget *button = gtk_button_new_with_label ("Quit");
+  g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL);
+  gtk_container_add (GTK_CONTAINER (vbox), button);
+
+  GtkWidget *drawing_area = gtk_drawing_area_new ();
+  gtk_container_add (GTK_CONTAINER (vbox), drawing_area);
+
+  gtk_widget_show (drawing_area);
+  gtk_widget_show (button);
+  gtk_widget_show (vbox);
+  gtk_widget_show (window);
+  gtk_main ();
+  return 0;
+}
diff --git a/script/gtk-6.c b/script/gtk-6.c
new file mode 100644
index 0000000000000000000000000000000000000000..81e12e6958d3c0adbed8d315927104482bc4c681
--- /dev/null
+++ b/script/gtk-6.c
@@ -0,0 +1,53 @@
+#include <gtk/gtk.h>
+
+gboolean draw (GtkWidget *widget, cairo_t *c, gpointer data)
+{
+  GdkRGBA red = { 1.0, 0.0, 0.0, 0.8 };
+  GdkRGBA yellow = { 1.0, 1.0, 0.0, 0.6 };
+  GdkRGBA blue = { 0.0, 0.5, 1.0, 0.4 };
+
+  gdk_cairo_set_source_rgba (c, &red);
+  cairo_rectangle (c, 10, 10, 60, 40);
+  cairo_fill (c);
+
+  gdk_cairo_set_source_rgba (c, &yellow);
+  cairo_arc (c, 65, 50, 30, 0, 2 * G_PI);
+  cairo_fill (c);
+
+  gdk_cairo_set_source_rgba (c, &blue);
+  cairo_move_to (c, 10, 70);
+  cairo_line_to (c, 70, 70);
+  cairo_line_to (c, 40, 18);
+  cairo_close_path (c);
+  cairo_fill (c);
+
+  return FALSE;  /* TRUE to stop other handlers from being invoked for the event.
+                    FALSE to propagate the event further. */
+}
+
+int main (int argc, char **argv)
+{
+  gtk_init (&argc, &argv);
+  GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_title (GTK_WINDOW (window), "Hello");
+  g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
+
+  GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
+  gtk_container_add (GTK_CONTAINER (window), vbox);
+
+  GtkWidget *button = gtk_button_new_with_label ("Quit");
+  g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL);
+  gtk_container_add (GTK_CONTAINER (vbox), button);
+
+  GtkWidget *drawing_area = gtk_drawing_area_new ();
+  gtk_container_add (GTK_CONTAINER (vbox), drawing_area);
+  g_signal_connect (drawing_area, "draw", G_CALLBACK (draw), NULL);
+  gtk_widget_set_size_request (drawing_area, 100, 100);
+
+  gtk_widget_show (drawing_area);
+  gtk_widget_show (button);
+  gtk_widget_show (vbox);
+  gtk_widget_show (window);
+  gtk_main ();
+  return 0;
+}
diff --git a/script/gtk-7.c b/script/gtk-7.c
new file mode 100644
index 0000000000000000000000000000000000000000..11041fbe1d27585ca4edb951f195f114ddad126e
--- /dev/null
+++ b/script/gtk-7.c
@@ -0,0 +1,71 @@
+#include <stdio.h>
+#include <gtk/gtk.h>
+
+gboolean draw (GtkWidget *widget, cairo_t *c, gpointer data)
+{
+  GdkRGBA red = { 1.0, 0.0, 0.0, 0.8 };
+  GdkRGBA yellow = { 1.0, 1.0, 0.0, 0.6 };
+  GdkRGBA blue = { 0.0, 0.5, 1.0, 0.4 };
+
+  gdk_cairo_set_source_rgba (c, &red);
+  cairo_rectangle (c, 10, 10, 60, 40);
+  cairo_fill (c);
+
+  gdk_cairo_set_source_rgba (c, &yellow);
+  cairo_arc (c, 65, 50, 30, 0, 2 * G_PI);
+  cairo_fill (c);
+
+  gdk_cairo_set_source_rgba (c, &blue);
+  cairo_move_to (c, 10, 70);
+  cairo_line_to (c, 70, 70);
+  cairo_line_to (c, 40, 18);
+  cairo_close_path (c);
+  cairo_fill (c);
+
+  return FALSE;  /* TRUE to stop other handlers from being invoked for the event.
+                    FALSE to propagate the event further. */
+}
+
+gboolean button_press (GtkWidget *widget, GdkEventButton *e, gpointer data)
+{
+  printf ("button %d pressed at (%lf, %lf)\n", e->button, e->x, e->y);
+  return FALSE;
+}
+
+gboolean key_press (GtkWidget *widget, GdkEventKey *e, gpointer data)
+{
+  printf ("key '%c' (%d) pressed\n", e->keyval, e->keyval);
+  return FALSE;
+}
+
+int main (int argc, char **argv)
+{
+  gtk_init (&argc, &argv);
+  GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_title (GTK_WINDOW (window), "Hello");
+  g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
+
+  GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
+  gtk_container_add (GTK_CONTAINER (window), vbox);
+
+  GtkWidget *button = gtk_button_new_with_label ("Quit");
+  g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL);
+  gtk_container_add (GTK_CONTAINER (vbox), button);
+
+  GtkWidget *drawing_area = gtk_drawing_area_new ();
+  gtk_container_add (GTK_CONTAINER (vbox), drawing_area);
+  g_signal_connect (drawing_area, "draw", G_CALLBACK (draw), NULL);
+  gtk_widget_set_size_request (drawing_area, 100, 100);
+  gtk_widget_add_events (drawing_area, GDK_BUTTON_PRESS_MASK);
+  g_signal_connect (drawing_area, "button_press_event", G_CALLBACK (button_press), NULL);
+
+  gtk_widget_add_events (window, GDK_KEY_PRESS_MASK);
+  g_signal_connect (window, "key_press_event", G_CALLBACK (key_press), NULL);
+
+  gtk_widget_show (drawing_area);
+  gtk_widget_show (button);
+  gtk_widget_show (vbox);
+  gtk_widget_show (window);
+  gtk_main ();
+  return 0;
+}
diff --git a/script/hp-2020ws.pdf b/script/hp-2020ws.pdf
index 5cb5791ac2df663284a741c84b703d637c9494a0..9ffec9021c72492cdbc0119d27f88f428ac500e2 100644
Binary files a/script/hp-2020ws.pdf and b/script/hp-2020ws.pdf differ
diff --git a/script/hp-2020ws.tex b/script/hp-2020ws.tex
index a6f2868c37c02c4ec315a1dc06f74894062f0bf4..5adc27dadc1e263360ba7f3071e7186e01fc5807 100644
--- a/script/hp-2020ws.tex
+++ b/script/hp-2020ws.tex
@@ -264,7 +264,7 @@
 
   \subsection{Hello, world!}
 
-  Das folgende Beispiel-Programm (Datei: \gitfile{hp}{script}{hello-1.c})
+  Das folgende Beispiel-Programm (Datei: \gitfile{hp}{2020ws/script}{hello-1.c})
   gibt den Text "`Hello, world!"' auf dem Bildschirm aus:
   \begin{lstlisting}
     #include <stdio.h>
@@ -333,7 +333,7 @@
 
   Der Programmtext wird mit Hilfe eines Eingabeprogramms, des \newterm{Texteditors},
   in den Computer eingegeben und als Datei gespeichert.
-  Als Dateiname sei hier \gitfile{hp}{script}{hello-1.c} angenommen.
+  Als Dateiname sei hier \gitfile{hp}{2020ws/script}{hello-1.c} angenommen.
   Die Dateiendung \file{.c} soll anzeigen,
   daß es sich um einen Programmquelltext in der Programmiersprache C handelt.
 
@@ -413,7 +413,7 @@
         eine Benutzergruppe (hier: \lstinline[style=terminal]{ainf})
         und für alle anderen Benutzer des Computers.
         
-        Im o.\,a.\ Beispiel ist die Datei \gitfile{hp}{script}{hello-1.c}
+        Im o.\,a.\ Beispiel ist die Datei \gitfile{hp}{2020ws/script}{hello-1.c}
         für den Benutzer \lstinline[style=terminal]{peter} les- und schreibbar,
         für alle Angehörigen der Gruppe \lstinline[style=terminal]{ainf} nur lesbar
         und für alle anderen Benutzer des Computers ebenfalls nur lesbar.
@@ -453,7 +453,7 @@
   eine String-Konstante wie z.\,B.\ \lstinline{"Hello, world!\n"} "`einfach so"' auszugeben,
   liegt die Vermutung nahe, Integer-Konstanten auf gleiche Weise ausgeben zu können.
 
-  Datei \gitfile{hp}{script}{output-1.c}:
+  Datei \gitfile{hp}{2020ws/script}{output-1.c}:
   \begin{lstlisting}
     #include <stdio.h>
 
@@ -530,7 +530,7 @@
   \breath
 
   Wie man nun tatsächlich in C Zahlenwerte ausgibt,
-  illustriert das Beispielprogramm \gitfile{hp}{script}{output-2.c}:
+  illustriert das Beispielprogramm \gitfile{hp}{2020ws/script}{output-2.c}:
   \begin{lstlisting}
     #include <stdio.h>
 
@@ -582,7 +582,7 @@
       Auch mehrere \lstinline{\n} in derselben String-Konstanten sind zulässig.
     \item
       C akzeptiert auch sehr seltsame Konstrukte.
-      Das folgende Beispiel (Datei: \gitfile{hp}{script}{hello-2.c})
+      Das folgende Beispiel (Datei: \gitfile{hp}{2020ws/script}{hello-2.c})
       \begin{lstlisting}[gobble=8]
         #include <stdio.h>
 
@@ -611,7 +611,7 @@
 
   Wenn mehrere Werte ausgegeben werden sollen,
   verwendet man in \lstinline{printf()} mehrere Formatspezifikationen
-  und gibt mehrere Werte als Parameter an (Datei: \gitfile{hp}{script}{output-3.c}):
+  und gibt mehrere Werte als Parameter an (Datei: \gitfile{hp}{2020ws/script}{output-3.c}):
   \begin{lstlisting}
     #include <stdio.h>
 
@@ -629,7 +629,7 @@
   \end{lstlisting}
   Achtung: Zu viele oder zu wenige Werte in der Parameterliste
   ergeben trotzdem ein gültiges, wenn auch fehlerhaftes C-Programm
-  (Datei: \gitfile{hp}{script}{output-4.c}):
+  (Datei: \gitfile{hp}{2020ws/script}{output-4.c}):
   \begin{lstlisting}
     #include <stdio.h>
 
@@ -660,7 +660,7 @@
 
   Das Einlesen von Werten erfolgt in C mit der Funktion \lstinline{scanf()}.
 
-  Das folgende Beispielprogramm (Datei: \gitfile{hp}{script}{input-1.c})
+  Das folgende Beispielprogramm (Datei: \gitfile{hp}{2020ws/script}{input-1.c})
   liest einen Wert vom Standardeingabegerät (hier: Tastatur) ein
   und gibt ihn wieder aus:
   \begin{lstlisting}
@@ -683,7 +683,7 @@
   (Genaugenommen handelt es sich um die Übergabe einer Speicheradresse.
   Dies wird in Abschnitt \ref{Zeiger} genauer behandelt.)
 
-  Wenn wir das \lstinline{&} vergessen (Beispielprogramm: \gitfile{hp}{script}{input-2.c}),
+  Wenn wir das \lstinline{&} vergessen (Beispielprogramm: \gitfile{hp}{2020ws/script}{input-2.c}),
   kann das C-Programm weiterhin compiliert werden.
   Bei Verwendung der Option \lstinline[style=cmd]{-Wall} erhalten wir eine Warnung.
   Wenn wir das Programm ausführen und versuchen, einen Wert einzugeben, stürzt das Programm ab.
@@ -725,7 +725,7 @@
   dazu verwendet werden, zwei Integer-Ausdrücke, die sogenannten \newterm{Operanden},
   durch Addition zu einem neuen Integer-Ausdruck zu verknüpfen.
 
-  Beispiel: \gitfile{hp}{script}{mathe-1.c}
+  Beispiel: \gitfile{hp}{2020ws/script}{mathe-1.c}
   \begin{lstlisting}
     #include <stdio.h>
 
@@ -815,7 +815,7 @@
 
   \subsection{Verzweigungen}
 
-  Das Beispielprogramm \gitfile{hp}{script}{if-0.c}
+  Das Beispielprogramm \gitfile{hp}{2020ws/script}{if-0.c}
   \begin{lstlisting}
     #include <stdio.h>
 
@@ -850,7 +850,7 @@
   Diese sog.\ \newterm{Verzweigung\/} geschieht mittels einer \lstinline{if}-Anweisung.
 
   \goodbreak
-  Beispielprogramm: \gitfile{hp}{script}{if-1.c}
+  Beispielprogramm: \gitfile{hp}{2020ws/script}{if-1.c}
   \begin{lstlisting}
     #include <stdio.h>
 
@@ -883,7 +883,7 @@
   Die \lstinline{if}-Anweisung kennt einen optionalen \lstinline{else}-Zweig.
   Dieser wird dann ausgeführt, wenn die Bedingung \emph{nicht\/} erfüllt ist.
 
-  Beispielprogramm: \gitfile{hp}{script}{if-2.c}
+  Beispielprogramm: \gitfile{hp}{2020ws/script}{if-2.c}
   \begin{lstlisting}
     #include <stdio.h>
 
@@ -907,7 +907,7 @@
   Sowohl auf das \lstinline{if} als auch auf das \lstinline{else}
   folgt nur jeweils \emph{eine\/} Anweisung, die von der Bedingung abhängt.
 
-  In dem folgenden Beispielprogramm (Datei: \gitfile{hp}{script}{if-3.c})
+  In dem folgenden Beispielprogramm (Datei: \gitfile{hp}{2020ws/script}{if-3.c})
   \begin{lstlisting}
     #include <stdio.h>
 
@@ -943,7 +943,7 @@
   zu einem sog.\ \newterm{Anweisungsblock\/} zusammenfassen.
 
   \goodbreak
-  Beispielprogramm: \gitfile{hp}{script}{if-4.c}
+  Beispielprogramm: \gitfile{hp}{2020ws/script}{if-4.c}
   \begin{lstlisting}
     #include <stdio.h>
 
@@ -967,8 +967,8 @@
 
   Aus Sicht des Computers ist die Einrückung
   -- und überhaupt die Anordnung von Leerzeichen und Zeilenschaltungen -- belanglos.
-  Die folgende Schreibweise (Datei: \gitfile{hp}{script}{if-5.c}) ist für ihn
-  vollkommen gleichwertig zu \gitfile{hp}{script}{if-4.c}:
+  Die folgende Schreibweise (Datei: \gitfile{hp}{2020ws/script}{if-5.c}) ist für ihn
+  vollkommen gleichwertig zu \gitfile{hp}{2020ws/script}{if-4.c}:
   \begin{lstlisting}
     #include<stdio.h>
     int main(void){int a,b;printf("Bitte a eingeben: ");scanf("%d",&a);
@@ -1047,7 +1047,7 @@
   Daß es sich bei Wahrheitswerten in C tatsächlich um Integer-Werte handelt, wird auch deutlich,
   wenn man sich diese mittels \lstinline{printf()} ausgeben läßt.
 
-  Wenn man beispielsweise in dem folgenden Programm \gitfile{hp}{script}{if-6.c}
+  Wenn man beispielsweise in dem folgenden Programm \gitfile{hp}{2020ws/script}{if-6.c}
   den Wert \lstinline{7} für die Variable \lstinline{b} eingibt,
   \begin{lstlisting}
     #include <stdio.h>
@@ -1083,7 +1083,7 @@
   Mit Hilfe der \lstinline{while}-Anweisung ist es möglich,
   Anweisungen in Abhängigkeit von einer Bedingung mehrfach auszuführen.
 
-  Das folgende Beispielprogramm \gitfile{hp}{script}{loop-1.c}
+  Das folgende Beispielprogramm \gitfile{hp}{2020ws/script}{loop-1.c}
   schreibt die Zahlen von 1 bis einschließlich 10 auf den Bildschirm:
   \begin{lstlisting}
     #include <stdio.h>
@@ -1112,7 +1112,7 @@
   \breath
 
   Wenn man eine Bedingung angibt, die niemals 0 wird,
-  erzeugt man eine Endlosschleife (\gitfile{hp}{script}{while-2.c}):
+  erzeugt man eine Endlosschleife (\gitfile{hp}{2020ws/script}{while-2.c}):
   \begin{lstlisting}
     #include <stdio.h>
 
@@ -1236,7 +1236,7 @@
           printf ("%d\n", i);
       \end{lstlisting}
       \bigskip
-      \quad(Datei: \gitfile{hp}{script}{loop-2.c})
+      \quad(Datei: \gitfile{hp}{2020ws/script}{loop-2.c})
     \end{minipage}
   \end{center}
 
@@ -1276,7 +1276,7 @@
       printf ("%d\n", i);
   \end{lstlisting}
   \vspace{-\smallskipamount}
-  zwar zulässiges C, aber nicht sinnvoll (Datei: \gitfile{hp}{script}{loop-3.c}).
+  zwar zulässiges C, aber nicht sinnvoll (Datei: \gitfile{hp}{2020ws/script}{loop-3.c}).
   Dies kann man sofort erkennen, indem man die \lstinline{for}-Schleife
   in eine \lstinline{while}-Schleife übersetzt:
   \begin{lstlisting}
@@ -1298,7 +1298,7 @@
 
   Das Verwerfen berechneter Werte verdient eine nähere Betrachtung
   -- insbesondere in der Programmiersprache C.
-  Wie das Beispielprogramm \gitfile{hp}{script}{statements-1.c} illustriert,
+  Wie das Beispielprogramm \gitfile{hp}{2020ws/script}{statements-1.c} illustriert,
   \begin{lstlisting}
     #include <stdio.h>
 
@@ -1326,7 +1326,7 @@
   nämlich die Ausgabe des Textes auf dem Standardausgabegerät (Bildschirm).
   Diese weitere Bedeutung heißt \newterm{Seiteneffekt\/} des Ausdrucks.
 
-  Das Beispielprogramm \gitfile{hp}{script}{statements-2.c}
+  Das Beispielprogramm \gitfile{hp}{2020ws/script}{statements-2.c}
   gibt den vom ersten \lstinline{printf()} zurückgegebenen Wert
   mit Hilfe eines zweiten \lstinline{printf()} aus:
   \begin{lstlisting}
@@ -1534,7 +1534,7 @@
     \}
   \end{quote}
 
-  Beispielprogramm: \gitfile{hp}{script}{functions-1.c}
+  Beispielprogramm: \gitfile{hp}{2020ws/script}{functions-1.c}
   \begin{lstlisting}
     #include <stdio.h>
 
@@ -1579,7 +1579,7 @@
   sind sie von verschiedenen Stellen im Programm aus zugänglich
   und/oder verhalten sich unterschiedlich.
 
-  Beispielprogramm: \gitfile{hp}{script}{functions-2.c}
+  Beispielprogramm: \gitfile{hp}{2020ws/script}{functions-2.c}
   \begin{lstlisting}[style=numbered]
     #include <stdio.h>
 
@@ -1724,7 +1724,7 @@
   mit dem Wert "`Speicheradresse dieser Variablen"' zu erhalten.
 
   \goodbreak
-  Beispielprogramm: \gitfile{hp}{script}{pointers-1.c}
+  Beispielprogramm: \gitfile{hp}{2020ws/script}{pointers-1.c}
   \begin{lstlisting}
     #include <stdio.h>
 
@@ -1770,7 +1770,7 @@
   wenn mehrere Variable gleichen Typs gemeinsam angelegt werden.
   Eine derartige Ansammlung von Variablen gleichen Typs heißt \newterm{Array\/} (Feldvariable, Vektor).
 
-  Beispielprogramm: \gitfile{hp}{script}{arrays-1.c}
+  Beispielprogramm: \gitfile{hp}{2020ws/script}{arrays-1.c}
   \begin{lstlisting}
     #include <stdio.h>
 
@@ -1805,7 +1805,7 @@
   Wenn wir uns dieser Schreibweise bedienen
   und anstelle des Zeigers \lstinline{p}, der durchgehend den Wert \lstinline{prime} hat,
   direkt \lstinline{prime} verwenden,
-  erhalten wir das Beispielprogramm \gitfile{hp}{script}{arrays-2.c}:
+  erhalten wir das Beispielprogramm \gitfile{hp}{2020ws/script}{arrays-2.c}:
   \goodbreak
   \begin{lstlisting}
     #include <stdio.h>
@@ -1857,7 +1857,7 @@
   braucht diese nicht ausdrücklich angegeben zu werden.
   In diesem Fall folgt auf den Bezeichner nur das Paar eckiger Klammern und der Initialisierer.
 
-  Das Beispielprogramm \gitfile{hp}{script}{strings-1.c} zeigt,
+  Das Beispielprogramm \gitfile{hp}{2020ws/script}{strings-1.c} zeigt,
   wie das Array durchlaufen werden kann, bis die Zahl 0 gefunden wird:
   \begin{lstlisting}
     #include <stdio.h>
@@ -1875,7 +1875,7 @@
   Durch die Formatangabe \lstinline{%d} wird jedes Zeichen -- korrektermaßen -- als Dezimalzahl ausgegeben.
   Wenn wir stattdessen die Formatangabe \lstinline{%c} verwenden (für \emph{character\/}),
   wird für jedes Zeichen -- ebenso korrektermaßen -- sein Zeichenwert (Buchstabe, Ziffer, \dots) ausgegeben
-  (Datei: \gitfile{hp}{script}{strings-2.c}):
+  (Datei: \gitfile{hp}{2020ws/script}{strings-2.c}):
   \begin{lstlisting}
     #include <stdio.h>
 
@@ -1891,7 +1891,7 @@
 
   Durch Verwendung von Pointer-Arithmetik
   und Weglassen der überflüssigen Abfrage \lstinline{!= 0}
-  erhalten wir das äquivalente Beispielprogramm \gitfile{hp}{script}{strings-3.c}:
+  erhalten wir das äquivalente Beispielprogramm \gitfile{hp}{2020ws/script}{strings-3.c}:
   \begin{lstlisting}
     #include <stdio.h>
 
@@ -1912,7 +1912,7 @@
   Eine weitere Formatangabe \lstinline{%s} dient in \lstinline{printf()} dazu,
   direkt einen kompletten String bis ausschließlich der abschließenden 0 auszugeben.
 
-  Beispielprogramm: \gitfile{hp}{script}{strings-4.c}
+  Beispielprogramm: \gitfile{hp}{2020ws/script}{strings-4.c}
   \begin{lstlisting}
     #include <stdio.h>
 
@@ -1967,7 +1967,7 @@
       führt dies zu unsinnigen Ergebnissen
       bis hin zu einem Absturz (Speicherzugriffsfehler).
 
-      Beispielprogramm: \gitfile{hp}{2020ws/20161024}{strings-14.c}
+      Beispielprogramm: \gitfile{hp}{2020ws/script}{strings-14.c}
 
     \item[\textbf{;\,)}]
       Null-Zeichen in den String schreiben
@@ -1988,7 +1988,7 @@
       werden andere Variable überschrieben,
       was in der Regel zu einem Absturz führt (Speicherzugriffsfehler).
 
-      Beispielprogramm: \gitfile{hp}{2020ws/20161024}{strings-14.c}
+      Beispielprogramm: \gitfile{hp}{2020ws/script}{strings-14.c}
 
     \item
       \lstinline{strlen()} -- Ermitteln der Länge eines Strings
@@ -2001,7 +2001,7 @@
         printf ("%s\n", strlen (hello));
       \end{lstlisting}
 
-      Beispielprogramm: \gitfile{hp}{2020ws/20161024}{strings-14.c}
+      Beispielprogramm: \gitfile{hp}{2020ws/script}{strings-14.c}
 
     \item
       \lstinline{strcmp()} -- Strings vergleichen
@@ -2024,7 +2024,7 @@
       normalerweise ASCII. Dabei kommen z.\,B.\ Großbuchstaben grundsätzlich
       \emph{vor\/} den Kleinbuchstaben.
 
-      Beispielprogramm: \gitfile{hp}{2020ws/20161024}{strings-15.c}
+      Beispielprogramm: \gitfile{hp}{2020ws/script}{strings-15.c}
 
     \item
       \lstinline{strcat()} -- String an anderen String anhängen
@@ -2046,7 +2046,7 @@
       werden andere Variable überschrieben,
       was in der Regel zu einem Absturz führt (Speicherzugriffsfehler).
       
-      Beispielprogramm: \gitfile{hp}{2020ws/20161024}{strings-15.c}
+      Beispielprogramm: \gitfile{hp}{2020ws/script}{strings-15.c}
 
     \item
       \lstinline{sprintf()} -- in String schreiben
@@ -2075,7 +2075,7 @@
       zu verwenden. Diese erwartet als zweiten Parameter die Länge des Ziel-Strings
       und sorgt dafür, daß nicht über dessen Ende hinausgeschrieben wird.
 
-      Beispielprogramm: \gitfile{hp}{2020ws/20161024}{strings-16.c}
+      Beispielprogramm: \gitfile{hp}{2020ws/script}{strings-16.c}
 
     \item
       \lstinline{strstr()} -- in String suchen
@@ -2097,7 +2097,7 @@
       (\emph{signed size type\/}). Um diese mit \lstinline{printf()} auszugeben,
       verwendet man \lstinline{%zd} anstelle von \lstinline{%d}.
 
-      Beispielprogramm: \gitfile{hp}{2020ws/20161024}{strings-16.c}
+      Beispielprogramm: \gitfile{hp}{2020ws/script}{strings-16.c}
       
   \end{itemize}
 
@@ -2114,7 +2114,7 @@
   geschrieben.
   
   Tatsächlich kann das Hauptprogramm vom Betriebssystem Parameter entgegennehmen
-  (Datei: \gitfile{hp}{script}{params-1.c}):
+  (Datei: \gitfile{hp}{2020ws/script}{params-1.c}):
   \begin{lstlisting}
     #include <stdio.h>
 
@@ -2156,9 +2156,9 @@
 
   Um die Parameter des Programms in einer Schleife durchzugehen,
   können wir also entweder von \lstinline{0} bis \lstinline{argc - 1} zählen
-  (Schleifenbedingung \lstinline{i < argc}, Datei: \gitfile{hp}{script}{params-1.c} -- siehe oben)
+  (Schleifenbedingung \lstinline{i < argc}, Datei: \gitfile{hp}{2020ws/script}{params-1.c} -- siehe oben)
   oder die Schleife mit dem Erreichen der Endmarkierung abbrechen
-  (Schleifenbedingung \lstinline{argv[i] != NULL}, Datei: \gitfile{hp}{script}{params-2.c}).
+  (Schleifenbedingung \lstinline{argv[i] != NULL}, Datei: \gitfile{hp}{2020ws/script}{params-2.c}).
   \begin{lstlisting}
     #include <stdio.h>
 
@@ -2172,7 +2172,7 @@
   \end{lstlisting}
   Auch für Zeiger gilt: \lstinline{NULL} entspricht dem Wahrheitswert "`falsch"';
   alles andere dem Wahrheitswert "`wahr"'.
-  Wir dürfen die Schleifenbedingung also wie folgt abkürzen (Datei: \gitfile{hp}{script}{params-3.c}):
+  Wir dürfen die Schleifenbedingung also wie folgt abkürzen (Datei: \gitfile{hp}{2020ws/script}{params-3.c}):
   \begin{lstlisting}
     #include <stdio.h>
 
@@ -2190,7 +2190,7 @@
   In vielen Situationen ist es sinnvoll,
   mehrere Variable zu einer Einheit zusammenzufassen.
 
-  Das folgende Beispielprogramm \gitfile{hp}{script}{structs-1.c}
+  Das folgende Beispielprogramm \gitfile{hp}{2020ws/script}{structs-1.c}
   faßt drei Variable \lstinline{day}, \lstinline{month} und \lstinline{year}
   zu einem einzigen -- neuen -- Datentyp \lstinline{date} zusammen:
   \begin{lstlisting}
@@ -2225,7 +2225,7 @@
 
   Eine wichtige Anwendung derartiger \newterm{strukturierter Datentypen\/} besteht darin,
   zusammengehörige Daten als Einheit an Funktionen übergeben zu können
-  (Beispielprogramm: \gitfile{hp}{script}{structs-2.c}):
+  (Beispielprogramm: \gitfile{hp}{2020ws/script}{structs-2.c}):
   \begin{lstlisting}
     #include <stdio.h>
 
@@ -2265,7 +2265,7 @@
   \lstinline{foo->bar}
 
   \goodbreak
-  Beispielprogramm: \gitfile{hp}{script}{structs-3.c}
+  Beispielprogramm: \gitfile{hp}{2020ws/script}{structs-3.c}
   \goodbreak
   \begin{lstlisting}
     #include <stdio.h>
@@ -2314,7 +2314,7 @@
   sollte man ihn durch etwas Uncompilierbares (z.\,B.\ \lstinline{@@@}) markieren,
   damit man auf jeden Fall vermeidet, ein fehlerhaftes Programm auszuliefern.)
 
-  Zunächst kopieren wir das Beispielprogramm \gitfile{hp}{script}{structs-3.c}
+  Zunächst kopieren wir das Beispielprogramm \gitfile{hp}{2020ws/script}{structs-3.c}
   und ergänzen den Aufruf der -- noch nicht existierenden -- Funktion \lstinline{inc_date()}
   (Datei: \gitfile{{hp}script}{incdate-0.c}):
   \begin{lstlisting}
@@ -2367,7 +2367,7 @@
   Stattdessen haben wir jetzt eine fehlerhafte Funktion \lstinline{inc_date()}.
 
   Im nächsten Schritt ersetzen wir die fehlerhafte Funktion
-  durch ein simples Hochzählen der \lstinline{day}-Kom\-po\-nen\-te (Datei: \gitfile{hp}{script}{incdate-1.c})
+  durch ein simples Hochzählen der \lstinline{day}-Kom\-po\-nen\-te (Datei: \gitfile{hp}{2020ws/script}{incdate-1.c})
   \begin{lstlisting}
     void inc_date (date *d)
     {
@@ -2378,7 +2378,7 @@
   Dies reparieren wir im nächsten Schritt,
   wobei wir für den Moment inkorrekterweise annehmen, daß alle Monate 30 Tage hätten
   und das Jahr beliebig viele Monate.
-  (Datei: \gitfile{hp}{script}{incdate-2.c}):
+  (Datei: \gitfile{hp}{2020ws/script}{incdate-2.c}):
   \begin{lstlisting}
     void inc_date (date *d)
     {
@@ -2391,7 +2391,7 @@
     }
   \end{lstlisting}
   Zunächst reparieren wir den Fehler, der am Ende des Jahres entsteht
-  (Datei: \gitfile{hp}{script}{incdate-3.c}).
+  (Datei: \gitfile{hp}{2020ws/script}{incdate-3.c}).
   \begin{lstlisting}
     void inc_date (date *d)
     {
@@ -2411,7 +2411,7 @@
   Das Problem der unterschiedlich langen Monate gehen wir wieder stufenweise an.
   Zunächst ersetzen wir die Konstante \lstinline{31}
   durch eine Variable \lstinline{days_in_month}.
-  (Datei: \gitfile{hp}{script}{incdate-4.c})
+  (Datei: \gitfile{hp}{2020ws/script}{incdate-4.c})
   \begin{lstlisting}
     void inc_date (date *d)
     {
@@ -2430,7 +2430,7 @@
     }
   \end{lstlisting}
   Anschließend reparieren wir den fehlerhaften (konstanten) Wert der Variablen,
-  wobei wir zunächst das Problem der Schaltjahre aussparen (Datei: \gitfile{hp}{script}{incdate-5.c}):
+  wobei wir zunächst das Problem der Schaltjahre aussparen (Datei: \gitfile{hp}{2020ws/script}{incdate-5.c}):
   \begin{lstlisting}
     void inc_date (date *d)
     {
@@ -2454,7 +2454,7 @@
   \end{lstlisting}
   Auf dieselbe Weise lagern wir das Problem "`Schaltjahr oder nicht?"'
   in eine Variable aus. Diese ist wieder zunächst konstant
-  (Datei: \gitfile{hp}{script}{incdate-6.c}):
+  (Datei: \gitfile{hp}{2020ws/script}{incdate-6.c}):
   \begin{lstlisting}
     void inc_date (date *d)
     {
@@ -2483,7 +2483,7 @@
     }
   \end{lstlisting}
   Als nächstes ergänzen wir die Vier-Jahres-Regel für Schaltjahre
-  (Datei \gitfile{hp}{script}{incdate-7.c}):
+  (Datei \gitfile{hp}{2020ws/script}{incdate-7.c}):
   \begin{lstlisting}
           ¡int is_leap_year = 0;
           if (d->year % 4 == 0)
@@ -2495,11 +2495,11 @@
   \end{lstlisting}
   Das nun vorliegende Programm arbeitet bereits für den julianischen Kalender
   sowie für alle Jahre von 1901 bis 2099 korrekt,
-  nicht jedoch für z.\,B.\ das Jahr 2100 (Datei: \gitfile{hp}{script}{incdate-8.c}).
+  nicht jedoch für z.\,B.\ das Jahr 2100 (Datei: \gitfile{hp}{2020ws/script}{incdate-8.c}).
   Damit das Programm für den aktuell verwendeten gregorianischen Kalender korrekt arbeitet,
   ergänzen wir noch die Ausnahme, daß durch 100 teilbare Jahre keine Schaltjahre sind,
   sowie die Ausnahme von der Ausnahme, daß durch 400 teilbare Jahre
-  (z.\,B.\ das Jahr 2000) eben doch Schaltjahre sind (Datei: \gitfile{hp}{script}{incdate-9.c}):
+  (z.\,B.\ das Jahr 2000) eben doch Schaltjahre sind (Datei: \gitfile{hp}{2020ws/script}{incdate-9.c}):
   \begin{lstlisting}
           int is_leap_year = 0;
           if (d->year % 4 == 0)
@@ -2518,7 +2518,7 @@
             days_in_month = 28;
   \end{lstlisting}
   Damit ist die Aufgabe gelöst.
-  Der vollständige Quelltext der Lösung (Datei: \gitfile{hp}{script}{incdate-9.c}) lautet:
+  Der vollständige Quelltext der Lösung (Datei: \gitfile{hp}{2020ws/script}{incdate-9.c}) lautet:
   \begin{lstlisting}
     #include <stdio.h>
 
@@ -2650,7 +2650,7 @@
   \lstinline{FILE} übergibt, verhalten sie sich in der üblichen Weise,
   nur daß sie nicht zur Standardausgabe schreiben (Bildschirm),
   sondern in die Datei, deren Name beim Öffnen des \lstinline{FILE}
-  angegeben wurde (Datei \gitfile{hp}{script}{fhello-1.c}):
+  angegeben wurde (Datei \gitfile{hp}{2020ws/script}{fhello-1.c}):
 
   \begin{lstlisting}
     #include <stdio.h>
@@ -2671,7 +2671,7 @@
   ist dieser Zeiger \lstinline{NULL}, und seine Verwendung führt
   zum Absturz des Programms.
   Es ist daher dringend empfohlen, diesen Fall zu prüfen
-  (Datei: \gitfile{hp}{script}{fhello-2.c}):
+  (Datei: \gitfile{hp}{2020ws/script}{fhello-2.c}):
 
   \begin{lstlisting}
     #include <stdio.h>
@@ -2696,7 +2696,7 @@
   Mit \lstinline{#include <errno.h>} erhält unser Programm
   Zugriff auf diese Variable
   und kann den Fehler-Code in seiner Fehlermeldung mit ausgeben
-  (Datei: \gitfile{hp}{script}{fhello-3.c}):
+  (Datei: \gitfile{hp}{2020ws/script}{fhello-3.c}):
 
   \begin{lstlisting}
     #include <stdio.h>
@@ -2730,7 +2730,7 @@
   Mit \lstinline{#include <string.h>} erhalten wir
   eine Funktion \lstinline{strerror()},
   die den Fehler-Code in eine für Menschen lesbare Fehlermeldung umwandelt
-  (Datei: \gitfile{hp}{script}{fhello-4.c}):
+  (Datei: \gitfile{hp}{2020ws/script}{fhello-4.c}):
 
   \begin{lstlisting}
     #include <stdio.h>
@@ -2769,7 +2769,7 @@
   eine Funktion \lstinline{error()} zur Verfügung,
   die eine zum übergebenen Fehler-Code gehörende Fehlermeldung ausgibt
   und anschließend das Programm mit einem übergebenen Fehler-Code beendet
-  (Datei: \gitfile{hp}{script}{fhello-5.c}):
+  (Datei: \gitfile{hp}{2020ws/script}{fhello-5.c}):
 
   \begin{lstlisting}
     #include <stdio.h>
@@ -2817,14 +2817,14 @@
   Dies ist zunächst unabhängig von Bibliotheken und auch nicht auf die Programmiersprache C beschränkt.
 
   Beispiel:
-  Die Datei \gitfile{hp}{script}{maerchen.c} enthält:
+  Die Datei \gitfile{hp}{2020ws/script}{maerchen.c} enthält:
   \begin{lstlisting}[language={}]
     Vor langer, langer Zeit
     gab es einmal
     #include "hexe.h"
     Die lebte in einem Wald.
   \end{lstlisting}
-  Die Datei \gitfile{hp}{script}{hexe.h} enthält:
+  Die Datei \gitfile{hp}{2020ws/script}{hexe.h} enthält:
   \begin{lstlisting}[language={}]
     eine kleine Hexe.
   \end{lstlisting}
@@ -2859,7 +2859,7 @@
   \end{lstlisting}
 
   Nichts anderes geschieht, wenn man das klassische \file{hello.c}
-  (Datei: \gitfile{hp}{script}{hello-1.c} compiliert:
+  (Datei: \gitfile{hp}{2020ws/script}{hello-1.c} compiliert:
   \begin{lstlisting}
     #include <stdio.h>
 
@@ -2869,7 +2869,7 @@
       return 0;
     }
   \end{lstlisting}
-  Die Datei \file{stdio.h} ist wesentlich länger als \gitfile{hp}{script}{hexe.txt} in dem o.\,a.\
+  Die Datei \file{stdio.h} ist wesentlich länger als \gitfile{hp}{2020ws/script}{hexe.txt} in dem o.\,a.\
   Beispiel, und sie ruft weitere Include-Dateien auf,
   so daß wir insgesamt auf über 800 Zeilen Quelltext kommen.
 
@@ -2918,7 +2918,7 @@
   die bei Benutzung durch einen Text ersetzt werden.
   Auf diese Weise kann man \newterm{Konstante\/} definieren.
 
-  Beispiel: \gitfile{hp}{script}{higher-math-1.c}
+  Beispiel: \gitfile{hp}{2020ws/script}{higher-math-1.c}
   \begin{lstlisting}
     #include <stdio.h>
 
@@ -2934,7 +2934,7 @@
   Genau wie bei \lstinline{#include} nimmt der Präprozessor auch bei \lstinline{#define}
   eine rein textuelle Ersetzung vor, ohne sich um den Sinn des Ersetzten zu kümmern.
 
-  Beispiel: \gitfile{hp}{script}{higher-math-2.c}
+  Beispiel: \gitfile{hp}{2020ws/script}{higher-math-2.c}
   \begin{lstlisting}
     #include <stdio.h>
 
@@ -2952,7 +2952,7 @@
 
   Dies kann zu Problemen führen, sobald Berechnungen ins Spiel kommen.
 
-  Beispiel: \gitfile{hp}{script}{higher-math-3.c}
+  Beispiel: \gitfile{hp}{2020ws/script}{higher-math-3.c}
   \begin{lstlisting}
     #include <stdio.h>
 
@@ -2975,7 +2975,7 @@
   Um derartige Effekte zu vermeiden, setzt man arithmetische
   Operationen innerhalb von Makros in Klammern.
 
-  Beispiel: \gitfile{hp}{script}{higher-math-4.c}
+  Beispiel: \gitfile{hp}{2020ws/script}{higher-math-4.c}
   \begin{lstlisting}
     #define VIER (2 + 2)
   \end{lstlisting}
@@ -2988,7 +2988,7 @@
   \begin{experts}
     Wenn man ein Semikolon setzt, gehört dies mit zum Ersetzungstext des Makros.
     Dies ist grundsätzlich zulässig, führt aber zu sehr seltsamen C-Quelltexten.
-    -- siehe z.\,B.\ \gitfile{hp}{script}{higher-math-5.c}.
+    -- siehe z.\,B.\ \gitfile{hp}{2020ws/script}{higher-math-5.c}.
   \end{experts}
 
   \breath
@@ -2997,7 +2997,7 @@
   
   Es besteht aus drei Quelltexten:
 
-  \gitfile{hp}{script}{philosophy.c}:
+  \gitfile{hp}{2020ws/script}{philosophy.c}:
   \begin{lstlisting}
     #include <stdio.h>
     #include "answer.h"
@@ -3010,7 +3010,7 @@
   \end{lstlisting}
  
   \goodbreak
-  \gitfile{hp}{script}{answer.c}:
+  \gitfile{hp}{2020ws/script}{answer.c}:
   \begin{lstlisting}
     int answer (void)
     {
@@ -3019,13 +3019,13 @@
   \end{lstlisting}
  
   \goodbreak
-  \gitfile{hp}{script}{answer.h}:
+  \gitfile{hp}{2020ws/script}{answer.h}:
   \begin{lstlisting}
     extern int answer (void);
   \end{lstlisting}
 
-  Das Programm \gitfile{hp}{script}{philosophy.c} verwendet eine Funktion \lstinline{answer()}, die
-  in der Datei \gitfile{hp}{script}{answer.h} extern deklariert ist.
+  Das Programm \gitfile{hp}{2020ws/script}{philosophy.c} verwendet eine Funktion \lstinline{answer()}, die
+  in der Datei \gitfile{hp}{2020ws/script}{answer.h} extern deklariert ist.
 
   Der "`normale"' Aufruf
   \begin{lstlisting}[style=terminal]
@@ -3044,7 +3044,7 @@
   tritt ein Fehler auf.
 
   Tatsächlich wird die Funktion \lstinline{answer()}
-  nicht innerhalb von \gitfile{hp}{script}{philosophy.c}, sondern in einer separaten Datei \gitfile{hp}{script}{answer.c},
+  nicht innerhalb von \gitfile{hp}{2020ws/script}{philosophy.c}, sondern in einer separaten Datei \gitfile{hp}{2020ws/script}{answer.c},
   einer sog.\ \newterm{Bibliothek\/} definiert.
   Es ist möglich (und üblich), Bibliotheken separat vom Hauptprogramm zu compilieren.
   Dadurch spart man sich das Neucompilieren,
@@ -3096,7 +3096,7 @@
   Unter Microsoft Windows ist der Aufruf etwas anders
   und hängt von der verwendeten Version der GLUT-Bibliothek ab.
   Für Details siehe die Dokumentation der GLUT-Bibliothek
-  sowie die Datei \gitfile{hp}{2020ws/20161031}{egal.txt}.)
+  sowie die Datei \gitfile{hp}{2020ws/script}{egal.txt}.)
 
   Die Bibliothek stellt uns fertig geschriebene Programmfragmente zur Verfügung, insbesondere:
   \begin{itemize}
@@ -3145,7 +3145,7 @@
 
   \begin{itemize}
     \item
-      Das Beispielprogramm \gitfile{hp}{script}{cube-1.c} illustriert,
+      Das Beispielprogramm \gitfile{hp}{2020ws/script}{cube-1.c} illustriert,
       wie man grundsätzlich überhaupt ein geometrisches Objekt zeichnet.
       In diesem Fall handelt es sich um einen Würfel der Kantenlänge \lstinline{0.5},
       von dem wir nur die Vorderfläche sehen, also ein Quadrat.
@@ -3190,7 +3190,7 @@
         \put(5.1,1.7){\makebox(0,0)[l]{Endlosschleife: Ab jetzt werden nur noch Callbacks aufgerufen.}}
       \end{picture}
     \item
-      In \gitfile{hp}{script}{cube-2.c} kommt eine Drehung um \lstinline{-30} Grad
+      In \gitfile{hp}{2020ws/script}{cube-2.c} kommt eine Drehung um \lstinline{-30} Grad
       um eine schräge Achse \lstinline{(0.5, 1.0, 0.0)} hinzu.
       Der Würfel ist jetzt als solcher zu erkennen.
 
@@ -3198,7 +3198,7 @@
       daß alle nachfolgenden Zeichenoperationen gedreht ausgeführt werden.
 
     \item
-      In \gitfile{hp}{script}{cube-3.c} kommt als zusätzliches Konzept eine weitere Callback-Funktion hinzu,
+      In \gitfile{hp}{2020ws/script}{cube-3.c} kommt als zusätzliches Konzept eine weitere Callback-Funktion hinzu,
       nämlich ein \newterm{Timer-Handler}.
       Durch den \lstinline{glutTimerFunc()}-Aufruf veranlassen wir OpenGL,
       die von uns geschriebene Funktion \lstinline{timer_handler()} aufzurufen,
@@ -3216,21 +3216,21 @@
 
 %    \item
 %      Weil das Bild während des Neuzeichnens die ganze Zeit zu sehen ist,
-%      flackert in \gitfile{hp}{script}{cube-3.c} der Bildschirm.
-%      Dies wird in \gitfile{hp}{script}{cube-3a.c} dadurch behoben,
+%      flackert in \gitfile{hp}{2020ws/script}{cube-3.c} der Bildschirm.
+%      Dies wird in \gitfile{hp}{2020ws/script}{cube-3a.c} dadurch behoben,
 %      daß die Zeichnung zunächst in einem unsichtbaren Pufferspeicher aufgebaut wird.
 %      Erst die fertige Zeichnung wird mit dem Funktionsaufruf \lstinline{swapBuffers()} sichtbar gemacht.
 %
 %      Damit dies möglich ist, muß beim Initialisieren ein doppelter Puffer angefordert werden.
-%      Zu diesem Zweck ersetzen wir die Bibliothek \gitfile{hp}{script}{opengl-magic.c}
-%      durch \gitfile{hp}{script}{opengl-magic-double.c}.
+%      Zu diesem Zweck ersetzen wir die Bibliothek \gitfile{hp}{2020ws/script}{opengl-magic.c}
+%      durch \gitfile{hp}{2020ws/script}{opengl-magic-double.c}.
 %
 %      Der Compiler-Aufruf lautet dann:
 %      \begin{lstlisting}[style=terminal,gobble=8]
 %        $ ¡gcc -Wall -O cube.c -lGL -lGLU -lglut opengl-magic-double.c -o cube¿
 %      \end{lstlisting}
 %
-%      Unabhängig davon heißt die Include-Datei weiterhin \gitfile{hp}{script}{opengl-magic.h}.
+%      Unabhängig davon heißt die Include-Datei weiterhin \gitfile{hp}{2020ws/script}{opengl-magic.h}.
 %      Dies illustriert, daß der Include-Mechanismus des Präprozessors
 %      und der Zusammenbau-Mecha"-nismus des Linkers tatsächlich voneinander unabhängig sind.
 %
@@ -3244,7 +3244,7 @@
 %      \end{experts}
 
     \item
-      In \gitfile{hp}{script}{cube-3.c} dreht sich der Würfel zunächst langsam, dann immer schneller.
+      In \gitfile{hp}{2020ws/script}{cube-3.c} dreht sich der Würfel zunächst langsam, dann immer schneller.
       Dies liegt daran, daß sich jedes \lstinline{glRotatef()}
       auf alle nachfolgenden Zeichenbefehle auswirkt,
       so daß sich sämtliche \lstinline{glRotatef()} aufaddieren.
@@ -3256,7 +3256,7 @@
       Durch \lstinline{glPopMatrix()} wird das System wieder in denjenigen Zustand versetzt,
       in dem es sich vor dem Aufruf von \lstinline{glPushMatrix()} befand.
 
-      Dies ist in \gitfile{hp}{script}{cube-4.c} (langsame Drehung) und \gitfile{hp}{script}{cube-5.c} (schnelle Drehung) umgesetzt.
+      Dies ist in \gitfile{hp}{2020ws/script}{cube-4.c} (langsame Drehung) und \gitfile{hp}{2020ws/script}{cube-5.c} (schnelle Drehung) umgesetzt.
 
   \end{itemize}
 
@@ -3304,7 +3304,7 @@
   Die weiteren OpenGL-Beispielprogramme illustrieren den Umgang mit Transformationen.
   \begin{itemize}
     \item
-      Die Beispielprogramme \gitfile{hp}{script}{cube-5.c} und \gitfile{hp}{script}{cube-6.c}
+      Die Beispielprogramme \gitfile{hp}{2020ws/script}{cube-5.c} und \gitfile{hp}{2020ws/script}{cube-6.c}
       illustrieren eine weitere Transformation der gezeichneten Objekte,
       nämlich die Translation (Verschiebung).
 
@@ -3315,7 +3315,7 @@
       muß man die Transformationen in der Reihenfolge \emph{von unten nach oben\/} ausführen.
 
     \item
-      Das Beispielprogramm \gitfile{hp}{script}{orbit-1.c} 
+      Das Beispielprogramm \gitfile{hp}{2020ws/script}{orbit-1.c} 
       verwendet weitere Transformationen und geometrische Objekte,
       um die Umlaufbahn des Mondes um die Erde zu illustrieren.
 
@@ -3395,8 +3395,8 @@
   mehreren Leerzeichen unterscheiden. \lstinline[style=cmd]{make}
   akzeptiert jedoch nur das Tabulator-Zeichen.
 
-  Die o.\,a.\ Regel bedeutet, daß jedesmal, wenn sich \gitfile{hp}{script}{philosophy.c} oder
-  \gitfile{hp}{script}{answer.h} geändert hat, \lstinline[style=cmd]{make}
+  Die o.\,a.\ Regel bedeutet, daß jedesmal, wenn sich \gitfile{hp}{2020ws/script}{philosophy.c} oder
+  \gitfile{hp}{2020ws/script}{answer.h} geändert hat, \lstinline[style=cmd]{make}
   das Programm \lstinline[style=cmd]{gcc} in der beschriebenen Weise aufrufen soll.
 
   Durch die Kombination mehrerer Regeln lernt \lstinline[style=cmd]{make},
@@ -4687,7 +4687,7 @@
     \begin{displaymath}
       \phi(t) = \phi(0)\cdot\cos(\omega t)\qquad\mbox{mit}\qquad\omega=\sqrt{\frac{g}{l}}
     \end{displaymath}
-    Das Beispielprogramm \gitfile{hp}{script}{pendulum-1.c} illustriert,
+    Das Beispielprogramm \gitfile{hp}{2020ws/script}{pendulum-1.c} illustriert,
     welche Bewegung sich aus diesem $\phi(t)$ ergibt.
   \end{experts}
 
@@ -4743,7 +4743,7 @@
                        = \phi(t) + \frac{\Delta t \cdot v}{l}
   \end{displaymath}
 
-  Ein C-Programm, das diese Berechnungen durchführt (Datei: \gitfile{hp}{script}{pendulum-2.c}), enthält als Kernstück:
+  Ein C-Programm, das diese Berechnungen durchführt (Datei: \gitfile{hp}{2020ws/script}{pendulum-2.c}), enthält als Kernstück:
   \goodbreak
   \begin{lstlisting}
     #define g 9.81
@@ -4767,21 +4767,21 @@
   versetzt das Pendel um das Zeitintervall \lstinline{dt} in die Zukunft.
  
   Es ist vom Verfahren her nicht notwendig, mit der Kleinwinkelnäherung $\sin\phi\approx\phi$ zu arbeiten.
-  Das Beispielprogramm \gitfile{hp}{script}{pendulum-3.c} illustriert,
+  Das Beispielprogramm \gitfile{hp}{2020ws/script}{pendulum-3.c} illustriert,
   welchen Unterschied die Kleinwinkelnäherung ausmacht.
 
   Wie gut arbeitet das explizite Euler-Verfahren?
   Um dies zu untersuchen, lösen wir eine Differentialgleichung,
   deren exakte Lösung aus der Literatur bekannt ist,
   nämlich die Differentialgleichung mit Kleinwinkelnäherung.
-  Das Beispielprogramm \gitfile{hp}{script}{pendulum-4.c} vergleicht beide Lösungen miteinander.
+  Das Beispielprogramm \gitfile{hp}{2020ws/script}{pendulum-4.c} vergleicht beide Lösungen miteinander.
   Für das betrachtete Beispiel ist die Übereinstimmung recht gut;
   für Präzisionsberechnungen ist das explizite Euler-Verfahren jedoch nicht genau (und stabil) genug.
   Hierfür sei auf die Lehrveranstaltungen zur numerischen Mathematik verwiesen.
 
   \subsubsection*{Bemerkung}
 
-  Das Beispielprogramm \gitfile{hp}{script}{pendulum-4.c} berechnet mit überzeugender Übereinstimmung
+  Das Beispielprogramm \gitfile{hp}{2020ws/script}{pendulum-4.c} berechnet mit überzeugender Übereinstimmung
   dasselbe Ergebnis für die Auslenkung des Pendels auf zwei verschiedene Weisen:
   \begin{enumerate}
     \item
@@ -4900,26 +4900,26 @@
   \begin{itemize}
     \item
       Minimum/Maximum ermitteln:
-      \gitfile{hp}{script}{sort-0.c} (mit "`Schummeln"'),
-      \gitfile{hp}{script}{sort-1.c} (lineare Suche),
-      \gitfile{hp}{script}{sort-2.c} (mit Visualisierung)
+      \gitfile{hp}{2020ws/script}{sort-0.c} (mit "`Schummeln"'),
+      \gitfile{hp}{2020ws/script}{sort-1.c} (lineare Suche),
+      \gitfile{hp}{2020ws/script}{sort-2.c} (mit Visualisierung)
     \item
       Selectionsort:
-      \gitfile{hp}{script}{sort-3.c} (bei Minimumsuche Anfang des Arrays überspringen),
-      \gitfile{hp}{script}{sort-4.c} (Selectionsort),
-      \gitfile{hp}{script}{sort-5.c} (100 Namen),
-      \gitfile{hp}{script}{sort-6.c} (100 Namen, ohne Visualisierung)
+      \gitfile{hp}{2020ws/script}{sort-3.c} (bei Minimumsuche Anfang des Arrays überspringen),
+      \gitfile{hp}{2020ws/script}{sort-4.c} (Selectionsort),
+      \gitfile{hp}{2020ws/script}{sort-5.c} (100 Namen),
+      \gitfile{hp}{2020ws/script}{sort-6.c} (100 Namen, ohne Visualisierung)
     \item
       Bubblesort:
-      \gitfile{hp}{script}{sort-7.c} (Selectionsort, Minimumsuche mit in der Hauptschleife),
-      \gitfile{hp}{script}{bsort-1.c} (Minimumsuche durch Vergleich benachbarter Strings),
-      \gitfile{hp}{script}{bsort-2.c} (Abbruch in äußerer Schleife, sobald sortiert),
-      \gitfile{hp}{script}{bsort-3.c} (Abbruch auch in innerer Schleife, sobald sortiert)
+      \gitfile{hp}{2020ws/script}{sort-7.c} (Selectionsort, Minimumsuche mit in der Hauptschleife),
+      \gitfile{hp}{2020ws/script}{bsort-1.c} (Minimumsuche durch Vergleich benachbarter Strings),
+      \gitfile{hp}{2020ws/script}{bsort-2.c} (Abbruch in äußerer Schleife, sobald sortiert),
+      \gitfile{hp}{2020ws/script}{bsort-3.c} (Abbruch auch in innerer Schleife, sobald sortiert)
     \item
       Quicksort:
-      \gitfile{hp}{script}{qsort-1.c} (Array in 2 Hälften vorsortieren),
-      \gitfile{hp}{script}{qsort-2.c} (rekursiver Aufruf für linke Hälfte),
-      \gitfile{hp}{script}{qsort-3.c} (rekursiver Aufruf für beide Hälften)
+      \gitfile{hp}{2020ws/script}{qsort-1.c} (Array in 2 Hälften vorsortieren),
+      \gitfile{hp}{2020ws/script}{qsort-2.c} (rekursiver Aufruf für linke Hälfte),
+      \gitfile{hp}{2020ws/script}{qsort-3.c} (rekursiver Aufruf für beide Hälften)
   \end{itemize}
 
   Bei "`zufällig"' sortierten Ausgangsdaten arbeitet Quicksort schneller als Bubblesort.
@@ -5274,7 +5274,7 @@
       print_object (object[i]);
   \end{lstlisting}
 
-  (Beispiel-Programm: \gitfile{hp}{2020ws/20161219}{objects-7.c})
+  (Beispiel-Programm: \gitfile{hp}{2020ws/script}{objects-7.c})
 
   Die expliziten Typumwandlungen sind ein gravierender Nachteil dieser
   Vorgehensweise, denn sie schalten jegliche Überprüfung durch den Compiler aus.
@@ -5317,7 +5317,7 @@
                         NULL };
   \end{lstlisting}
 
-  (Beispiel-Programm: \gitfile{hp}{2020ws/20161219}{objects-8.c})
+  (Beispiel-Programm: \gitfile{hp}{2020ws/script}{objects-8.c})
 
   \subsection{Unions}
 
@@ -5357,7 +5357,7 @@
   Die im o.\,a.\ Beispiel konstruierte \lstinline{union}
   spricht dieselbe Speicherzelle einerseits als \lstinline{int8_t} an
   und andererseits als \lstinline{uint8_t}.
-  Das Beispiel-Programm (Datei: \gitfile{hp}{2020ws/20161219}{unions-1.c})
+  Das Beispiel-Programm (Datei: \gitfile{hp}{2020ws/script}{unions-1.c})
   nutzt dies aus, um die negative Zahl \lstinline{-3}
   als positive 8-Bit-Zahl auszugeben (Berechnung des Zweierkomplements).
 
@@ -5419,7 +5419,7 @@
     \end{minipage}
   \end{center}
 
-  (Beispiel-Programm: \gitfile{hp}{2020ws/20161219}{objects-9.c})
+  (Beispiel-Programm: \gitfile{hp}{2020ws/script}{objects-9.c})
 
   Das Ansprechen falscher Speicherbereiche
   wird hierdurch zwar nicht völlig ausgeschlossen;
@@ -5437,7 +5437,7 @@
   nur die veränderlichen Eigenschaften der Objekte
   in einer \lstinline{union} zu speichern --
   siehe Aufgabe 1 (c) bis (e) in den Übungen vom 19.\,12.\,2016
-  (Datei: \gitfile{hp}{2020ws/20161219}{hp-uebung-20161219.pdf}).
+  (Datei: \gitfile{hp}{2016ws/20161219}{hp-uebung-20161219.pdf}).
 
   \goodbreak
 
@@ -5454,7 +5454,7 @@
   Die Bibliothek verwendet intern einige der hier besprochenen Vorgehensweisen
   zur Realisierung objektorientierter Programmierung in C.
 
-  Die Beispielprogramme \href{https://gitlab.cvh-server.de/pgerwinski/hp/tree/2020ws/20161219}%
+  Die Beispielprogramme \href{https://gitlab.cvh-server.de/pgerwinski/hp/tree/2020ws/script}%
   {\file{gtk-1.c} bis \file{gtk-7.c}} demonstrieren,
   wie man mit Hilfe von GTK+ ein einfaches GUI-Programm schreibt,
   das graphische Objekte (Rechteck, Kreis, Dreieck) auf den Bildschirm zeichnet
@@ -5490,7 +5490,7 @@
   sowie die Verarbeitung von Benutzereingaben (Tastatur, Maus)
   über Callbacks.
 
-  In \href{https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20161219/hp-2016ws-p4.pdf}%
+  In \href{https://gitlab.cvh-server.de/pgerwinski/hp/raw/2016ws/20161219/hp-2016ws-p4.pdf}%
   {Praktikumsversuch 4} haben Sie selbst weitere Erfahrungen mit GTK+ gesammelt
   und gleichzeitig eine eigene Objekt-Hierarchie
   (für graphische Objekte: Rechteck, Kreis, Dreieck) programmiert.
@@ -5611,7 +5611,7 @@
 
   \breath
 
-  Das Beispiel-Programm \gitfile{hp}{2020ws/20170109}{objects-12.c} illustriert,
+  Das Beispiel-Programm \gitfile{hp}{2020ws/script}{objects-12.c} illustriert,
   wie man virtuelle Methoden in C realisieren kann.
 
   In größeren Projekten ist es nicht effizient,
@@ -5620,7 +5620,7 @@
   Stattdessen speichert man in der Objektinstanz
   lediglich einen Zeiger auf eine Tabelle von Zeigern auf die virtuellen Methoden,
   die sog.\ \newterm{virtuelle Methodentabelle} --
-  siehe das Beispiel-Programm \gitfile{hp}{2020ws/20170109}{objects-13.c}.
+  siehe das Beispiel-Programm \gitfile{hp}{2020ws/script}{objects-13.c}.
 
   \subsection{Einführung in C++}
 
@@ -5635,8 +5635,8 @@
   Andere bekannte objektorientierte Sprachen sind Java, Python, C\#, JavaScript,
   PHP, verschiedene Pascal-Dialekte und viele weitere.
 
-  Das Beispiel-Programm \gitfile{hp}{2020ws/20170109}{objects-14.cpp}
-  ist eine direkte Übersetzung von \gitfile{hp}{2020ws/20170109}{objects-12.c} nach C++.
+  Das Beispiel-Programm \gitfile{hp}{2020ws/script}{objects-14.cpp}
+  ist eine direkte Übersetzung von \gitfile{hp}{2020ws/script}{objects-12.c} nach C++.
   In C++ kümmert sich der Compiler um die Vererbung zwischen den Objekt-Datentypen,
   um die Verwaltung der Zeiger auf virtuelle Methoden,
   um korrekte Konstruktoren und um vieles mehr.
@@ -5687,7 +5687,7 @@
   In der ermittelten Hälfte beginnt man die Suche wieder in der Mitte --
   so lange, bis man nur noch ein einzelnes Element vor sich hat.
 
-  Das Beispiel-Programm \gitfile{hp}{2020ws/20170116}{stack-11.c} illustriert,
+  Das Beispiel-Programm \gitfile{hp}{2020ws/script}{stack-11.c} illustriert,
   wie man einen Stack mit den o.\,g.\ Funktionalitäten implementieren kann.
 
   \breath
@@ -5711,7 +5711,7 @@
   Die beiden Indexvariablen arbeiten also \emph{ringförmig\/}; 
   der FIFO wird durch einen \newterm{Ringpuffer\/} realisiert.
 
-  Beispiel-Programm: \gitfile{hp}{2020ws/20170116}{fifo-8.c}
+  Beispiel-Programm: \gitfile{hp}{2020ws/script}{fifo-8.c}
 
   \subsection{Verkettete Listen}
 
diff --git a/script/objects-12.c b/script/objects-12.c
new file mode 100644
index 0000000000000000000000000000000000000000..5d605e1b295e252b2d947a1d4ac04c9fc805d36d
--- /dev/null
+++ b/script/objects-12.c
@@ -0,0 +1,66 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+union t_object;
+
+typedef struct
+{
+  void (* print) (union t_object *this);
+} t_base;
+
+typedef struct
+{
+  void (* print) (union t_object *this);
+  int content;
+} t_integer;
+
+typedef struct
+{
+  void (* print) (union t_object *this);
+  char *content;
+} t_string;
+
+typedef union t_object
+{
+  t_base base;
+  t_integer integer;
+  t_string string;
+} t_object;
+
+void print_integer (t_object *this)
+{
+  printf ("Integer: %d\n", this->integer.content);
+}
+
+void print_string (t_object *this)
+{
+  printf ("String: \"%s\"\n", this->string.content);
+}
+
+t_object *new_integer (int i)
+{
+  t_object *p = malloc (sizeof (t_integer));
+  p->integer.print = print_integer;
+  p->integer.content = i;
+  return p;
+}
+
+t_object *new_string (char *s)
+{
+  t_object *p = malloc (sizeof (t_string));
+  p->string.print = print_string;
+  p->string.content = s;
+  return p;
+}
+
+int main (void)
+{
+  t_object *object[] = { new_integer (42),
+                         new_string ("Hello, world!"),
+                         NULL };
+
+  for (int i = 0; object[i]; i++)
+    object[i]->base.print (object[i]);
+
+  return 0;
+}
diff --git a/script/objects-13.c b/script/objects-13.c
new file mode 100644
index 0000000000000000000000000000000000000000..81ef279b060e0b6290194fdeda8c3330cb716cdd
--- /dev/null
+++ b/script/objects-13.c
@@ -0,0 +1,75 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+union t_object;
+struct t_vmt;
+
+typedef struct
+{
+  struct t_vmt *vmt;
+} t_base;
+
+typedef struct
+{
+  struct t_vmt *vmt;
+  int content;
+} t_integer;
+
+typedef struct
+{
+  struct t_vmt *vmt;
+  char *content;
+} t_string;
+
+typedef union t_object
+{
+  t_base base;
+  t_integer integer;
+  t_string string;
+} t_object;
+
+typedef struct t_vmt
+{
+  void (* print) (union t_object *this);
+} t_vmt;
+
+void print_integer (t_object *this)
+{
+  printf ("Integer: %d\n", this->integer.content);
+}
+
+void print_string (t_object *this)
+{
+  printf ("String: \"%s\"\n", this->string.content);
+}
+
+t_vmt vmt_integer = { print_integer };
+t_vmt vmt_string = { print_string };
+
+t_object *new_integer (int i)
+{
+  t_object *p = malloc (sizeof (t_integer));
+  p->integer.vmt = &vmt_integer;
+  p->integer.content = i;
+  return p;
+}
+
+t_object *new_string (char *s)
+{
+  t_object *p = malloc (sizeof (t_string));
+  p->integer.vmt = &vmt_string;
+  p->string.content = s;
+  return p;
+}
+
+int main (void)
+{
+  t_object *object[] = { new_integer (42),
+                         new_string ("Hello, world!"),
+                         NULL };
+
+  for (int i = 0; object[i]; i++)
+    object[i]->base.vmt->print (object[i]);
+
+  return 0;
+}
diff --git a/script/objects-14.cpp b/script/objects-14.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ea40a139bacadb6ce4de30312bb0c1b6c21d9c8e
--- /dev/null
+++ b/script/objects-14.cpp
@@ -0,0 +1,52 @@
+#include <stdio.h>
+
+struct TBase
+{
+  virtual void print () = 0;
+};
+
+struct TInteger: TBase
+{
+  int content;
+  virtual void print ();
+  TInteger (int i);
+};
+
+struct TString: TBase
+{
+  char *content;
+  virtual void print ();
+  TString (char *s);
+};
+
+void TInteger::print ()
+{
+  printf ("Integer: %d\n", content);
+}
+
+void TString::print ()
+{
+  printf ("String: \"%s\"\n", content);
+}
+
+TInteger::TInteger (int i)
+{
+  content = i;
+}
+
+TString::TString (char *s)
+{
+  content = s;
+}
+
+int main (void)
+{
+  TBase *object[] = { new TInteger (42),
+                      new TString ("Hello, world!"),
+                      NULL };
+
+  for (int i = 0; object[i]; i++)
+    object[i]->print ();
+
+  return 0;
+}
diff --git a/script/objects-7.c b/script/objects-7.c
new file mode 100644
index 0000000000000000000000000000000000000000..b9b24ad65f650aeda194e4570ae853e1a5ad8f11
--- /dev/null
+++ b/script/objects-7.c
@@ -0,0 +1,43 @@
+#include <stdio.h>
+
+#define T_BASE    0
+#define T_INTEGER 1
+#define T_STRING  2
+
+typedef struct
+{
+  int type;
+} t_base;
+
+typedef struct
+{
+  int type;
+  int content;
+} t_integer;
+
+typedef struct
+{
+  int type;
+  char *content;
+} t_string;
+
+void print_object (t_base *this)
+{
+  if (this->type == T_INTEGER)
+    printf ("Integer: %d\n", ((t_integer *) this)->content);
+  else if (this->type == T_STRING)
+    printf ("String: \"%s\"\n", ((t_string *) this)->content);
+}
+
+int main (void)
+{
+  t_integer i = { T_INTEGER, 42 };
+  t_string s = { T_STRING, "Hello, world!" };
+
+  t_base *object[] = { (t_base *) &i, (t_base *) &s, NULL };
+
+  for (int i = 0; object[i]; i++)
+    print_object (object[i]);
+
+  return 0;
+}
diff --git a/script/objects-8.c b/script/objects-8.c
new file mode 100644
index 0000000000000000000000000000000000000000..0c93e8f6c3c4b5e504c758dfa87b8510e98c0692
--- /dev/null
+++ b/script/objects-8.c
@@ -0,0 +1,59 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#define T_BASE    0
+#define T_INTEGER 1
+#define T_STRING  2
+
+typedef struct
+{
+  int type;
+} t_base;
+
+typedef struct
+{
+  int type;
+  int content;
+} t_integer;
+
+typedef struct
+{
+  int type;
+  char *content;
+} t_string;
+
+void print_object (t_base *this)
+{
+  if (this->type == T_INTEGER)
+    printf ("Integer: %d\n", ((t_integer *) this)->content);
+  else if (this->type == T_STRING)
+    printf ("String: \"%s\"\n", ((t_string *) this)->content);
+}
+
+t_integer *new_integer (int i)
+{
+  t_integer *p = malloc (sizeof (t_integer));
+  p->type = T_INTEGER;
+  p->content = i;
+  return p;
+}
+
+t_string *new_string (char *s)
+{
+  t_string *p = malloc (sizeof (t_string));
+  p->type = T_STRING;
+  p->content = s;
+  return p;
+}
+
+int main (void)
+{
+  t_base *object[] = { (t_base *) new_integer (42),
+                       (t_base *) new_string ("Hello, world!"),
+                       NULL };
+
+  for (int i = 0; object[i]; i++)
+    print_object (object[i]);
+
+  return 0;
+}
diff --git a/script/objects-9.c b/script/objects-9.c
new file mode 100644
index 0000000000000000000000000000000000000000..41468b043cd69b1c19b2c4456eb937ff34dbe9f8
--- /dev/null
+++ b/script/objects-9.c
@@ -0,0 +1,66 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#define T_BASE    0
+#define T_INTEGER 1
+#define T_STRING  2
+
+typedef struct
+{
+  int type;
+} t_base;
+
+typedef struct
+{
+  int type;
+  int content;
+} t_integer;
+
+typedef struct
+{
+  int type;
+  char *content;
+} t_string;
+
+typedef union
+{
+  t_base base;
+  t_integer integer;
+  t_string string;
+} t_object;
+
+void print_object (t_object *this)
+{
+  if (this->base.type == T_INTEGER)
+    printf ("Integer: %d\n", this->integer.content);
+  else if (this->base.type == T_STRING)
+    printf ("String: \"%s\"\n", this->string.content);
+}
+
+t_object *new_integer (int i)
+{
+  t_object *p = malloc (sizeof (t_integer));
+  p->integer.type = T_INTEGER;
+  p->integer.content = i;
+  return p;
+}
+
+t_object *new_string (char *s)
+{
+  t_object *p = malloc (sizeof (t_string));
+  p->string.type = T_STRING;
+  p->string.content = s;
+  return p;
+}
+
+int main (void)
+{
+  t_object *object[] = { new_integer (42),
+                         new_string ("Hello, world!"),
+                         NULL };
+
+  for (int i = 0; object[i]; i++)
+    print_object (object[i]);
+
+  return 0;
+}
diff --git a/script/stack-11.c b/script/stack-11.c
new file mode 100644
index 0000000000000000000000000000000000000000..89629d661097948711db9ed252f568aa4a15440a
--- /dev/null
+++ b/script/stack-11.c
@@ -0,0 +1,64 @@
+#include <stdio.h>
+
+#define STACK_SIZE 10
+
+int stack[STACK_SIZE];
+int stack_pointer = 0;
+
+void push (int x)
+{
+  stack[stack_pointer++] = x;
+}
+
+void push_at (int x, int pos)
+{
+  for (int i = stack_pointer - 1; i >= pos; i--)
+    stack[i + 1] = stack[i];
+  stack[pos] = x;
+  stack_pointer++;
+}
+
+void push_sorted (int x)
+{
+  int left = 0;
+  int right = stack_pointer;
+  while (left < right - 1)
+    {
+      int i = (left + right) / 2;
+      if (x < stack[i])
+        right = i;
+      else
+        left = i;
+    }
+  push_at (x, right);
+}
+
+int pop (void)
+{
+  return stack[--stack_pointer];
+}
+
+void show (void)
+{
+  printf ("stack:");
+  for (int i = 0; i < stack_pointer; i++)
+    printf (" %d", stack[i]);
+  printf ("\n");
+}
+
+int main (void)
+{
+  push (3);
+  push (7);
+  push (137);
+  show ();
+  push_sorted (5);
+  show ();
+  push_sorted (256);
+  show ();
+  push_sorted (42);
+  push_sorted (13);
+  push_sorted (107);
+  show ();
+  return 0;
+}
diff --git a/script/strings-14.c b/script/strings-14.c
new file mode 100644
index 0000000000000000000000000000000000000000..dd05111f79e0573d616522593362f6f93beb89e7
--- /dev/null
+++ b/script/strings-14.c
@@ -0,0 +1,19 @@
+#include <stdio.h>
+#include <string.h>
+
+int main (void)
+{
+  char hello[] = "Hello, world!\n";
+
+  printf ("%s\n", hello);
+  printf ("%zd\n", strlen (hello));
+
+  printf ("%s\n", hello + 7);
+  printf ("%zd\n", strlen (hello + 7));
+
+  hello[5] = 0;
+  printf ("%s\n", hello);
+  printf ("%zd\n", strlen (hello));
+
+  return 0;
+}
diff --git a/script/strings-15.c b/script/strings-15.c
new file mode 100644
index 0000000000000000000000000000000000000000..fed7abe314e9db92eb804177d9aae413b60fb4c6
--- /dev/null
+++ b/script/strings-15.c
@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include <string.h>
+
+int main (void)
+{
+  char *anton = "Anton";
+  char *zacharias = "Zacharias";
+
+  printf ("%d\n", strcmp (anton, zacharias));
+  printf ("%d\n", strcmp (zacharias, anton));
+  printf ("%d\n", strcmp (anton, anton));
+
+  char buffer[100] = "Huber ";
+  strcat (buffer, anton);
+  printf ("%s\n", buffer);
+
+  return 0;
+}
diff --git a/script/strings-16.c b/script/strings-16.c
new file mode 100644
index 0000000000000000000000000000000000000000..731a6b182fcc38e984565425a141d50bb09893df
--- /dev/null
+++ b/script/strings-16.c
@@ -0,0 +1,15 @@
+#include <stdio.h>
+#include <string.h>
+
+int main (void)
+{
+  char buffer[100] = "";
+  sprintf (buffer, "Die Antwort lautet: %d", 42);
+  printf ("%s\n", buffer);
+
+  char *answer = strstr (buffer, "Antwort");
+  printf ("%s\n", answer);
+  printf ("found at: %zd\n", answer - buffer);
+
+  return 0;
+}
diff --git a/script/unions-1.c b/script/unions-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..87e5325939f6b045d78f92d62eacdbe2045e3190
--- /dev/null
+++ b/script/unions-1.c
@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <stdint.h>
+
+typedef union
+{
+  int8_t i;
+  uint8_t u;
+} num8_t;
+
+int main (void)
+{
+  num8_t n;
+  n.i = -3;
+  printf ("%d\n", n.u);
+  return 0;
+}