part3.tex

\documentclass[aspectratio=169]{beamer}

\usepackage[utf8]{inputenc}
\usepackage{soul}
\usepackage{pdfpcnotes}
\usepackage{listings}
\usepackage{tikz}
\usepackage{booktabs}
\usepackage{minted}
\usepackage[ngerman]{babel}

\usetheme{Hannover}
\usecolortheme{dove}

\AtBeginSection[]{
  \begin{frame}
  \vfill
  \centering
  \begin{beamercolorbox}[sep=8pt,center,shadow=true,rounded=true]{title}
    \usebeamerfont{title}\insertsectionhead\par%
  \end{beamercolorbox}
  \vfill
  \end{frame}
}

\lstset{language=C++,
                basicstyle=\ttfamily,
                keywordstyle=\color{blue}\ttfamily,
                stringstyle=\color{red}\ttfamily,
                commentstyle=\color{purple}\ttfamily,
                morecomment=[l][\color{magenta}]{\#}
}


\title{Eine Einführung in modernes C++}
\subtitle{Teil 3 -- Unittest, Tools und best practices}
\author{Paul Nykiel}
\date{\today}

\begin{document}
\maketitle

\frame{
    \pnote{Sofort Fragen!}
    \pnote{Feedback erwünscht}
    \tableofcontents
}

\section{Unittests}
\begin{frame}
    \frametitle{Was sind Unittests?}
    \begin{itemize}
        \item Möglichst kleine Komponenten des Codes testen (z.B. einzelne Funktion/Klasse)
            \pnote{Auf dieser Ebene noch möglich Korrektheit zu bestätigen}
            \pause
        \item Nicht komplette Codebase notwendig
            \pnote{z.B. kein ADTF, Edgecases müssen nicht in echter Welt konstruiert werden}
            \pause
        \item Restlicher Code kann auf Korrektheit vertrauen
            \pnote{Vertrauen auf Model, selbst bei Änderungen} 
            \pause
        \item Vorgehen: Festdefinierte Eingabe und daraus resultierende Ausgabe
            \pnote{Entwickler definiert Eingabe und was resultat sein muss}
    \end{itemize}
\end{frame}

\begin{frame}
    \frametitle{Google Test - Einführung}
    \begin{itemize}
        \item Tests von einem Modul werden in einer Testsuite zusammengefasst
            \pnote{D.h. eine Testsuite für Funktion A, eine für Funktion B}
            \pause
        \item Innerhalb einer Testsuite können beliebig viele Tests angelegt werden
            \pnote{Pro Test ein Name}
            \pause
        \item Jeder Test sollte genau eine Funktionalität prüfen
            \pnote{Dann kann sofort erkannt werden was nicht funktioniert, Tests bleiben kompakt}
            \pause
        \item Bedingungen mit Makros testen
            \pnote{Z.B. Gleichheit, größer, keine Exception...}
    \end{itemize}
\end{frame}

\begin{frame}
    \frametitle{Google Test - Funktionen}
    \lstinputlisting{examples/slides/gtest1.cpp}
    \pnote{Diverseste Bedinungen, z.B. auch Float, integration in CLion}
\end{frame}

\begin{frame}
    \frametitle{Google Test - Klassen}
    \lstinputlisting{examples/slides/gtest2.cpp}
    \pnote{Diverseste Bedinungen, z.B. auch Float, integration in CLion}
\end{frame}

\section{Tools}
\begin{frame}
    \Huge{Demo: Debugger}
    \pnote{Einfach Average Implementierung, Breakpoints und Variablen zeigen, Hinweis: auch bei Abstürzen}
\end{frame}

\begin{frame}
    \Huge{Demo: Valgrind}
    \pnote{Einfachen Memory Leak bauen, vllt. Use After Free}
\end{frame}

\begin{frame}
    \Huge{Demo: clang-tidy}
    \pnote{Vorheriges Beispiel: Warnings anzeigen, und fixen}
\end{frame}

\section{Best Practices}
\pnote{Nicht aller Code der compiliert ist zwingend korrekt}
\pnote{Best Practices helfen hoffentlich korrekten Code zu schreiben}
\pnote{UB vermeiden}
\pnote{Volle Liste im Wiki}

\begin{frame}
    \frametitle{Allgemein}
    \begin{itemize}
        \item Auskommentierter Code entfernen
            \pnote{Wir haben git}
            \pause
        \item Warnings beachten
            \pnote{Warnings haben einen Grund!}
            \pause
        \item Sichtbarkeit minimieren
            \pnote{Fehlerminimierung}
            \pnote{Bsp. Member Private, Namespaces, reicht eine lokale Variable?}
            \pause
        \item Duplicate Code vermeiden
            \pnote{Macht Code unnötige Lange + schlecht wartbar}
            \pause
        \item Einzeilige \lstinline{if} klammern
            \pnote{Große Fehlerquelle, Anweisung in nächste Zeile und mit klammern}
            \pause
        \item Magic Numbers extrahieren
            \pnote{Nutzt Konstanten oder ADTF properties}
    \end{itemize}
\end{frame}

\begin{frame}
    \frametitle{Funktionen - In Parameter}
    {\Large In-Parameter: Wird von der Funktion nur gelesen}

    \vspace{1cm}

    \pause
    Für In-Parameter gilt:
    \begin{itemize}
        \item Wenn trivial zu kopieren: by-value:
            \lstinline{double sqrt(double v);}
            \pnote{Auch Referenz muss kopiert werden, Kopie kann z.B. in Reg liegen}
            \pause
        \item Für größere Objekte: als \lstinline{const}-Referenz:
            \lstinline{double getMax(const std::vector<double> &v);}
            \pnote{Keine große Kopie}
    \end{itemize}
\end{frame}

\begin{frame}
    \frametitle{Funktionen - In-Out Parameter}
    {\Large In-Out-Parameter: Wird von der Funktion gelesen und geschrieben}

    \vspace{1cm}

    \pause
    Für In-Out-Parameter gilt:
    \begin{itemize} 
        \item Als Referenz an Funktion übergeben:
            \lstinline{void removeDuplicates(std::vector<int> &v);}
            \pnote{Kein Pointer, kein Copy-Return}
    \end{itemize}
\end{frame}

\begin{frame}
    \frametitle{Funktionen - Out Parameter}
    {\Large Out-Parameter: Wird von der Funktion nur geschrieben}

    \vspace{1cm}

    \pause
    Für Out-Parameter gilt:
    \begin{itemize}
        \item Immer via \lstinline{return}
            \pnote{Muss nicht default-Konstruierbar sein}
            \pnote{Copy-Ellision Funktioniert}
    \end{itemize}
\end{frame} 

\begin{frame}
    \frametitle{Funktionen - Out Parameter}
    \begin{itemize}
        \item Aber C kann nur einen Wert auf einmal returnen? \pause \lstinline{std::tuple}, \lstinline{std::pair} oder \lstinline{struct}
            \pause
        \item \lstinline{struct} für komplexere Datentypen
            \pnote{Bei gleichen Typen sonst Fehlerquelle}
            \pause
        \item Structure Binding:
            \lstinline{auto [min, max, avg] = getMinMaxAvg(list);}
            \pnote{Für Pair, Tuple und Struct}
            \pause
        \item Für Werte die in manchen Fällen nicht existieren: \lstinline{std::optional}.
            \lstinputlisting{examples/slides/optional.cpp}
    \end{itemize}
\end{frame}

\begin{frame}
    \frametitle{C-Konstrukte}
    \begin{itemize}
        \item Referenzen bzw. Smart-Pointer statt Raw-Pointer
            \pnote{Ownership nicht klar, Leaks}
            \pause
        \item \lstinline{enum class} statt \lstinline{enum}
            \pnote{Scope, kein implizitier Cast}
            \pause
        \item \lstinline{std::array} und \lstinline{std::vector} statt C-Style Arrays (\lstinline{int arr[10]};)
            \pnote{Kein impliziter Decay, Längeninformation, Pointer mit .data()}
            \pause
        \item (Template-) Funktionen statt Makros
            \pnote{Siehe Wiki für mehr Beispiele}
    \end{itemize}
\end{frame}

\begin{frame}
    \frametitle{Header}
    \begin{itemize}
        \item Header immer mit Include-Guards schützen
            \lstinputlisting{examples/slides/includeguards.cpp}
            \pnote{verhindert mehrfaches inkludieren in selber TU}
        \item Alle verwendeten Header inkludieren
            \pnote{Code kann in einem Context compilieren, in einem anderen nicht}
            \pause
        \item Code in einer \lstinline{.cpp} Datei implementieren, nicht im Header
            \pnote{Sonst längere Buildzeiten, Linkerprobleme}
    \end{itemize}            
\end{frame}

\section{Abschluss}
\begin{frame}
    \frametitle{Was fehlt?}
    \begin{itemize}
        \item R-Value Referenzen, forward/universal Referenzen
            \pnote{Neue Form von Referenz (ab C++11), primär benötigt wenn nicht triviale Speicherverwaltung}
            \pause
        \item Move
            \pnote{Speicher von einer Klasse an eine andere Übergeben, z.B. return, per default da, sonst wenn nicht triviale Speicherverwaltung}
            \pause
        \item Destruktor und Copy / Move Konstruktor
            \pnote{Wird per default angelegt, muss nur angelegt werden wenn nicht trivialer Speicher verwaltet wird}
            \pause
        \item Operatorenüberladung
            \pnote{Nur spezielle Member Funktionen, einfach!}
            \pause
        \item Friend Definition
            \pnote{Wird selten benötigt, einfach einzulesen}
            \pause
        \item Meta-Programming
            \pnote{Touring-vollständige Sprache zur CompileTime, type\_traits, bringt zwar Vorteile aber nicht notwendig}
    \end{itemize}
\end{frame}

\begin{frame}
    \frametitle{Mehr Informationen}
    \begin{itemize}
        \item \url{en.cppreference.com}
            \pnote{Dokumentation der Sprache und STL, deutsche Version ist Shit}
            \pause
        \item \url{github.com/isocpp/CppCoreGuidelines}
            \pnote{Gut für Designentscheidungen}
            \pause
        \item \url{godbolt.org}
            \pnote{Was erzeugt der Compiler für Code auf unterschiedlichen Plattformen, eher als Spielzeug}
            \pause
        \item \url{git.spatz.wtf/spatzenhirn/cppcmakeintro}
            \pnote{Dieser Vortrag}
            \pause
        \item Scott Meyers: Effective Modern C++
            \pnote{Gutes Buch, deutliche Vertiefung}
    \end{itemize}
\end{frame}

\section{Praxis}
\begin{frame}
    \frametitle{Praxis}
    \begin{itemize}
        \item Schreibt Unittests für den Huffman Encoder
            \pause
        \item Untersucht das Verhalten: meldet Valgrind Probleme? meldet clang-tidy welche?
            \pause
        \item Lest euch die Code-Richtlinien (\url{https://git.spatz.wtf/spatzenhirn/wiki/-/wikis/Software/Cup2021/CodeRichtlinien}) durch und überprüft ob euer Code die Richtlinien erfüllt.
    \end{itemize}
\end{frame}


\end{document}