diff --git a/20190113/aufgabe-1.c b/20190113/aufgabe-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..a1054f2b601850a402dccb6f4878437d1bb6909c
--- /dev/null
+++ b/20190113/aufgabe-1.c
@@ -0,0 +1,22 @@
+#include <stdio.h>
+
+void foreach (int *a, void (*fun) (int x))
+{
+  for (int *p = a; *p >= 0; p++)
+    fun (*p);
+}
+
+void even_or_odd (int x)
+{
+  if (x % 2)
+    printf ("%d ist ungerade.\n", x);
+  else
+    printf ("%d ist gerade.\n", x);
+}
+
+int main (void)
+{
+  int numbers[] = { 12, 17, 32, 1, 3, 16, 19, 18, -1 };
+  foreach (numbers, even_or_odd);
+  return 0;
+}
diff --git a/20190107/aufgabe-3a.c b/20190113/aufgabe-2a.c
similarity index 100%
rename from 20190107/aufgabe-3a.c
rename to 20190113/aufgabe-2a.c
diff --git a/20190107/aufgabe-3b.c b/20190113/aufgabe-2b.c
similarity index 100%
rename from 20190107/aufgabe-3b.c
rename to 20190113/aufgabe-2b.c
diff --git a/20190107/gtk-1.c b/20190113/gtk-1.c
similarity index 100%
rename from 20190107/gtk-1.c
rename to 20190113/gtk-1.c
diff --git a/20190107/gtk-2.c b/20190113/gtk-2.c
similarity index 100%
rename from 20190107/gtk-2.c
rename to 20190113/gtk-2.c
diff --git a/20190107/gtk-3.c b/20190113/gtk-3.c
similarity index 100%
rename from 20190107/gtk-3.c
rename to 20190113/gtk-3.c
diff --git a/20190107/gtk-4.c b/20190113/gtk-4.c
similarity index 100%
rename from 20190107/gtk-4.c
rename to 20190113/gtk-4.c
diff --git a/20190107/gtk-5.c b/20190113/gtk-5.c
similarity index 100%
rename from 20190107/gtk-5.c
rename to 20190113/gtk-5.c
diff --git a/20190107/gtk-6.c b/20190113/gtk-6.c
similarity index 100%
rename from 20190107/gtk-6.c
rename to 20190113/gtk-6.c
diff --git a/20190107/gtk-7.c b/20190113/gtk-7.c
similarity index 100%
rename from 20190107/gtk-7.c
rename to 20190113/gtk-7.c
diff --git a/20190107/hello-gtk.png b/20190113/hello-gtk.png
similarity index 100%
rename from 20190107/hello-gtk.png
rename to 20190113/hello-gtk.png
diff --git a/20190113/hp-20190113.pdf b/20190113/hp-20190113.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..61094c4e509d8476b726fd88e37282b6f554c4c8
Binary files /dev/null and b/20190113/hp-20190113.pdf differ
diff --git a/20190113/hp-20190113.tex b/20190113/hp-20190113.tex
new file mode 100644
index 0000000000000000000000000000000000000000..c176e5f0939b5be11bae1255b258c6d2d72bc341
--- /dev/null
+++ b/20190113/hp-20190113.tex
@@ -0,0 +1,891 @@
+% hp-20190113.pdf - Lecture Slides on Low-Level Programming
+% Copyright (C) 2012, 2013, 2015, 2016, 2017, 2018, 2019  Peter Gerwinski
+%
+% This document is free software: you can redistribute it and/or
+% modify it either under the terms of the Creative Commons
+% Attribution-ShareAlike 3.0 License, or under the terms of the
+% GNU General Public License as published by the Free Software
+% Foundation, either version 3 of the License, or (at your option)
+% any later version.
+%
+% This document is distributed in the hope that it will be useful,
+% but WITHOUT ANY WARRANTY; without even the implied warranty of
+% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+% GNU General Public License for more details.
+%
+% You should have received a copy of the GNU General Public License
+% along with this document.  If not, see <http://www.gnu.org/licenses/>.
+%
+% You should have received a copy of the Creative Commons
+% Attribution-ShareAlike 3.0 Unported License along with this
+% document.  If not, see <http://creativecommons.org/licenses/>.
+
+% README: Objektorientierte Programmierung
+
+\documentclass[10pt,t]{beamer}
+
+\usepackage{pgslides}
+\usepackage{pdftricks}
+\usepackage{tikz}
+\usepackage{rotating}
+
+\begin{psinputs}
+  \usepackage[utf8]{inputenc}
+  \usepackage[german]{babel}
+  \usepackage[T1]{fontenc}
+  \usepackage{helvet}
+  \renewcommand*\familydefault{\sfdefault}
+  \usepackage{pstricks,pst-grad}
+\end{psinputs}
+
+\title{Hardwarenahe Programmierung}
+\author{Prof.\ Dr.\ rer.\ nat.\ Peter Gerwinski}
+\date{13.\ Januar 2019}
+
+\begin{document}
+
+\maketitleframe
+
+\nosectionnonumber{\inserttitle}
+
+\begin{frame}
+
+  \shownosectionnonumber
+
+  \begin{itemize}
+    \item[\textbf{1}] \textbf{Einführung}
+      \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp.git}}}
+    \item[\textbf{2}] \textbf{Einführung in C}
+    \item[\textbf{3}] \textbf{Bibliotheken}
+    \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
+    \item[\textbf{5}] \textbf{Algorithmen}
+      \begin{itemize}
+        \item[5.1] Differentialgleichungen
+        \item[5.2] Rekursion
+        \color{medgreen}
+        \item[5.3] Aufwandsabschätzungen
+      \end{itemize}
+    \item[\textbf{6}] \textbf{Objektorientierte Programmierung}
+      \begin{itemize}
+        \color{medgreen}
+        \item[6.0] Dynamische Speicherverwaltung
+        \color{orange}
+        \item[6.1] Konzepte und Ziele
+        \color{red}
+        \item[6.2] Beispiel: Zahlen und Buchstaben
+        \item[6.3] Beispiel: Graphische Benutzeroberfläche (GUI)
+        \vspace*{-\smallskipamount}
+        \item[\dots]
+      \end{itemize}
+    \item[\textbf{7}] \textbf{Datenstrukturen}
+  \end{itemize}
+  \vspace*{-1cm}
+
+\end{frame}
+
+\setcounter{section}{4}
+\section{Algorithmen}
+\setcounter{subsection}{2}
+\subsection{Aufwandsabschätzungen \protect\color{gray}-- Komplexitätsanalyse}
+
+\begin{frame}
+
+  \newcommand{\w}{\hspace*{0.75pt}}
+
+  \showsubsection
+
+  \begin{picture}(0,0)
+    \put(7.6,-0.3){%
+      \begin{minipage}[t]{5.3cm}
+%        \vspace*{-1.0cm}\includegraphics{landau-symbols.pdf}
+        \vspace*{-1.0cm}{\includegraphics{landau-symbols.pdf}} \small
+        \begin{description}\itemsep0pt\leftskip-0.5cm
+          \item[$n$:] Eingabedaten
+          \item[$g(n)$:] Rechenzeit
+        \end{description}
+      \end{minipage}}
+  \end{picture}
+
+  \vspace*{-1.5\bigskipamount}
+
+  \begin{itemize}
+    \item
+      Türme von Hanoi: $\mathcal{O}(2^n)$
+%      \begin{onlyenv}<1>
+%        \par\medskip
+%        Für jede zusätzliche Scheibe\\verdoppelt sich die Rechenzeit!
+%        % 32.712 * 2^32 / 3600 / 24 / 365.25 = 4452.08032888280477602859
+%        \begin{itemize}
+%          \arrowitem
+%            $\frac{32,712\,\text{s}\,\cdot\,2^{32}}{3600\,\cdot\,24\,\cdot\,365,25} \approx 4452$
+%            Jahre\\[\smallskipamount]
+%            für 64 Scheiben
+%        \end{itemize}
+%      \end{onlyenv}
+%  \end{itemize}
+%
+%  \pause
+%
+%  Beispiel: Sortieralgorithmen
+%
+%  \begin{itemize}
+    \item
+      Minimum suchen: \alt<1->{$\mathcal{O}(n)$}{$\mathcal{O}(\textbf{\color{red}?})$}
+%    \pause
+    \item
+      \dots\ mit Schummeln: $\mathcal{O}(1)$
+%      \pause
+%      \pause
+      \begin{picture}(0,0)
+        \put(-4.742,-4.3){\begin{minipage}[t]{12cm}
+          Faustregel:\\Schachtelung der Schleifen zählen\\
+          $x$ Schleifen \textarrow\ $\mathcal{O}(n\w^x)$
+          \vspace{0.5\smallskipamount}
+%          \begin{onlyenv}<1->
+%            \begin{tabbing}
+%              Verschlüsselung brechen (Primfaktorzerlegung):~\=\kill
+%              \textbf{\color{red}RSA}: Schlüsselerzeugung (Berechnung von $d\/$): 
+%                \> \color{red}$\mathcal{O}\bigl((\log n)^2\bigr)$,\\[0.5\smallskipamount]
+%              Ver- und Entschlüsselung (Exponentiation):
+%                \> \color{red}$\mathcal{O}\kern0.5pt(n\log n)$,\\[0.5\smallskipamount]
+%              Verschlüsselung brechen (Primfaktorzerlegung):
+%                \> \color{red}$\mathcal{O}\bigl(2^{\sqrt{\log n\,\cdot\,\log\log n}}\bigr)$
+%            \end{tabbing}
+%          \end{onlyenv}
+        \end{minipage}}
+      \end{picture}
+%    \pause
+    \item
+      Minimum an den Anfang tauschen,\\
+      nächstes Minimum suchen:\\
+      \textarrow\ Selectionsort: $\mathcal{O}(n\w^2)$
+%    \pause
+    \item
+      Während Minimumsuche prüfen\\und abbrechen, falls schon sortiert\\
+      \textarrow\ Bubblesort: $\mathcal{O}(n)$ bis $\mathcal{O}(n\w^2)$
+%    \pause
+    \item
+      Rekursiv sortieren\\
+      \textarrow\ Quicksort: $\mathcal{O}(n\log n)$ bis $\mathcal{O}(n\w^2)$\hfill
+  \end{itemize}
+
+\end{frame}
+
+\begin{frame}
+
+  \showsubsection
+
+  \textbf{Quicksort}
+
+  \begin{center}
+    \includegraphics[width=\textwidth]{../20190107/photo-20190107-173418.jpg}
+  \end{center}
+
+\end{frame}
+
+\begin{frame}
+
+  \newcommand{\w}{\hspace*{0.75pt}}
+
+  \showsubsection
+
+  \begin{picture}(0,0)
+    \put(7.6,-0.3){%
+      \begin{minipage}[t]{5.3cm}
+%        \vspace*{-1.0cm}\includegraphics{landau-symbols.pdf}
+        \vspace*{-1.0cm}\alt<1->{\includegraphics{landau-symbols-2.pdf}}%
+                                {\includegraphics{landau-symbols.pdf}}
+        \small
+        \begin{description}\itemsep0pt\leftskip-0.5cm
+          \item[$n$:] Eingabedaten
+          \item[$g(n)$:] Rechenzeit
+        \end{description}
+      \end{minipage}}
+  \end{picture}
+
+  \vspace*{-1.5\bigskipamount}
+
+  \begin{itemize}
+    \item
+      Türme von Hanoi: $\mathcal{O}(2^n)$
+%      \begin{onlyenv}<1>
+%        \par\medskip
+%        Für jede zusätzliche Scheibe\\verdoppelt sich die Rechenzeit!
+%        % 32.712 * 2^32 / 3600 / 24 / 365.25 = 4452.08032888280477602859
+%        \begin{itemize}
+%          \arrowitem
+%            $\frac{32,712\,\text{s}\,\cdot\,2^{32}}{3600\,\cdot\,24\,\cdot\,365,25} \approx 4452$
+%            Jahre\\[\smallskipamount]
+%            für 64 Scheiben
+%        \end{itemize}
+%      \end{onlyenv}
+%  \end{itemize}
+%
+%  \pause
+%
+%  Beispiel: Sortieralgorithmen
+%
+%  \begin{itemize}
+    \item
+      Minimum suchen: \alt<1->{$\mathcal{O}(n)$}{$\mathcal{O}(\textbf{\color{red}?})$}
+%    \pause
+    \item
+      \dots\ mit Schummeln: $\mathcal{O}(1)$
+%      \pause
+%      \pause
+      \begin{picture}(0,0)
+        \put(-4.742,-4.3){\begin{minipage}[t]{12cm}
+          Faustregel:\\Schachtelung der Schleifen zählen\\
+          $x$ Schleifen \textarrow\ $\mathcal{O}(n\w^x)$
+          \vspace{0.5\smallskipamount}
+          \begin{onlyenv}<1->
+            \begin{tabbing}
+              Verschlüsselung brechen (Primfaktorzerlegung):~\=\kill
+              \textbf{\color{red}RSA}: Schlüsselerzeugung (Berechnung von $d\/$): 
+                \> \color{red}$\mathcal{O}\bigl((\log n)^2\bigr)$,\\[0.5\smallskipamount]
+              Ver- und Entschlüsselung (Exponentiation):
+                \> \color{red}$\mathcal{O}\kern0.5pt(n\log n)$,\\[0.5\smallskipamount]
+              Verschlüsselung brechen (Primfaktorzerlegung):
+                \> \color{red}$\mathcal{O}\bigl(2^{\sqrt{\log n\,\cdot\,\log\log n}}\bigr)$
+            \end{tabbing}
+          \end{onlyenv}
+        \end{minipage}}
+      \end{picture}
+%    \pause
+    \item
+      Minimum an den Anfang tauschen,\\
+      nächstes Minimum suchen:\\
+      \textarrow\ Selectionsort: $\mathcal{O}(n\w^2)$
+%    \pause
+    \item
+      Während Minimumsuche prüfen\\und abbrechen, falls schon sortiert\\
+      \textarrow\ Bubblesort: $\mathcal{O}(n)$ bis $\mathcal{O}(n\w^2)$
+%    \pause
+    \item
+      Rekursiv sortieren\\
+      \textarrow\ Quicksort: $\mathcal{O}(n\log n)$ bis $\mathcal{O}(n\w^2)$\hfill
+  \end{itemize}
+
+\end{frame}
+
+\section{Objektorientierte Programmierung}
+\addtocounter{subsection}{-1}
+\subsection{Dynamische Speicherverwaltung}
+
+\begin{frame}[fragile]
+
+  \showsection
+  \showsubsection
+
+  \begin{itemize}
+    \item
+      Array: feste Anzahl von Elementen desselben Typs (z.\,B.\ 3 ganze Zahlen)
+    \item
+      Dynamisches Array: variable Anzahl von Elementen desselben Typs
+  \end{itemize}
+
+  \bigskip
+
+  \begin{lstlisting}
+    char *name[] = { "Anna", "Berthold", "Caesar" };
+
+    ...
+
+     name[3] = "Dieter";
+  \end{lstlisting}
+
+  \begin{picture}(0,0)
+    \color{red}
+    \put(0,0){\line(3,1){3.5}}
+    \put(0,1){\line(3,-1){3.5}}
+  \end{picture}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+  \showsection
+  \showsubsection
+
+  \bigskip
+
+  \begin{lstlisting}
+    #include <stdlib.h>
+
+    ...
+
+      char **name = malloc (3 * sizeof (char *));
+        /* Speicherplatz für 3 Zeiger anfordern */
+
+    ...
+
+      free (name)
+        /* Speicherplatz freigeben */
+
+  \end{lstlisting}
+
+\end{frame}
+
+\subsection{Konzepte und Ziele}
+
+\begin{frame}
+
+  \showsection
+  \showsubsection
+
+  \begin{itemize}
+    \item
+      Array: feste Anzahl von Elementen desselben Typs (z.\,B.\ 3 ganze Zahlen)
+    \item
+      Dynamisches Array: variable Anzahl von Elementen desselben Typs
+    \item
+      Problem: Elemente unterschiedlichen Typs
+    \item
+      Lösung: den Typ des Elements zusätzlich speichern
+  \end{itemize}
+  \begin{itemize}
+    \item
+      Funktionen, die mit dem Objekt arbeiten: \newterm{Methoden}
+    \begin{onlyenv}<1>
+      \item
+        Was die Funktion bewirkt,\\
+        hängt vom Typ des Objekts ab
+      \item
+        Realisierung über endlose \lstinline{if}-Ketten
+    \end{onlyenv}
+    \begin{onlyenv}<2>
+      \item
+        Was die Funktion bewirkt
+        \begin{picture}(0,0)
+          \color{red}
+          \put(-4.00,-0.10){\tikz{\draw[thick](0,0.25)--(3.75,-0.05);%
+                                  \draw[thick](-0.1,-0.05)--(3.75,0.3);}}
+        \end{picture}%
+        Welche Funktion aufgerufen wird,\\
+        hängt vom Typ des Objekts ab: \newterm{virtuelle Methode}
+      \item
+        Realisierung über endlose \lstinline{if}-Ketten%
+        \begin{picture}(0,0)
+          \color{red}
+          \put(-2.75,-0.10){\tikz{\draw[thick](0,0.25)--(2.5,-0.05);%
+                                  \draw[thick](-0.1,-0.05)--(2.5,0.3);}}
+          \put(1.5,-1.1){\begin{rotate}{7}\large\bf\textarrow\ kommt gleich\end{rotate}}
+        \end{picture}
+        Zeiger, die im Objekt gespeichert sind\\
+        (Genaugenommen: Tabelle von Zeigern)
+    \end{onlyenv}
+  \end{itemize}
+
+\end{frame}
+
+\begin{frame}
+
+  \showsection
+  \showsubsection
+
+  \begin{itemize}
+    \item
+      Problem: Elemente unterschiedlichen Typs
+    \item
+      Lösung: den Typ des Elements zusätzlich speichern
+    \item
+      \newterm{Methoden\/} und \newterm{virtuelle Methoden}
+  \end{itemize}
+
+  \begin{itemize}
+    \item
+      Zeiger auf verschiedene Strukturen\\
+      mit einem gemeinsamen Anteil von Datenfeldern\\
+      \textarrow\ "`verwandte"' \newterm{Objekte}, \newterm{Klassen} von Objekten
+    \item
+      Struktur, die \emph{nur\/} den gemeinsamen Anteil enthält\\
+      \textarrow\ "`Vorfahr"', \newterm{Basisklasse}, \newterm{Vererbung}
+    \item
+%      Explizite Typumwandlung eines Zeigers auf die Basisklasse\\
+%      in einen Zeiger auf die \newterm{abgeleitete Klasse}\\
+%      \textarrow\ Man kann ein Array unterschiedlicher Objekte\\
+%      \strut\phantom{\textarrow} in einer Schleife abarbeiten.\\
+      Zeiger auf die Basisklasse dürfen auf Objekte\\
+      der \newterm{abgeleiteten Klasse} zeigen\\
+      \textarrow\ \newterm{Polymorphie}
+  \end{itemize}
+
+\end{frame}
+
+\subsection{Beispiel: Zahlen und Buchstaben}
+
+\begin{frame}[fragile]
+
+  \showsection
+  \showsubsection
+
+  \begin{center}
+    \begin{minipage}{5cm}
+      \begin{lstlisting}[gobble=8]
+        ¡typedef struct
+        {
+          int type;
+        } t_base;¿
+      \end{lstlisting}
+    \end{minipage}\\[0.5cm]
+    \begin{minipage}{5cm}
+      \begin{lstlisting}[gobble=8]
+        ¡typedef struct
+        {
+          int type;
+          int content;
+        } t_integer;¿
+      \end{lstlisting}
+    \end{minipage}
+    \begin{minipage}{5cm}
+      \begin{lstlisting}[gobble=8]
+        ¡typedef struct
+        {
+          int type;
+          char *content;
+        } t_string;¿
+      \end{lstlisting}
+    \end{minipage}
+  \end{center}
+  
+\end{frame}
+
+\begin{frame}[fragile]
+  \begin{center}
+    \begin{minipage}{5cm}
+      \begin{lstlisting}[gobble=8]
+        ¡typedef struct
+        {
+          int type;
+        } t_base;¿
+      \end{lstlisting}
+    \end{minipage}\\[0.5cm]
+    \begin{minipage}{5cm}
+      \begin{lstlisting}[gobble=8]
+        ¡typedef struct
+        {
+          int type;
+          int content;
+        } t_integer;¿
+      \end{lstlisting}
+    \end{minipage}
+    \begin{minipage}{5cm}
+      \begin{lstlisting}[gobble=8]
+        ¡typedef struct
+        {
+          int type;
+          char *content;
+        } t_string;¿
+      \end{lstlisting}
+    \end{minipage}\\[0.7cm]
+    \begin{onlyenv}<1>
+      \begin{minipage}{8cm}
+        \begin{lstlisting}[gobble=10]
+          ¡t_integer i = { 1, 42 };
+          t_string s = { 2, "Hello, world!" };
+
+          t_base *object[] = { (t_base *) &i, (t_base *) &s };¿
+        \end{lstlisting}
+      \end{minipage}%
+      \begin{picture}(0,0)
+        \color{red}
+        \put(-5.4,-0.8){\mbox{$\underbrace{\rule{1.45cm}{0pt}}_{\shortstack{\strut explizite\\Typumwandlung}}$}}
+      \end{picture}
+    \end{onlyenv}
+%    \begin{onlyenv}<2>
+%      \begin{minipage}{5cm}
+%        \begin{lstlisting}[gobble=10]
+%          ¡typedef union
+%          {
+%            t_base base;
+%            t_integer integer;
+%            t_string string;
+%          } t_object;¿
+%        \end{lstlisting}
+%      \end{minipage}
+%    \end{onlyenv}
+  \end{center}
+  
+\end{frame}
+
+\subsection{Beispiel: Graphische Benutzeroberfläche (GUI)}
+
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  \scriptsize
+  \begin{lstlisting}
+    #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);
+      gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
+      GtkWidget *label = gtk_label_new ("Hello, world!");
+      gtk_container_add (GTK_CONTAINER (vbox), label);
+      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);
+      gtk_widget_show (button);
+      gtk_widget_show (label);
+      gtk_widget_show (vbox);
+      gtk_widget_show (window);
+      gtk_main ();
+      return 0;
+    }
+  \end{lstlisting}
+
+  \vspace*{-6cm}\strut\hfill
+  \includegraphics[scale=0.85]{hello-gtk.png}\\[2cm]
+  \begin{flushright}
+    \normalsize\bf Praktikumsversuch:\\
+    Objektorientiertes Zeichenprogramm
+  \end{flushright}
+  
+\end{frame}
+
+\subsection{Unions}
+
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  Variable teilen sich denselben Speicherplatz.
+
+  \medskip
+
+  \begin{minipage}[t]{3.7cm}
+    \begin{lstlisting}[gobble=6]
+      ¡typedef union
+      {
+        int8_t i;
+        uint8_t u;
+      } num8_t;¿
+    \end{lstlisting}
+  \end{minipage}%
+  \begin{minipage}[t]{4.5cm}
+    \begin{lstlisting}[gobble=6]
+      ¡int main (void)
+      {
+        num8_t test;
+        test.i = -1;
+        printf ("%d\n", test.u);
+        return 0;
+      }¿
+    \end{lstlisting}
+  \end{minipage}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  Variable teilen sich denselben Speicherplatz.
+
+  \medskip
+
+  \begin{minipage}[t]{3.7cm}
+    \begin{lstlisting}[gobble=6]
+      ¡typedef union
+      {
+        char s[8];
+        uint64_t x;
+      } num_char_t;¿
+    \end{lstlisting}
+  \end{minipage}%
+  \begin{minipage}[t]{4.5cm}
+    \begin{lstlisting}[gobble=6]
+      ¡int main (void)
+      {
+        num_char_t test = { "Hello!" };
+        printf ("%lx\n", test.x);
+        return 0;
+      }¿
+    \end{lstlisting}
+  \end{minipage}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  Variable teilen sich denselben Speicherplatz.
+
+  \medskip
+
+  \begin{minipage}[t]{3.7cm}
+    \begin{lstlisting}[gobble=6]
+      ¡typedef union
+      {
+        t_base base;
+        t_integer integer;
+        t_string string;
+      } t_object;¿
+    \end{lstlisting}
+  \end{minipage}%
+  \begin{minipage}[t]{3.0cm}
+    \begin{lstlisting}[gobble=6]
+
+      ¡typedef struct
+      {
+        int type;
+      } t_base;¿
+    \end{lstlisting}
+  \end{minipage}%
+  \begin{minipage}[t]{3.0cm}
+    \begin{lstlisting}[gobble=6]
+
+      ¡typedef struct
+      {
+        int type;
+        int content;
+      } t_integer;¿
+    \end{lstlisting}
+  \end{minipage}%
+  \begin{minipage}[t]{3.0cm}
+    \begin{lstlisting}[gobble=6]
+
+      ¡typedef struct
+      {
+        int type;
+        char *content;
+      } t_string;¿
+    \end{lstlisting}
+  \end{minipage}
+
+  \bigskip
+
+  \begin{center}
+    \begin{minipage}{8.5cm}
+      \begin{lstlisting}[gobble=8]
+        ¡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);¿
+      \end{lstlisting}
+    \end{minipage}
+  \end{center}
+
+\end{frame}
+
+\subsection{Virtuelle Methoden}
+
+\begin{frame}[fragile]
+  \showsubsection
+
+  \begin{lstlisting}
+    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);
+    }
+  \end{lstlisting}
+
+  \begin{picture}(0,0)
+    \color{red}
+    \put(9,1.7){\shortstack[l]{if-Kette:\\\strut wird unübersichtlich}}
+    \put(1,-2){\mbox{\textarrow}}
+    \put(0,-3){\mbox{Zeiger auf Funktionen}}
+  \end{picture}
+
+  \begin{lstlisting}[xleftmargin=4cm]
+    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);
+    }
+  \end{lstlisting}
+
+\end{frame}
+
+\begin{frame}[fragile]
+  \showsubsection
+
+  Zeiger auf Funktionen
+
+  \medskip
+
+  \begin{lstlisting}
+    void (* print) (t_object *this);
+  \end{lstlisting}
+  \begin{picture}(0,1.2)(0,-0.9)
+    \color{red}
+    \put(0.95,0.3){\mbox{$\underbrace{\rule{1cm}{0pt}}$}}
+    \put(0.2,-0.7){\shortstack{das, worauf print zeigt,\\ist eine Funktion}}
+  \end{picture}
+
+  \begin{itemize}
+    \item
+      Objekt enthält Zeiger auf Funktion
+      \begin{onlyenv}<1>
+        \medskip
+        \begin{lstlisting}[gobble=10]
+          typedef struct
+          {
+            void (* print) (union t_object *this);
+            int content;
+          } t_integer;
+        \end{lstlisting}
+      \end{onlyenv}
+      \begin{onlyenv}<2->
+        \vspace*{-3.5cm}  % Why doesn't a picture environment work here??? :-(
+        \begin{lstlisting}[gobble=10,xleftmargin=5.5cm]
+          typedef struct
+          {
+            void (* print) (union t_object *this);
+            int content;
+          } t_integer;
+        \end{lstlisting}
+        \vspace*{0.85cm}
+        \bigskip
+        \smallskip
+      \end{onlyenv}
+    \pause
+    \item
+      Konstruktor initialisiert diesen Zeiger
+      \begin{onlyenv}<2>
+        \medskip
+        \begin{lstlisting}[gobble=10]
+          t_object *new_integer (int i)
+          {
+            t_object *p = malloc (sizeof (t_integer));
+            p->integer.print = print_integer;
+            p->integer.content = i;
+            return p;
+          }
+        \end{lstlisting}
+        \vspace*{-2cm}
+      \end{onlyenv}
+    \pause
+    \item
+      Aufruf: "`automatisch"' die richtige Funktion
+      \begin{onlyenv}<3>
+        \medskip
+        \begin{lstlisting}[gobble=10]
+          for (int i = 0; object[i]; i++)
+            object[i]->base.print (object[i]);
+        \end{lstlisting}
+      \end{onlyenv}
+    \pause
+    \medskip
+    \item
+      in größeren Projekten:\\
+      Objekt enthält Zeiger auf Tabelle von Funktionen
+  \end{itemize}
+\end{frame}
+
+\subsection{Ausblick: C++}
+
+\begin{frame}[fragile]
+  \showsubsection
+
+  \begin{center}
+    \begin{minipage}{5cm}
+      \begin{lstlisting}[gobble=8]
+        ¡typedef struct
+        {
+          void (* print) (union t_object *this);
+        } t_base;¿
+      \end{lstlisting}
+    \end{minipage}\\[0.5cm]
+    \begin{minipage}{5.5cm}
+      \begin{lstlisting}[gobble=8]
+        ¡typedef struct
+        {
+          void (* print) (...);
+          int content;
+        } t_integer;¿
+      \end{lstlisting}
+    \end{minipage}
+    \begin{minipage}{5cm}
+      \begin{lstlisting}[gobble=8]
+        ¡typedef struct
+        {
+          void (* print) (union t_object *this);
+          char *content;
+        } t_string;¿
+      \end{lstlisting}
+    \end{minipage}
+  \end{center}
+  
+\end{frame}
+
+\begin{frame}[fragile]
+  \showsubsection
+
+  \begin{center}
+    \begin{minipage}{5cm}
+      \begin{lstlisting}[gobble=8]
+        ¡struct TBase
+        {
+          virtual void print (void);
+        };¿
+      \end{lstlisting}
+    \end{minipage}\\[0.5cm]
+    \begin{minipage}{5.5cm}
+      \begin{lstlisting}[gobble=8]
+        ¡struct TInteger: public TBase
+        {
+          virtual void print (void);
+          int content;
+        };¿
+      \end{lstlisting}
+    \end{minipage}
+    \begin{minipage}{5cm}
+      \begin{lstlisting}[gobble=8]
+        ¡struct TString: public TBase
+        {
+          virtual void print (void);
+          char *content;
+        };¿
+      \end{lstlisting}
+    \end{minipage}
+  \end{center}
+  
+\end{frame}
+
+\nosectionnonumber{\inserttitle}
+
+\begin{frame}
+
+  \shownosectionnonumber
+
+  \begin{itemize}
+    \item[\textbf{1}] \textbf{Einführung}
+      \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp.git}}}
+    \item[\textbf{2}] \textbf{Einführung in C}
+    \item[\textbf{3}] \textbf{Bibliotheken}
+    \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
+    \item[\textbf{5}] \textbf{Algorithmen}
+    \item[\textbf{6}] \textbf{Objektorientierte Programmierung}
+      \begin{itemize}
+        \item[6.0] Dynamische Speicherverwaltung
+        \color{medgreen}
+        \item[6.1] Konzepte und Ziele
+        \item[6.2] Beispiel: Zahlen und Buchstaben
+        \item[6.3] Beispiel: Graphische Benutzeroberfläche (GUI)
+        \item[6.4] Unions
+        \item[6.5] Virtuelle Methoden
+        \item[6.6] Ausblick: C++
+      \end{itemize}
+    \item[\textbf{7}] \textbf{Datenstrukturen}
+  \end{itemize}
+  \vspace*{-1cm}
+
+\end{frame}
+
+\end{document}
diff --git a/20190113/hp-uebung-20190113.pdf b/20190113/hp-uebung-20190113.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..3bdbdd519681e19b5e3134efa85b0deb6f702f9e
Binary files /dev/null and b/20190113/hp-uebung-20190113.pdf differ
diff --git a/20190113/hp-uebung-20190113.tex b/20190113/hp-uebung-20190113.tex
new file mode 100644
index 0000000000000000000000000000000000000000..aa4f3f9dfccd271c7259103c8eb96a2ab26fb411
--- /dev/null
+++ b/20190113/hp-uebung-20190113.tex
@@ -0,0 +1,220 @@
+% hp-uebung-20190113.pdf - Exercises on Low-Level Programming / Applied Computer Sciences
+% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019  Peter Gerwinski
+%
+% This document is free software: you can redistribute it and/or
+% modify it either under the terms of the Creative Commons
+% Attribution-ShareAlike 3.0 License, or under the terms of the
+% GNU General Public License as published by the Free Software
+% Foundation, either version 3 of the License, or (at your option)
+% any later version.
+%
+% This document is distributed in the hope that it will be useful,
+% but WITHOUT ANY WARRANTY; without even the implied warranty of
+% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+% GNU General Public License for more details.
+%
+% You should have received a copy of the GNU General Public License
+% along with this document.  If not, see <http://www.gnu.org/licenses/>.
+%
+% You should have received a copy of the Creative Commons
+% Attribution-ShareAlike 3.0 Unported License along with this
+% document.  If not, see <http://creativecommons.org/licenses/>.
+
+% README: Iteratorfunktionen, Objektorientierte Tier-Datenbank
+
+\documentclass[a4paper]{article}
+
+\usepackage{pgscript}
+
+\begin{document}
+
+%  \thispagestyle{empty}
+
+  \section*{Hardwarenahe Programmierung\\
+            Übungsaufgaben -- 13.\ Januar 2019}
+
+  Diese Übung enthält Punkteangaben wie in einer Klausur.
+  Um zu "`bestehen"', müssen Sie innerhalb von 90 Minuten
+  unter Verwendung ausschließlich zugelassener Hilfsmittel
+  16 Punkte (von insgesamt \totalpoints) erreichen.
+
+  \exercise{Iterationsfunktionen}
+
+  Wir betrachten das folgende Programm (\gitfile{hp}{20190113}{aufgabe-1.c}):
+
+  \begin{minipage}[t]{0.4\textwidth}
+    \begin{lstlisting}[gobble=6]
+      #include <stdio.h>
+
+      void foreach (int *a, void (*fun) (int x))
+      {
+        for (int *p = a; *p >= 0; p++)
+          fun (*p);
+      }
+
+      void even_or_odd (int x)
+      {
+        if (x % 2)
+          printf ("%d ist ungerade.\n", x);
+        else
+          printf ("%d ist gerade.\n", x);
+      }
+    \end{lstlisting}
+  \end{minipage}\hfill
+  \begin{minipage}[t]{0.52\textwidth}
+    \begin{lstlisting}[gobble=6]
+      int main (void)
+      {
+        int numbers[] = { 12, 17, 32, 1, 3, 16, 19, 18, -1 };
+        foreach (numbers, even_or_odd);
+        return 0;
+      }
+    \end{lstlisting}
+    \begin{enumerate}[\quad(a)]
+      \item
+        Was bedeutet \lstinline{void (*fun) (int x)},
+        und welchen Sinn hat seine Verwendung in der Funktion \lstinline{foreach()}?
+        \points{2}
+      \item
+        Schreiben Sie das Hauptprogramm \lstinline{main()} so um,
+        daß es unter Verwendung der Funktion \lstinline{foreach()}
+        die Summe aller positiven Zahlen in dem Array berechnet.
+        Sie dürfen dabei weitere Funktionen sowie globale Variable einführen.
+        \points{4}
+    \end{enumerate}
+  \end{minipage}
+
+  \exercise{Objektorientierte Tier-Datenbank}
+
+  Das auf der nächsten Seite in Blau dargestellte Programm (Datei: \gitfile{hp}{20190113}{aufgabe-2a.c})\\
+  soll Daten von Tieren verwalten.
+
+  Beim Compilieren erscheinen die folgende Fehlermeldungen:
+  \begin{lstlisting}[style=terminal]
+    $ ¡gcc -std=c99 -Wall -O aufgabe-2a.c -o aufgabe-2a¿
+    aufgabe-2a.c: In function 'main':
+    aufgabe-2a.c:31: error: 'animal' has no member named 'wings'
+    aufgabe-2a.c:37: error: 'animal' has no member named 'legs'
+  \end{lstlisting}
+
+  Der Programmierer nimmt die auf der nächsten Seite in Rot dargestellten Ersetzungen vor\\
+  (Datei: \gitfile{hp}{20190113}{aufgabe-2b.c}).
+  Daraufhin gelingt das Compilieren, und die Ausgabe des Programms lautet:
+  \begin{lstlisting}[style=terminal]
+    $ ¡gcc -std=c99 -Wall -O aufgabe-2b.c -o aufgabe-2b¿
+    $ ¡./aufgabe-2b¿
+    A duck has 2 legs.
+    Error in animal: cow
+  \end{lstlisting}
+
+  \begin{itemize}
+    \item[(a)]
+      Erklären Sie die o.\,a.\ Compiler-Fehlermeldungen.
+      \points{2}
+    \item[(b)]
+      Wieso verschwinden die Fehlermeldungen nach den o.\,a.\ Ersetzungen?
+      \points{3}
+    \item[(c)]
+      Erklären Sie die Ausgabe des Programms.
+      \points{5}
+    \item[(d)]
+      Beschreiben Sie -- in Worten und/oder als C-Quelltext -- einen Weg,
+      das Programm so zu berichtigen, daß es die Eingabedaten
+      (``A duck has 2 wings. A cow has 4 legs.'') korrekt speichert und ausgibt.\\
+      \points{4}
+    \item[(e)]
+      Schreiben Sie das Programm so um,
+      daß es keine expliziten Typumwandlungen mehr benötigt.\par
+      Hinweis: Verwenden Sie \lstinline{union}.
+      \points{4}
+    \item[(f)]
+      Schreiben Sie das Programm weiter um,
+      so daß es die Objektinstanzen \lstinline{duck} und \lstinline{cow}
+      dynamisch erzeugt.\par
+      Hinweis: Verwenden Sie \lstinline{malloc()} und schreiben Sie Konstruktoren.
+      \points{4}
+    \item[(g)]
+      Schreiben Sie das Programm weiter um,
+      so daß die Ausgabe nicht mehr direkt im Hauptprogramm erfolgt,
+      sondern stattdessen eine virtuelle Methode \lstinline{print()}
+      aufgerufen wird.\par
+      Hinweis: Verwenden Sie in den Objekten Zeiger auf Funktionen,
+      und initialisieren Sie diese in den Konstruktoren.
+      \points{4}
+  \end{itemize}
+
+  \begin{minipage}[t]{0.34\textwidth}
+    \begin{lstlisting}[gobble=6,xleftmargin=0pt]
+      #include <stdio.h>
+
+      #define ANIMAL     0
+      #define WITH_WINGS 1
+      #define WITH_LEGS  2
+
+      typedef struct animal
+      {
+        int type;
+        char *name;
+      } animal;
+
+      typedef struct with_wings
+      {
+        int wings;
+      } with_wings;
+
+      typedef struct with_legs
+      {
+        int legs;
+      } with_legs;
+    \end{lstlisting}
+  \end{minipage}\hfill
+  \begin{minipage}[t]{0.65\textwidth}
+    \begin{lstlisting}[gobble=6,xleftmargin=0pt]
+      int main (void)
+      {
+        animal *a[2];
+
+        animal duck;
+        a[0] = &duck;
+        a[0]->type = WITH_WINGS;
+        a[0]->name = "duck";
+        a[0]->wings = 2;
+
+        animal cow;
+        a[1] = &cow;
+        a[1]->type = WITH_LEGS;
+        a[1]->name = "cow";
+        a[1]->legs = 4;
+
+        for (int i = 0; i < 2; i++)
+          if (a[i]->type == WITH_LEGS)
+            printf ("A %s has %d legs.\n", a[i]->name,
+                    ((with_legs *) a[i])-> legs);
+          else if (a[i]->type == WITH_WINGS)
+            printf ("A %s has %d wings.\n", a[i]->name,
+                    ((with_wings *) a[i])-> wings);
+          else
+            printf ("Error in animal: %s\n", a[i]->name);
+
+        return 0;
+      }
+    \end{lstlisting}
+    \begin{picture}(0,0)
+      \color{red}
+      \put(3.7,6.207){\vector(-1,0){0.7}}
+      \put(3.8,6.207){\makebox(0,0)[l]{\lstinline[basicstyle=\color{red}]{((with_legs *) a[1])->legs = 4;}}}
+      \put(4.0,8.735){\vector(-1,0){0.7}}
+      \put(4.1,8.735){\makebox(0,0)[l]{\lstinline[basicstyle=\color{red}]{((with_wings *) a[0])->wings = 2;}}}
+    \end{picture}
+  \end{minipage}
+
+  \bigskip
+  \begin{flushright}
+    \textit{Viel Erfolg!}
+  \end{flushright}
+
+  \makeatletter
+    \immediate\write\@mainaux{\string\gdef\string\totalpoints{\arabic{points}}}
+  \makeatother
+
+\end{document}
diff --git a/20190113/landau-symbols-2.pdf b/20190113/landau-symbols-2.pdf
new file mode 120000
index 0000000000000000000000000000000000000000..6b458b6efd8e274824a6dfcaabc4b9c27d196dc4
--- /dev/null
+++ b/20190113/landau-symbols-2.pdf
@@ -0,0 +1 @@
+../common/landau-symbols-2.pdf
\ No newline at end of file
diff --git a/20190113/landau-symbols.pdf b/20190113/landau-symbols.pdf
new file mode 120000
index 0000000000000000000000000000000000000000..ca145425bf07439c680632aa0663f84be601a565
--- /dev/null
+++ b/20190113/landau-symbols.pdf
@@ -0,0 +1 @@
+../common/landau-symbols.pdf
\ No newline at end of file
diff --git a/20190113/logo-hochschule-bochum-cvh-text-v2.pdf b/20190113/logo-hochschule-bochum-cvh-text-v2.pdf
new file mode 120000
index 0000000000000000000000000000000000000000..4aa99b8f81061aca6dcaf43eed2d9efef40555f8
--- /dev/null
+++ b/20190113/logo-hochschule-bochum-cvh-text-v2.pdf
@@ -0,0 +1 @@
+../common/logo-hochschule-bochum-cvh-text-v2.pdf
\ No newline at end of file
diff --git a/20190113/logo-hochschule-bochum.pdf b/20190113/logo-hochschule-bochum.pdf
new file mode 120000
index 0000000000000000000000000000000000000000..b6b9491e370e499c9276918182cdb82cb311bcd1
--- /dev/null
+++ b/20190113/logo-hochschule-bochum.pdf
@@ -0,0 +1 @@
+../common/logo-hochschule-bochum.pdf
\ No newline at end of file
diff --git a/20190107/objects-1.c b/20190113/objects-1.c
similarity index 100%
rename from 20190107/objects-1.c
rename to 20190113/objects-1.c
diff --git a/20190107/objects-2.c b/20190113/objects-2.c
similarity index 100%
rename from 20190107/objects-2.c
rename to 20190113/objects-2.c
diff --git a/20190107/objects-3.c b/20190113/objects-3.c
similarity index 100%
rename from 20190107/objects-3.c
rename to 20190113/objects-3.c
diff --git a/20190107/objects-4.c b/20190113/objects-4.c
similarity index 100%
rename from 20190107/objects-4.c
rename to 20190113/objects-4.c
diff --git a/20190107/objects-5.c b/20190113/objects-5.c
similarity index 100%
rename from 20190107/objects-5.c
rename to 20190113/objects-5.c
diff --git a/20190107/objects-6.c b/20190113/objects-6.c
similarity index 100%
rename from 20190107/objects-6.c
rename to 20190113/objects-6.c
diff --git a/20190113/pgscript.sty b/20190113/pgscript.sty
new file mode 120000
index 0000000000000000000000000000000000000000..95c888478c99ea7fda0fd11ccf669ae91be7178b
--- /dev/null
+++ b/20190113/pgscript.sty
@@ -0,0 +1 @@
+../common/pgscript.sty
\ No newline at end of file
diff --git a/20190113/pgslides.sty b/20190113/pgslides.sty
new file mode 120000
index 0000000000000000000000000000000000000000..5be1416f4216f076aa268901f52a15d775e43f64
--- /dev/null
+++ b/20190113/pgslides.sty
@@ -0,0 +1 @@
+../common/pgslides.sty
\ No newline at end of file
diff --git a/README.md b/README.md
index 0a9b5a44c3bccc7ff90b63d7b5c2e3dd4a32dcc7..914837b5053ee54a6a495d9d0410690cf53b2593 100644
--- a/README.md
+++ b/README.md
@@ -29,6 +29,7 @@ Vortragsfolien und Beispiele:
  * [10.12.2018: volatile-Variable, Byte-Reihenfolge - Endianness, Binärdarstellung negativer Zahlen, Speicherausrichtung - Alignment](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20181210/hp-20181210.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/20181210/)
  * [17.12.2018: Rekursion, Aufwandsabschätzungen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20181217/hp-20181217.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/20181217/)
  * [07.01.2019: Aufwandsabschätzungen, dynamische Speicherverwaltung](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20190107/hp-20190107.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/20190107/)
+ * [13.01.2019: Objektorientierte Programmierung](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20190113/hp-20190113.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/20190113/)
  * [alle in 1 Datei](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/hp-slides-2018ws.pdf)
 
 Übungsaufgaben:
@@ -45,6 +46,7 @@ Vortragsfolien und Beispiele:
  * [10.12.2018: Trickprogrammierung, Thermometer-Baustein an I²C-Bus](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20181210/hp-uebung-20181210.pdf)
  * [17.12.2018: Fakultät, Lauflicht, Länge von Strings (Neuauflage)](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20181217/hp-uebung-20181217.pdf)
  * [07.01.2019: Speicherformate von Zahlen, Zeigerarithmetik](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20190107/hp-uebung-20190107.pdf)
+ * [13.01.2019: Iteratorfunktionen, Objektorientierte Tier-Datenbank](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/20190113/hp-uebung-20190113.pdf)
 
 Musterlösungen:
 ---------------
diff --git a/hp-slides-2018ws.pdf b/hp-slides-2018ws.pdf
index 7acf4f495ae2753e84b71f955be3c8a8ea2bdd18..ec91c823554d28fab6079c58e99b6d266370be71 100644
Binary files a/hp-slides-2018ws.pdf and b/hp-slides-2018ws.pdf differ
diff --git a/hp-slides-2018ws.tex b/hp-slides-2018ws.tex
index 3857cfffb7d651540dd07210f95adead692fef55..35ca4399e07c9f94e07b168983b7cc87e6a4084a 100644
--- a/hp-slides-2018ws.tex
+++ b/hp-slides-2018ws.tex
@@ -34,4 +34,6 @@
   \includepdf[pages=-]{20181217/hp-20181217.pdf}
   \pdfbookmark[1]{07.01.2019: Aufwandsabschätzungen, dynamische Speicherverwaltung}{20190107}
   \includepdf[pages=-]{20190107/hp-20190107.pdf}
+  \pdfbookmark[1]{13.01.2019: Objektorientierte Programmierung}{20190113}
+  \includepdf[pages=-]{20190113/hp-20190113.pdf}
 \end{document}