@@ -8,8 +8,9 @@
 5. [Classes](#classes)
 6. [Testing](#testing)
 7. [Concurrency](#concurrency)
-8. [Formatting](#formatting)
-9. [Comments](#comments)
+8. [Error Handling](#error-handling)
+9. [Formatting](#formatting)
+10. [Comments](#comments)
 
 ## Introduction
 ![Humorous image of software quality estimation as a count of how many expletives
@@ -507,7 +508,7 @@ function createMenu(config) {
 cancellable: true
 }, config);
 
-// config now equals: {title: "Order", body: "Bar", buttonText: "Send", cancellable: true}
+// config now equals: {title: "Foo", body: "Bar", buttonText: "Baz", cancellable: true}
 // ...
 }
 
@@ -766,7 +767,7 @@ class Airplane {
 return getMaxAltitude() - getPassengerCount();
 case 'Air Force One':
 return getMaxAltitude();
-case 'Cesna':
+case 'Cessna':
 return getMaxAltitude() - getFuelExpenditure();
 }
 }
@@ -793,7 +794,7 @@ class AirForceOne extends Airplane {
 }
 }
 
-class Cesna extends Airplane {
+class Cessna extends Airplane {
 //...
 getCruisingAltitude() {
 return getMaxAltitude() - getFuelExpenditure();
@@ -1792,6 +1793,79 @@ async function getCleanCodeArticle() {
 **[⬆ back to top](#table-of-contents)**
 
 
+## **Error Handling**
+Thrown errors are a good thing! They mean the runtime has successfully
+identified when something in your program has gone wrong and it's letting
+you know by stopping function execution on the current stack, killing the
+process (in Node), and notifying you in the console with a stack trace.
+
+### Don't ignore caught errors
+Doing nothing with a caught error doesn't give you the ability to ever fix
+or react to said error. Logging the error to the console (`console.log`)
+isn't much better as often times it can get lost in a sea of things printed
+to the console. If you wrap any bit of code in a `try/catch` it means you
+think an error may occur there and therefore you should have a plan,
+or create a code path, for when it occurs.
+
+**Bad:**
+```javascript
+try {
+functionThatMightThrow();
+} catch (error) {
+console.log(error);
+}
+```
+
+**Good:**
+```javascript
+try {
+functionThatMightThrow();
+} catch (error) {
+// One option (more noisy than console.log):
+console.error(error);
+// Another option:
+notifyUserOfError(error);
+// Another option:
+reportErrorToService(error);
+// OR do all three!
+}
+```
+
+### Don't ignore rejected promises
+For the same reason you shouldn't ignore caught errors
+from `try/catch`.
+
+**Bad:**
+```javascript
+getdata()
+.then(data => {
+functionThatMightThrow(data);
+})
+.catch(error => {
+console.log(error);
+});
+```
+
+**Good:**
+```javascript
+getdata()
+.then(data => {
+functionThatMightThrow(data);
+})
+.catch(error => {
+// One option (more noisy than console.log):
+console.error(error);
+// Another option:
+notifyUserOfError(error);
+// Another option:
+reportErrorToService(error);
+// OR do all three!
+});
+```
+
+**[⬆ back to top](#table-of-contents)**
+
+
 ## **Formatting**
 Formatting is subjective. Like many rules herein, there is no hard and fast
 rule that you must follow. The main point is DO NOT ARGUE over formatting.