bernhardmgruber
diff --git a/‎talk/morelanguage/constness.tex
Lines changed: 16 additions & 18 deletions b/‎talk/morelanguage/constness.tex
Lines changed: 16 additions & 18 deletions
diff --git a/‎talk/morelanguage/exceptions.tex
Lines changed: 53 additions & 43 deletions b/‎talk/morelanguage/exceptions.tex
Lines changed: 53 additions & 43 deletions
diff --git a/‎talk/morelanguage/lambda.tex
Lines changed: 2 additions & 2 deletions b/‎talk/morelanguage/lambda.tex
Lines changed: 2 additions & 2 deletions
@@ -4,46 +4,44 @@
   \frametitlecpp[98]{Constness}
   \begin{block}{The \texttt{const} keyword}
     \begin{itemize}
-    \item indicate that the element to the left is constant
+    \item indicates that the element to the left is constant
+    \begin{itemize}
+      \item when nothing on the left, applies to the right
+    \end{itemize}
     \item this element won't be modifiable in the future
     \item this is all checked at compile time
     \end{itemize}
   \end{block}
   \begin{cppcode}
-    // standard syntax
     int const i = 6;
+    const int i = 6; // equivalent
 
     // error : i is constant
     i = 5;
 
-    // also ok, when nothing on the left,
-    // const applies to the element on the right
-    const int j = 6;
+    auto const j = i; // works with auto
   \end{cppcode}
 \end{frame}
 
 \begin{frame}[fragile]
   \frametitlecpp[98]{Constness and pointers}
-  \scriptsize
+  \small
   \begin{cppcode}
-    // pointer to a constant integer
     int a = 1, b = 2;
-    int const *i = &a;
+
+    int const *i = &a; // pointer to const int
     *i = 5; // error, int is const
     i = &b; // ok, pointer is not const
 
-    // constant pointer to an integer
-    int * const j = &a;
+    int * const j = &a; // const pointer to int
     *j = 5; // ok, value can be changed
     j = &b; // error, pointer is const
 
-    // constant pointer to a constant integer
-    int const * const k = &a;
+    int const * const k = &a; // const pointer to const int
     *k = 5; // error, value is const
     k = &b; // error, pointer is const
 
-    // const reference
-    int const & l = a;
+    int const & l = a; // reference to const int
     l = b; // error, reference is const
 
     int const & const l = a; // compile error
@@ -54,17 +52,17 @@
   \frametitlecpp[98]{Member function constness}
   \begin{block}{The \texttt{const} keyword for member functions}
     \begin{itemize}
-    \item indicate that the function does not modify the object
+    \item indicates that the function does not modify the object
     \item in other words, \cppinline{this} is a pointer to a constant object
     \end{itemize}
   \end{block}
   \begin{cppcode}
     struct Example {
       void foo() const {
         // type of 'this' is 'Example const*'
-        m_member = 0; // Error: member function is const
+        data = 0; // Error: member function is const
       }
-      int m_member;
+      int data;
     };
   \end{cppcode}
 \end{frame}
@@ -74,7 +72,7 @@
   \begin{block}{Constness is part of the type}
     \begin{itemize}
     \item \cppinline{T const} and \cppinline{T} are different types
-    \item however, \cppinline{T} is automatically cast to \cppinline{T const} when needed
+    \item however: \cppinline{T} is automatically cast to \cppinline{T const} when needed
     \end{itemize}
   \end{block}
   \begin{cppcode}
 
@@ -2,7 +2,7 @@
 
 \begin{frame}[fragile]
   \frametitlecpp[98]{Exceptions}
-  \begin{block}{The concept}
+  \begin{block}{Purpose}
     \begin{itemize}
       \item to handle \textit{exceptional} events that happen rarely
       \item and cleanly jump to a place where the error can be handled
@@ -30,7 +30,7 @@
       }
     \end{cppcode*}
     \columnbreak
-    \begin{cppcode*}{fontsize=\small,gobble=2}
+    \begin{cppcode*}{fontsize=\small,firstnumber=7,gobble=2}
       void process_data(file &f) {
         ...
         if (i >= buffer.size())
@@ -46,32 +46,61 @@
   \begin{block}{Throwing exceptions}
     \begin{itemize}
       \item objects of any type can be thrown (even e.g.\ \cppinline{int})
-      \begin{itemize}
-        \item prefer standard exception classes
-      \end{itemize}
-      \item throw objects by value
     \end{itemize}
   \end{block}
+  \begin{goodpractice}{Throwing exceptions}
+    \begin{itemize}
+      \item prefer throwing standard exception classes
+      \item throw objects by value
+    \end{itemize}
+  \end{goodpractice}
+  \small
   \begin{cppcode}
+    #include <stdexcept>
     void process_data(file& f) {
       if (!f.open())
         throw std::invalid_argument{"stream is not open"};
-
       auto header = read_line(f); // may throw an IO error
       if (!header.starts_with("BEGIN"))
         throw std::runtime_error{"invalid file content"};
-
       std::string body(f.size()); // may throw std::bad_alloc
       ...
     }
   \end{cppcode}
 \end{frame}
 
+\begin{frame}[fragile]
+  \frametitlecpp[98]{Exceptions}
+  \begin{block}{Standard exceptions}
+    \begin{itemize}
+      \item \cppinline{std::exception}, defined in header \cppinline{<exception>}
+      \begin{itemize}
+        \item Base class of all standard exceptions
+        \item Get error message: \cppinline{virtual const char* what() const;}
+        \item Please derive your own exception classes from this one
+      \end{itemize}
+      \item From \cppinline{<stdexcept>}:
+      \begin{itemize}
+        \item \cppinline{std::runtime_error}, \cppinline{std::logic_error}, \cppinline{std::out_of_range}, \cppinline{std::invalid_argument}, ...
+        \item Store a string: \cppinline{throw std::runtime_error{"msg"}}
+        \item You should use these the most
+      \end{itemize}
+      \item \cppinline{std::bad_alloc}, defined in header \cppinline{<new>}
+      \begin{itemize}
+        \item Thrown by standard allocation functions (e.g.\ \cppinline{new})
+        \item Signals failure to allocate
+        \item Carries no message
+      \end{itemize}
+      \item ...
+    \end{itemize}
+  \end{block}
+\end{frame}
+
 \begin{frame}[fragile]
   \frametitlecpp[98]{Exceptions}
   \begin{block}{Catching exceptions}
     \begin{itemize}
-      \item a catch clause catches an exception of the same or derived type
+      \item a catch clause catches exceptions of the same or derived type
       \item multiple catch clauses will be matched in order
       \item if no catch clause matches, the exception propagates
       \item if the exception is never caught, \cppinline{std::terminate} is called
@@ -86,13 +115,18 @@
       std::cerr << "Failed to process file: " << e.what();
     }
   \end{cppcode}
+  \begin{goodpractice}{Catching exceptions}
+    \begin{itemize}
+      \item Catch exceptions by const reference
+    \end{itemize}
+  \end{goodpractice}
 \end{frame}
 
 \begin{frame}[fragile]
   \frametitlecpp[98]{Exceptions}
   \begin{block}{Rethrowing exceptions}
     \begin{itemize}
-      \item a caught exception can be rethrown
+      \item a caught exception can be rethrown inside the catch handler
       \item useful when we want to act on an error, but cannot handle and want to propagate it
     \end{itemize}
   \end{block}
@@ -166,45 +200,17 @@
   \end{multicols}
 \end{frame}
 
-\begin{frame}[fragile]
-  \frametitlecpp[98]{Exceptions}
-  \begin{block}{Standard exceptions}
-    \begin{itemize}
-      \item \cppinline{std::exception}, defined in header \cppinline{<exception>}
-      \begin{itemize}
-        \item Base class of all standard exceptions
-        \item Get error message: \cppinline{virtual const char* what() const;}
-        \item Please derive your own exception classes from this one
-      \end{itemize}
-      \item From \cppinline{<stdexcept>}:
-      \begin{itemize}
-        \item \cppinline{std::runtime_error}, \cppinline{std::logic_error}, \cppinline{std::out_of_range}, \cppinline{std::invalid_argument}, ...
-        \item Store a string: \cppinline{throw std::runtime_error{"msg"}}
-        \item You should use these the most
-      \end{itemize}
-      \item \cppinline{std::bad_alloc}, defined in header \cppinline{<new>}
-      \begin{itemize}
-        \item Thrown by standard allocation functions (e.g.\ \cppinline{new})
-        \item Signals failure to allocate
-        \item Carries no message
-      \end{itemize}
-      \item ...
-    \end{itemize}
-  \end{block}
-\end{frame}
-
 \begin{frame}[fragile]
   \frametitlecpp[17]{Exceptions}
   \begin{goodpractice}{Exceptions}
     \begin{itemize}
-      \item throw exceptions by value, catch them by (const) reference
       \item use exceptions for \textit{unlikely} runtime errors outside the program's control
       \begin{itemize}
         \item bad inputs, files unexpectedly not found, DB connection, \ldots
       \end{itemize}
       \item \textit{don't} use exceptions for logic errors in your code
       \begin{itemize}
-        \item consider \cppinline{assert} and tests
+        \item use \cppinline{assert} and tests
       \end{itemize}
       \item \textit{don't} use exceptions to provide alternative/skip return values
       \begin{itemize}
@@ -305,7 +311,7 @@
 
 \begin{frame}[fragile]
   \frametitlecpp[11]{noexcept specifier}
-  \begin{block}{}
+  \begin{block}{\texttt{noexcept}}
     \begin{itemize}
       \item a function with the \cppinline{noexcept} specifier states that it guarantees to not throw an exception
       \begin{cppcode*}{gobble=2,linenos=false}
@@ -314,16 +320,20 @@
       \begin{itemize}
         \item either no exceptions is thrown or they are handled internally
         \item checked at compile time
-        \item so allows the compiler to optimise around that knowledge
+        \item allows the compiler to optimize around that knowledge
       \end{itemize}
       \item a function with \cppinline{noexcept(expression)} is only \cppinline{noexcept} when \cppinline{expression} evaluates to \cppinline{true} at compile-time
       \begin{cppcode*}{gobble=2,linenos=false}
         int safe_if_8B() noexcept(sizeof(long)==8);
       \end{cppcode*}
-      \item Use \cppinline{noexcept} on leaf functions where you know the behaviour
-      \item C++11 destructors are \cppinline{noexcept} - never throw from them
     \end{itemize}
   \end{block}
+  \begin{goodpractice}{\texttt{noexcept}}
+    \begin{itemize}
+      \item Use \cppinline{noexcept} on leaf functions where you know the behavior
+      \item C++11 destructors are \cppinline{noexcept} - never throw from them
+    \end{itemize}
+  \end{goodpractice}
 \end{frame}
 
 \begin{advanced}
 
@@ -190,6 +190,8 @@
   \end{block}
 \end{frame}
 
+\begin{advanced}
+
 \begin{frame}[fragile]
   \frametitlecpp[11]{Capture list - this}
   \begin{block}{}
@@ -217,8 +219,6 @@
   Details in  \href{https://www.nextptr.com/tutorial/ta1430524603/capture-this-in-lambda-expression-timeline-of-change}{this blog post}.
 \end{frame}
 
-\begin{advanced}
-
 \begin{frame}[fragile]
   \frametitlecpp[11]{Anatomy of a lambda}
   \begin{block}{Lambdas are pure syntactic sugar - \cppinsightLink{https://cppinsights.io/s/67800da8}}