Add new section on correctness, mutation testing

00-Table_of_Contents.md

@@ -7,8 +7,9 @@
  6. [Considering Portability](06-Considering_Portability.md)
  7. [Considering Threadability](07-Considering_Threadability.md)
  8. [Considering Performance](08-Considering_Performance.md)
- 9. [Enable Scripting](09-Enable_Scripting.md)
- 10. [Further Reading](10-Further_Reading.md)
- 11. [Final Thoughts](11-Final_Thoughts.md)
+ 9. [Considering Correctness](09-Considering_Correctness.md)
+ 10. [Enable Scripting](10-Enable_Scripting.md)
+ 11. [Further Reading](11-Further_Reading.md)
+ 12. [Final Thoughts](12-Final_Thoughts.md)
 
 

02-Use_the_Tools_Available.md

@@ -303,6 +303,15 @@ Both of these tools use coverage reporting to find new code execution paths and
  * [LibFuzzer](http://llvm.org/docs/LibFuzzer.html)
  * [KLEE](http://klee.github.io/) - Can be used to fuzz individual functions
 
+### Mutation Testers
+
+These tools take code executed during unit test runs and mutate the executed code. If the test continues to pass with a mutation in place, then there is likely a flawed test in your suite.
+
+ * [Dextool Mutate](https://github.com/joakim-brannstrom/dextool/tree/master/plugin/mutate)
+ * [MuCPP](https://neptuno.uca.es/redmine/projects/mucpp-mutation-tool/wiki)
+ * [mull](https://github.com/mull-project/mull)
+ * [CCMutator](https://github.com/markus-kusano/CCMutator)
+
 ### Control Flow Guard
 
 MSVC's [Control Flow Guard](https://msdn.microsoft.com/en-us/library/windows/desktop/mt637065%28v=vs.85%29.aspx?f=255&MSPPError=-2147217396) adds high performance runtime security checks.

08-Considering_Performance.md

@@ -33,6 +33,8 @@ template<typename T> class MyTemplatedType;
 
 This is a proactive approach to reduce compilation time and rebuilding dependencies.
 
+*Note: forward declaration does prevent more inlining and optimizations. It's recommended to use Link Time Optimization or Link Time Code Generation for release builds.*
+
 ### Avoid Unnecessary Template Instantiations
 
 Templates are not free to instantiate. Instantiating many templates, or templates with more code than necessary increases compiled code size and build time.

09-Considering_Correctness.md

@@ -0,0 +1,30 @@
+# Considering Correctness
+
+## Avoid Typeless Interfaces
+
+
+Bad Idea:
+
+```cpp
+std::string find_file(const std::string &base, const std::string &pattern);
+```
+
+Better Idea:
+
+```cpp
+std::filesystem::path find_file(const std::filesystem::path &base, const std::regex &pattern);
+```
+
+The above is better but still suffers from having implicit conversions from `std::string` to `std::filesystem::path` and back.
+
+Consider using a typesafe library like
+
+ * https://foonathan.net/type_safe/
+ * https://github.com/rollbear/strong_type
+
+Note that stronger typing can also allow for more compiler optimizations.
+
+
+* [Sorting in C vs C++](Sorting in C vs C++.pdf)
+
+

SUMMARY.md

@@ -8,7 +8,8 @@
 * [Considering Portability](06-Considering_Portability.md)
 * [Considering Threadability](07-Considering_Threadability.md)
 * [Considering Performance](08-Considering_Performance.md)
-* [Enable Scripting](09-Enable_Scripting.md)
-* [Further Reading](10-Further_Reading.md)
-* [Final Thoughts](11-Final_Thoughts.md)
+* [Considering Correctness](09-Considering_Performance.md)
+* [Enable Scripting](10-Enable_Scripting.md)
+* [Further Reading](11-Further_Reading.md)
+* [Final Thoughts](12-Final_Thoughts.md)