Add TOC

Author: millengustavo

clean-code/notes.md

@@ -6,6 +6,81 @@ Author: Robert C. Martin
 
 ![clean_code](clean_code.jpeg)
 
+- [Clean Code: A Handbook of Agile Software Craftsmanship](#clean-code-a-handbook-of-agile-software-craftsmanship)
+- [Ch1. Clean Code](#ch1-clean-code)
+  - [Reading vs. Writing](#reading-vs-writing)
+- [Ch2. Meaningful Names](#ch2-meaningful-names)
+  - [Use intention-revealing names](#use-intention-revealing-names)
+  - [Avoid disinformation](#avoid-disinformation)
+  - [Make meaningful distinctions](#make-meaningful-distinctions)
+  - [Use pronounceable names](#use-pronounceable-names)
+  - [Use searchable names](#use-searchable-names)
+  - [Avoid encodings](#avoid-encodings)
+  - [Avoid mental mapping](#avoid-mental-mapping)
+  - [Class names](#class-names)
+  - [Method names](#method-names)
+  - [Don't be cute](#dont-be-cute)
+  - [Pick one word per concept](#pick-one-word-per-concept)
+  - [Don't pun](#dont-pun)
+  - [Use solution domain names](#use-solution-domain-names)
+  - [Use problem domain names](#use-problem-domain-names)
+  - [Add meaningful context](#add-meaningful-context)
+  - [Don't add gratuitous context](#dont-add-gratuitous-context)
+- [Ch3. Functions](#ch3-functions)
+  - [Small](#small)
+    - [Blocks and Indenting](#blocks-and-indenting)
+  - [Do one thing](#do-one-thing)
+  - [One level of abstraction per function](#one-level-of-abstraction-per-function)
+    - [The Stepdown rule](#the-stepdown-rule)
+  - [Use descriptive names](#use-descriptive-names)
+  - [Function arguments](#function-arguments)
+  - [How do you write functions like this?](#how-do-you-write-functions-like-this)
+- [Ch4. Comments](#ch4-comments)
+- [Ch5. Formatting](#ch5-formatting)
+  - [The newspaper metaphor](#the-newspaper-metaphor)
+  - [Vertical formatting](#vertical-formatting)
+  - [Horizontal formatting](#horizontal-formatting)
+- [Ch6. Objects and Data Structures](#ch6-objects-and-data-structures)
+  - [Data/Object anti-symmetry](#dataobject-anti-symmetry)
+  - [Data transfer objects (DTO)](#data-transfer-objects-dto)
+    - [Active records](#active-records)
+  - [Objects](#objects)
+  - [Data Structures](#data-structures)
+- [Ch7. Error Handling](#ch7-error-handling)
+  - [Write your `Try-Catch-Finally` statement first](#write-your-try-catch-finally-statement-first)
+  - [Provide context with exceptions](#provide-context-with-exceptions)
+  - [Define the normal flow](#define-the-normal-flow)
+- [Ch8. Boundaries](#ch8-boundaries)
+- [Ch9. Unit Tests](#ch9-unit-tests)
+  - [The three laws of TDD](#the-three-laws-of-tdd)
+  - [Keeping tests clean](#keeping-tests-clean)
+  - [Clean tests](#clean-tests)
+  - [F.I.R.S.T.](#first)
+- [Ch10. Classes](#ch10-classes)
+  - [The Single Responsibility Principle](#the-single-responsibility-principle)
+  - [Cohesion](#cohesion)
+  - [Organizing for change](#organizing-for-change)
+- [Ch11. Systems](#ch11-systems)
+  - [Separate constructing a system from using it](#separate-constructing-a-system-from-using-it)
+  - [Separation of main](#separation-of-main)
+    - [Factories](#factories)
+    - [Dependency injection (DI)](#dependency-injection-di)
+  - [Scaling up](#scaling-up)
+  - [Test drive the system architecture](#test-drive-the-system-architecture)
+  - [Optimize decision making](#optimize-decision-making)
+- [Ch12. Emergence](#ch12-emergence)
+  - [Simple design rule 1: runs all the tests](#simple-design-rule-1-runs-all-the-tests)
+  - [Simple design rule 2-4: refactoring](#simple-design-rule-2-4-refactoring)
+    - [No duplication](#no-duplication)
+    - [Expressive](#expressive)
+    - [Minimal classes and methods](#minimal-classes-and-methods)
+- [Ch13. Concurrency](#ch13-concurrency)
+  - [Why concurrency?](#why-concurrency)
+  - [Myths and misconceptions](#myths-and-misconceptions)
+  - [Concurrency defense principles](#concurrency-defense-principles)
+    - [Know your execution models](#know-your-execution-models)
+    - [Others](#others)
+
 # Ch1. Clean Code
 > "Most managers want good code, even when they are obsessing about the schedule (...) It's *your* job to defend the code with equal passion"
 
@@ -394,5 +469,3 @@ For each few lines of code we add, we pause and reflect on the new design
 - Run your threaded code on all target platforms early and often
 
 > Code that is simple to follow can become nightmarish when multiple threads and shared data get into the mix -> you need to write clean code with rigor or else face subtle and infrequent failures
-
-# Ch14. Successive Refinement