Final changes to readme and text

Author: niosus

lectures/error_handling.md

@@ -2,7 +2,7 @@
 **Error Handling in C++**
 
 <p align="center">
-  <a href="https://youtu.be/dummy_link"><img src="https://img.youtube.com/vi/dummy_link/maxresdefault.jpg" alt="Video Thumbnail" align="right" width=50% style="margin: 0.5rem"></a>
+  <a href="https://youtu.be/6DqX8OJKM1g"><img src="https://img.youtube.com/vi/6DqX8OJKM1g/maxresdefault.jpg" alt="Video Thumbnail" align="right" width=50% style="margin: 0.5rem"></a>
 </p>
 
 - [Disclaimer](#disclaimer)
@@ -45,10 +45,6 @@ So get a coffee and buckle up! There is a lot to cover and quite some nuance in
 
 Ah, and I can already smell the torches and hear the scraping of the pitchforks that people will inevitably bring to punish me for all the controversial statements I am about to make! What can go wrong, eh?
 
-<!-- Add a video from shreck?
-Link: https://www.youtube.com/watch?v=Waa9UqVP4KI
--->
-
 # Disclaimer
 
 Jokes aside, this is definitely *not* a one-size-fits-all topic. C++ is huge, powerful, and used across every domain imaginable for a long-long time.
@@ -63,8 +59,6 @@ However, I believe that what we talk about today fits many setups with minimal a
 
 Now, back to error handling. -->
 
-<!-- TODO: Film the camera that films me, slowly zooming in. -->
-
 # What Do We Mean by “Error”?
 
 Before we go into how to handle errors, however, let’s clarify what we mean when we think about an "error" in programming.
@@ -227,7 +221,7 @@ Budget: 10
 Reference numbers: 42    49      23
 Player numbers:    10    40      24
 Please enter number to change: 40
-Please provide a a new value: 49
+Please provide a new value: 50
 Budget: 2
 Reference numbers: 50    49      23
 Player numbers:    10    40      24
@@ -341,7 +335,7 @@ If we run our example now, we will get a crash as soon as we call the `ChangePla
 F0000 00:00:1750605447.566908       1 example.cpp:44] Check failed: change_entry.index < player_numbers_.size() (40 vs. 3)
 ```
 
-To the degree of my knowledge, using `CHECK`-like macros to check pre-conditions of functions is widely considered a good practice. These `CHECK`s can be violated either due to a bug in our program or due to some undefined behavior just like in our example from earlier.
+To the degree of my knowledge, using `CHECK`-like macros to check pre-conditions of functions is [widely considered a good practice](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#i6-prefer-expects-for-expressing-preconditions). These `CHECK`s can be violated either due to a bug in our program or due to some undefined behavior just like in our example from earlier.
 
 One concern that people have when thinking of using the `CHECK` macros is performance as these checks stay in the production code we ship and do cost some little time when our program runs.
 
@@ -428,8 +422,6 @@ c++ -std=c++17 -DNDEBUG -o comparison_game comparison_game.cpp
 
 Running our game *now* and providing a wrong input index leads to the same undefined behavior we observed before as all of the assertions were compiled out. Not great, right? What makes it even less great is that many people just don't know that `asserts` get disabled like that and are sure that they are protected, while they really are not!
 
-<!-- Get the UB kick assert's ass, and me pushing the UB away -->
-
 And `CHECK` does not have these flaws.
 
 ### Complete the `Game` class yourself

readme.md

@@ -721,6 +721,47 @@ Headers with classes
 ----------------------------------------------------------
 </details>
 
+<details>
+<summary>Error handling in C++</summary>
+
+----------------------------------------------------------
+[![Video thumbnail](https://img.youtube.com/vi/6DqX8OJKM1g/maxresdefault.jpg)](https://youtu.be/6DqX8OJKM1g)
+
+- [Disclaimer](#disclaimer)
+- [What Do We Mean by “Error”?](lectures/error_handling.md#what-do-we-mean-by-error)
+- [Setting up the example: **a comparison game**](lectures/error_handling.md#setting-up-the-example-a-comparison-game)
+  - [Rules of the game](lectures/error_handling.md#rules-of-the-game)
+  - [Initial code of the game](lectures/error_handling.md#initial-code-of-the-game)
+- [Unrecoverable errors: **fail early**](lectures/error_handling.md#unrecoverable-errors-fail-early)
+  - [Our first unrecoverable error encounter](lectures/error_handling.md#our-first-unrecoverable-error-encounter)
+  - [How to deal with unrecoverable errors](lectures/error_handling.md#how-to-deal-with-unrecoverable-errors)
+    - [Catch them as early as possible](lectures/error_handling.md#catch-them-as-early-as-possible)
+    - [Use `CHECK` macro to fail early](lectures/error_handling.md#use-check-macro-to-fail-early)
+    - [Don't use `assert`](lectures/error_handling.md#dont-use-assert)
+    - [Complete the `Game` class yourself](lectures/error_handling.md#complete-the-game-class-yourself)
+  - [How to minimize number of unrecoverable errors](lectures/error_handling.md#how-to-minimize-number-of-unrecoverable-errors)
+- [Recoverable errors: **handle and proceed**](lectures/error_handling.md#recoverable-errors-handle-and-proceed)
+  - [Exceptions](lectures/error_handling.md#exceptions)
+    - [How to use exceptions](lectures/error_handling.md#how-to-use-exceptions)
+    - [A case for exceptions for both "recoverable" and "unrecoverable" errors](lectures/error_handling.md#a-case-for-exceptions-for-both-recoverable-and-unrecoverable-errors)
+    - [Why we might not want to use exceptions](lectures/error_handling.md#why-we-might-not-want-to-use-exceptions)
+      - [Exceptions are (sometimes) expensive](lectures/error_handling.md#exceptions-are-sometimes-expensive)
+      - [Exceptions hide the error path](lectures/error_handling.md#exceptions-hide-the-error-path)
+      - [Exceptions are banned in many code bases](lectures/error_handling.md#exceptions-are-banned-in-many-code-bases)
+  - [Returning errors explicitly can work better if done well](lectures/error_handling.md#returning-errors-explicitly-can-work-better-if-done-well)
+    - [Returning a value indicating error does not always work 😱](lectures/error_handling.md#returning-a-value-indicating-error-does-not-always-work-)
+    - [Returning an error code breaks "pure functions" 😱](lectures/error_handling.md#returning-an-error-code-breaks-pure-functions-)
+    - [Using `std::optional`: **a better way**](lectures/error_handling.md#using-stdoptional-a-better-way)
+    - [Using `std::expected`: **add context**](lectures/error_handling.md#using-stdexpected-add-context)
+  - [Performance Considerations for `std::optional` and `std::expected`](lectures/error_handling.md#performance-considerations-for-stdoptional-and-stdexpected)
+    - [Error type size matters](lectures/error_handling.md#error-type-size-matters)
+    - [Return value optimization with `std::optional` and `std::expected`](lectures/error_handling.md#return-value-optimization-with-stdoptional-and-stdexpected)
+  - [Summary](lectures/error_handling.md#summary)
+  - [Other use of `std::optional`](lectures/error_handling.md#other-use-of-stdoptional)
+
+----------------------------------------------------------
+</details>
+
 ## PS
 
 ### Most of the code snippets are validated automatically