updating title headers in all chapters

README.md

@@ -20,12 +20,12 @@ I want to extend a warm and deep thanks to Marc Grabanski and the entire Fronten
 
 ## Titles
 
-* ["Getting Started"](getting-started/README.md)
-* ["Scope & Closures"](scope-closures/README.md)
-* ["this & Object Prototypes"](this-object-prototypes/README.md)
-* ["Types & Grammar"](types-grammar/README.md)
-* ["Async & Performance"](async-performance/README.md)
-* ["ES:Next & Beyond"](es-next-beyond/README.md)
+* [Getting Started](getting-started/README.md)
+* [Scope & Closures](scope-closures/README.md)
+* [this & Object Prototypes](this-object-prototypes/README.md)
+* [Types & Grammar](types-grammar/README.md)
+* [Async & Performance](async-performance/README.md)
+* [ES.Next & Beyond](es-next-beyond/README.md)
 
 ## Publishing
 

async-performance/README.md

@@ -1,5 +1,9 @@
 # You Don't Know JS Yet: Async & Performance - 2nd Edition
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
 [Table of Contents](toc.md)
 
 * [Foreword](foreword.md) (by TBA)
@@ -12,4 +16,3 @@
 * [Chapter 6: Benchmarking & Tuning](ch6.md)
 * [Appendix A: Library: asynquence](apA.md)
 * [Appendix B: Advanced Async Patterns](apB.md)
-* [Appendix C: Thank You's!](apC.md)

async-performance/apA.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: Async & Performance
+# You Don't Know JS Yet: Async & Performance - 2nd Edition
 # Appendix A: *asynquence* Library
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 Chapters 1 and 2 went into quite a bit of detail about typical asynchronous programming patterns and how they're commonly solved with callbacks. But we also saw why callbacks are fatally limited in capability, which led us to Chapters 3 and 4, with Promises and generators offering a much more solid, trustable, and reason-able base to build your asynchrony on.
 
 I referenced my own asynchronous library *asynquence* (http://github.com/getify/asynquence) -- "async" + "sequence" = "asynquence" -- several times in this book, and I want to now briefly explain how it works and why its unique design is important and helpful.

async-performance/apB.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: Async & Performance
+# You Don't Know JS Yet: Async & Performance - 2nd Edition
 # Appendix B: Advanced Async Patterns
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 Appendix A introduced the *asynquence* library for sequence-oriented async flow control, primarily based on Promises and generators.
 
 Now we'll explore other advanced asynchronous patterns built on top of that existing understanding and functionality, and see how *asynquence* makes those sophisticated async techniques easy to mix and match in our programs without needing lots of separate libraries.

async-performance/ch1.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: Async & Performance
+# You Don't Know JS Yet: Async & Performance - 2nd Edition
 # Chapter 1: Asynchrony: Now & Later
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 One of the most important and yet often misunderstood parts of programming in a language like JavaScript is how to express and manipulate program behavior spread out over a period of time.
 
 This is not just about what happens from the beginning of a `for` loop to the end of a `for` loop, which of course takes *some time* (microseconds to milliseconds) to complete. It's about what happens when part of your program runs *now*, and another part of your program runs *later* -- there's a gap between *now* and *later* where your program isn't actively executing.

async-performance/ch2.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: Async & Performance
+# You Don't Know JS Yet: Async & Performance - 2nd Edition
 # Chapter 2: Callbacks
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 In Chapter 1, we explored the terminology and concepts around asynchronous programming in JavaScript. Our focus is on understanding the single-threaded (one-at-a-time) event loop queue that drives all "events" (async function invocations). We also explored various ways that concurrency patterns explain the relationships (if any!) between *simultaneously* running chains of events, or "processes" (tasks, function calls, etc.).
 
 All our examples in Chapter 1 used the function as the individual, indivisible unit of operations, whereby inside the function, statements run in predictable order (above the compiler level!), but at the function-ordering level, events (aka async function invocations) can happen in a variety of orders.

async-performance/ch3.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: Async & Performance
+# You Don't Know JS Yet: Async & Performance - 2nd Edition
 # Chapter 3: Promises
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 In Chapter 2, we identified two major categories of deficiencies with using callbacks to express program asynchrony and manage concurrency: lack of sequentiality and lack of trustability. Now that we understand the problems more intimately, it's time we turn our attention to patterns that can address them.
 
 The issue we want to address first is the *inversion of control*, the trust that is so fragilely held and so easily lost.

async-performance/ch4.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: Async & Performance
+# You Don't Know JS Yet: Async & Performance - 2nd Edition
 # Chapter 4: Generators
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 In Chapter 2, we identified two key drawbacks to expressing async flow control with callbacks:
 
 * Callback-based async doesn't fit how our brain plans out steps of a task.

async-performance/ch5.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: Async & Performance
+# You Don't Know JS Yet: Async & Performance - 2nd Edition
 # Chapter 5: Program Performance
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 This book so far has been all about how to leverage asynchrony patterns more effectively. But we haven't directly addressed why asynchrony really matters to JS. The most obvious explicit reason is **performance**.
 
 For example, if you have two Ajax requests to make, and they're independent, but you need to wait on them both to finish before doing the next task, you have two options for modeling that interaction: serial and concurrent.

async-performance/ch6.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: Async & Performance
+# You Don't Know JS Yet: Async & Performance - 2nd Edition
 # Chapter 6: Benchmarking & Tuning
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 As the first four chapters of this book were all about performance as a coding pattern (asynchrony and concurrency), and Chapter 5 was about performance at the macro program architecture level, this chapter goes after the topic of performance at the micro level, focusing on single expressions/statements.
 
 One of the most common areas of curiosity -- indeed, some developers can get quite obsessed about it -- is in analyzing and testing various options for how to write a line or chunk of code, and which one is faster.

async-performance/foreword.md

@@ -1,4 +1,6 @@
-# You Don't Know JS: Async & Performance
+# You Don't Know JS Yet: Async & Performance - 2nd Edition
 # Foreword
 
-TBA
+| NOTE: |
+| :--- |
+| Work in progress |

async-performance/toc.md

@@ -1,4 +1,8 @@
-# You Don't Know JS: Async & Performance
+# You Don't Know JS Yet: Async & Performance - 2nd Edition
+
+| NOTE: |
+| :--- |
+| Work in progress |
 
 ## Table of Contents
 
@@ -47,5 +51,3 @@
 	* Tail Call Optimization (TCO)
 * Appendix A: *asynquence* Library
 * Appendix B: Advanced Async Patterns
-* Appendix C: Acknowledgments
-

es-next-beyond/README.md

@@ -1,4 +1,8 @@
-# You Don't Know JS Yet: ES:Next & Beyond - 2nd Edition
+# You Don't Know JS Yet: ES.Next & Beyond - 2nd Edition
+
+| NOTE: |
+| :--- |
+| Work in progress |
 
 [Table of Contents](toc.md)
 
@@ -12,4 +16,4 @@
 * [Chapter 6: API Additions](ch6.md)
 * [Chapter 7: Meta Programming](ch7.md)
 * [Chapter 8: Beyond ES6](ch8.md)
-* [Appendix A: Thank You's!](apA.md)
+* [Appendix A: TODO](apA.md)

es-next-beyond/ch1.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: ES6 & Beyond
+# You Don't Know JS Yet: ES.Next & Beyond - 2nd Edition
 # Chapter 1: ES? Now & Future
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 Before you dive into this book, you should have a solid working proficiency over JavaScript up to the most recent standard (at the time of this writing), which is commonly called *ES5* (technically ES 5.1). Here, we plan to talk squarely about the upcoming *ES6*, as well as cast our vision beyond to understand how JS will evolve moving forward.
 
 If you are still looking for confidence with JavaScript, I highly recommend you read the other titles in this series first:

es-next-beyond/ch2.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: ES6 & Beyond
+# You Don't Know JS Yet: ES.Next & Beyond - 2nd Edition
 # Chapter 2: Syntax
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 If you've been writing JS for any length of time, odds are the syntax is pretty familiar to you. There are certainly many quirks, but overall it's a fairly reasonable and straightforward syntax that draws many similarities from other languages.
 
 However, ES6 adds quite a few new syntactic forms that take some getting used to. In this chapter, we'll tour through them to find out what's in store.

es-next-beyond/ch3.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: ES6 & Beyond
+# You Don't Know JS Yet: ES.Next & Beyond - 2nd Edition
 # Chapter 3: Organization
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 It's one thing to write JS code, but it's another to properly organize it. Utilizing common patterns for organization and reuse goes a long way to improving the readability and understandability of your code. Remember: code is at least as much about communicating to other developers as it is about feeding the computer instructions.
 
 ES6 has several important features that help significantly improve these patterns, including: iterators, generators, modules, and classes.

es-next-beyond/ch4.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: ES6 & Beyond
+# You Don't Know JS Yet: ES.Next & Beyond - 2nd Edition
 # Chapter 4: Async Flow Control
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 It's no secret if you've written any significant amount of JavaScript that asynchronous programming is a required skill. The primary mechanism for managing asynchrony has been the function callback.
 
 However, ES6 adds a new feature that helps address significant shortcomings in the callbacks-only approach to async: *Promises*. In addition, we can revisit generators (from the previous chapter) and see a pattern for combining the two that's a major step forward in async flow control programming in JavaScript.

es-next-beyond/ch5.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: ES6 & Beyond
+# You Don't Know JS Yet: ES.Next & Beyond - 2nd Edition
 # Chapter 5: Collections
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 Structured collection and access to data is a critical component of just about any JS program. From the beginning of the language up to this point, the array and the object have been our primary mechanism for creating data structures. Of course, many higher-level data structures have been built on top of these, as user-land libraries.
 
 As of ES6, some of the most useful (and performance-optimizing!) data structure abstractions have been added as native components of the language.

es-next-beyond/ch6.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: ES6 & Beyond
+# You Don't Know JS Yet: ES.Next & Beyond - 2nd Edition
 # Chapter 6: API Additions
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 From conversions of values to mathematic calculations, ES6 adds many static properties and methods to various built-in natives and objects to help with common tasks. In addition, instances of some of the natives have new capabilities via various new prototype methods.
 
 **Note:** Most of these features can be faithfully polyfilled. We will not dive into such details here, but check out "ES6 Shim" (https://github.com/paulmillr/es6-shim/) for standards-compliant shims/polyfills.

es-next-beyond/ch7.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: ES6 & Beyond
+# You Don't Know JS Yet: ES.Next & Beyond - 2nd Edition
 # Chapter 7: Meta Programming
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 Meta programming is programming where the operation targets the behavior of the program itself. In other words, it's programming the programming of your program. Yeah, a mouthful, huh?
 
 For example, if you probe the relationship between one object `a` and another `b` -- are they `[[Prototype]]` linked? -- using `a.isPrototypeOf(b)`, this is commonly referred to as introspection, a form of meta programming. Macros (which don't exist in JS, yet) --  where the code modifies itself at compile time -- are another obvious example of meta programming. Enumerating the keys of an object with a `for..in` loop, or checking if an object is an *instance of* a "class constructor", are other common meta programming tasks.

es-next-beyond/ch8.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: ES6 & Beyond
+# You Don't Know JS Yet: ES.Next & Beyond - 2nd Edition
 # Chapter 8: Beyond ES6
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 At the time of this writing, the final draft of ES6 (*ECMAScript 2015*) is shortly headed toward its final official vote of approval by ECMA. But even as ES6 is being finalized, the TC39 committee is already hard at work on features for ES7/2016 and beyond.
 
 As we discussed in Chapter 1, it's expected that the cadence of progress for JS is going to accelerate from updating once every several years to having an official version update once per year (hence the year-based naming). That alone is going to radically change how JS developers learn about and keep up with the language.

es-next-beyond/foreword.md

@@ -1,4 +1,6 @@
-# You Don't Know JS: ES6 & Beyond
+# You Don't Know JS Yet: ES.Next & Beyond - 2nd Edition
 # Foreword
 
-TBA
+| NOTE: |
+| :--- |
+| Work in progress |

es-next-beyond/toc.md

@@ -1,4 +1,8 @@
-# You Don't Know JS: ES6 & Beyond
+# You Don't Know JS Yet: ES.Next & Beyond
+
+| NOTE: |
+| :--- |
+| Work in progress |
 
 ## Table of Contents
 
@@ -55,4 +59,4 @@
 	* Object Properties and `...`
 	* `Array#includes(..)`
 	* SIMD
-* Appendix A: Acknowledgments
+* Appendix A: TODO

getting-started/README.md

@@ -1,10 +1,14 @@
 # You Don't Know JS Yet: Getting Started - 2nd Edition
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
 [Table of Contents](toc.md)
 
 * [Foreword](foreword.md) (by TBA)
 * [Preface](../preface.md)
 * [Chapter 1: Into Programming](ch1.md)
 * [Chapter 2: Into JavaScript](ch2.md)
-* [Chapter 3: Into YDKJS](ch3.md)
-* [Appendix A: Thank You's!](apA.md)
+* [Chapter 3: Into YDKJSJ](ch3.md)
+* [Appendix A: TODO](apA.md)

getting-started/ch1.md

@@ -1,6 +1,9 @@
 # You Don't Know JS Yet: Getting Started - 2nd Edition
 # Chapter 1: Into Programming
 
+| NOTE: |
+| :--- |
+| Work in progress |
 
 .
 

getting-started/ch2.md

@@ -1,6 +1,9 @@
 # You Don't Know JS Yet: Getting Started - 2nd Edition
 # Chapter 2: Into JavaScript
 
+| NOTE: |
+| :--- |
+| Work in progress |
 
 .
 

getting-started/ch3.md

@@ -1,5 +1,9 @@
 # You Don't Know JS Yet: Getting Started - 2nd Edition
-# Chapter 3: Into YDKJS
+# Chapter 3: Into YDKJSJ
+
+| NOTE: |
+| :--- |
+| Work in progress |
 
 .
 

getting-started/foreword.md

@@ -1,4 +1,6 @@
-# You Don't Know JS Yet: Getting Started
+# You Don't Know JS Yet: Getting Started - 2nd Edition
 # Foreword
 
-TBA
+| NOTE: |
+| :--- |
+| Work in progress |

getting-started/toc.md

@@ -32,4 +32,4 @@
 	* Types & Grammar
 	* Async & Performance
 	* ES6 & Beyond
-* Appendix A: Acknowledgments
+* Appendix A: TODO

scope-closures/README.md

@@ -1,5 +1,9 @@
 # You Don't Know JS Yet: Scope & Closures - 2nd Edition
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
 [Table of Contents](toc.md)
 
 * [Foreword](foreword.md) (by TBA)
@@ -12,4 +16,3 @@
 * [Appendix A: Dynamic Scope](apA.md)
 * [Appendix B: Polyfilling Block Scope](apB.md)
 * [Appendix C: Lexical-this](apC.md)
-* [Appendix D: Thank You's!](apD.md)

scope-closures/apA.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: Scope & Closures
+# You Don't Know JS Yet: Scope & Closures - 2nd Edition
 # Appendix A: Dynamic Scope
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 In Chapter 2, we talked about "Dynamic Scope" as a contrast to the "Lexical Scope" model, which is how scope works in JavaScript (and in fact, most other languages).
 
 We will briefly examine dynamic scope, to hammer home the contrast. But, more importantly, dynamic scope actually is a near cousin to another mechanism (`this`) in JavaScript, which we covered in the "*this & Object Prototypes*" title of this book series.

scope-closures/apB.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: Scope & Closures
+# You Don't Know JS Yet: Scope & Closures - 2nd Edition
 # Appendix B: Polyfilling Block Scope
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 In Chapter 3, we explored Block Scope. We saw that `with` and the `catch` clause are both tiny examples of block scope that have existed in JavaScript since at least the introduction of ES3.
 
 But it's ES6's introduction of `let` that finally gives full, unfettered block-scoping capability to our code. There are many exciting things, both functionally and code-stylistically, that block scope will enable.

scope-closures/apC.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: Scope & Closures
+# You Don't Know JS Yet: Scope & Closures - 2nd Edition
 # Appendix C: Lexical-this
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 Though this title does not address the `this` mechanism in any detail, there's one ES6 topic which relates `this` to lexical scope in an important way, which we will quickly examine.
 
 ES6 adds a special syntactic form of function declaration called the "arrow function". It looks like this:

scope-closures/ch1.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: Scope & Closures
+# You Don't Know JS Yet: Scope & Closures - 2nd Edition
 # Chapter 1: What is Scope?
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 One of the most fundamental paradigms of nearly all programming languages is the ability to store values in variables, and later retrieve or modify those values. In fact, the ability to store values and pull values out of variables is what gives a program *state*.
 
 Without such a concept, a program could perform some tasks, but they would be extremely limited and not terribly interesting.

scope-closures/ch2.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: Scope & Closures
+# You Don't Know JS Yet: Scope & Closures - 2nd Edition
 # Chapter 2: Lexical Scope
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 In Chapter 1, we defined "scope" as the set of rules that govern how the *Engine* can look up a variable by its identifier name and find it, either in the current *Scope*, or in any of the *Nested Scopes* it's contained within.
 
 There are two predominant models for how scope works. The first of these is by far the most common, used by the vast majority of programming languages. It's called **Lexical Scope**, and we will examine it in-depth. The other model, which is still used by some languages (such as Bash scripting, some modes in Perl, etc.) is called **Dynamic Scope**.

scope-closures/ch3.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: Scope & Closures
+# You Don't Know JS Yet: Scope & Closures - 2nd Edition
 # Chapter 3: Function vs. Block Scope
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 As we explored in Chapter 2, scope consists of a series of "bubbles" that each act as a container or bucket, in which identifiers (variables, functions) are declared. These bubbles nest neatly inside each other, and this nesting is defined at author-time.
 
 But what exactly makes a new bubble? Is it only the function? Can other structures in JavaScript create bubbles of scope?

scope-closures/ch4.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: Scope & Closures
+# You Don't Know JS Yet: Scope & Closures - 2nd Edition
 # Chapter 4: Hoisting
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 By now, you should be fairly comfortable with the idea of scope, and how variables are attached to different levels of scope depending on where and how they are declared. Both function scope and block scope behave by the same rules in this regard: any variable declared within a scope is attached to that scope.
 
 But there's a subtle detail of how scope attachment works with declarations that appear in various locations within a scope, and that detail is what we will examine here.

scope-closures/ch5.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: Scope & Closures
+# You Don't Know JS Yet: Scope & Closures - 2nd Edition
 # Chapter 5: Scope Closure
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 We arrive at this point with hopefully a very healthy, solid understanding of how scope works.
 
 We turn our attention to an incredibly important, but persistently elusive, *almost mythological*, part of the language: **closure**. If you have followed our discussion of lexical scope thus far, the payoff is that closure is going to be, largely, anticlimactic, almost self-obvious. *There's a man behind the wizard's curtain, and we're about to see him*. No, his name is not Crockford!

scope-closures/foreword.md

@@ -1,4 +1,6 @@
-# You Don't Know JS Yet: Scope & Closures
+# You Don't Know JS Yet: Scope & Closures - 2nd Edition
 # Foreword
 
-TBA
+| NOTE: |
+| :--- |
+| Work in progress |

scope-closures/toc.md

@@ -1,4 +1,8 @@
-# You Don't Know JS: Scope & Closures
+# You Don't Know JS Yet: Scope & Closures - 2nd Edition
+
+| NOTE: |
+| :--- |
+| Work in progress |
 
 ## Table of Contents
 
@@ -30,4 +34,3 @@
 * Appendix A: Dynamic Scope
 * Appendix B: Polyfilling Block Scope
 * Appendix C: Lexical-this
-* Appendix D: Acknowledgments

this-object-prototypes/README.md

@@ -1,14 +1,17 @@
 # You Don't Know JS Yet: *this* & Object Prototypes - 2nd Edition
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
 [Table of Contents](toc.md)
 
 * [Foreword](foreword.md) (by TBA)
 * [Preface](../preface.md)
-* [Chapter 1: *this* Or That?](ch1.md)
-* [Chapter 2: *this* All Makes Sense Now!](ch2.md)
+* [Chapter 1: `this` Or That?](ch1.md)
+* [Chapter 2: `this` All Makes Sense Now!](ch2.md)
 * [Chapter 3: Objects](ch3.md)
 * [Chapter 4: Mixing (Up) "Class" Objects](ch4.md)
 * [Chapter 5: Prototypes](ch5.md)
 * [Chapter 6: Behavior Delegation](ch6.md)
-* [Appendix A: ES6 *class*](apA.md)
-* [Appendix B: Thank You's!](apB.md)
+* [Appendix A: ES6 `class`](apA.md)

this-object-prototypes/apA.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: *this* & Object Prototypes
+# You Don't Know JS Yet: *this* & Object Prototypes - 2nd Edition
 # Appendix A: ES6 `class`
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 If there's any take-away message from the second half of this book (Chapters 4-6), it's that classes are an optional design pattern for code (not a necessary given), and that furthermore they are often quite awkward to implement in a `[[Prototype]]` language like JavaScript.
 
 This awkwardness is *not* just about syntax, although that's a big part of it. Chapters 4 and 5 examined quite a bit of syntactic ugliness, from verbosity of `.prototype` references cluttering the code, to *explicit pseudo-polymorphism* (see Chapter 4) when you give methods the same name at different levels of the chain and try to implement a polymorphic reference from a lower-level method to a higher-level method. `.constructor` being wrongly interpreted as "was constructed by" and yet being unreliable for that definition is yet another syntactic ugly.

this-object-prototypes/ch1.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: *this* & Object Prototypes
+# You Don't Know JS Yet: *this* & Object Prototypes - 2nd Edition
 # Chapter 1: `this` Or That?
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 One of the most confused mechanisms in JavaScript is the `this` keyword. It's a special identifier keyword that's automatically defined in the scope of every function, but what exactly it refers to bedevils even seasoned JavaScript developers.
 
 > Any sufficiently *advanced* technology is indistinguishable from magic. -- Arthur C. Clarke

this-object-prototypes/ch2.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: *this* & Object Prototypes
+# You Don't Know JS Yet: *this* & Object Prototypes - 2nd Edition
 # Chapter 2: `this` All Makes Sense Now!
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 In Chapter 1, we discarded various misconceptions about `this` and learned instead that `this` is a binding made for each function invocation, based entirely on its **call-site** (how the function is called).
 
 ## Call-site

this-object-prototypes/ch3.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: *this* & Object Prototypes
+# You Don't Know JS Yet: *this* & Object Prototypes - 2nd Edition
 # Chapter 3: Objects
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 In Chapters 1 and 2, we explained how the `this` binding points to various objects depending on the call-site of the function invocation. But what exactly are objects, and why do we need to point to them? We will explore objects in detail in this chapter.
 
 ## Syntax

this-object-prototypes/ch4.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: *this* & Object Prototypes
+# You Don't Know JS yet: *this* & Object Prototypes - 2nd Edition
 # Chapter 4: Mixing (Up) "Class" Objects
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 Following our exploration of objects from the previous chapter, it's natural that we now turn our attention to "object oriented (OO) programming", with "classes". We'll first look at "class orientation" as a design pattern, before examining the mechanics of "classes": "instantiation", "inheritance" and "(relative) polymorphism".
 
 We'll see that these concepts don't really map very naturally to the object mechanism in JS, and the lengths (mixins, etc.) many JavaScript developers go to overcome such challenges.

this-object-prototypes/ch5.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: *this* & Object Prototypes
+# You Don't Know JS Yet: *this* & Object Prototypes - 2nd Edition
 # Chapter 5: Prototypes
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 In Chapters 3 and 4, we mentioned the `[[Prototype]]` chain several times, but haven't said what exactly it is. We will now examine prototypes in detail.
 
 **Note:** All of the attempts to emulate class-copy behavior, as described previously in Chapter 4, labeled as variations of "mixins", completely circumvent the `[[Prototype]]` chain mechanism we examine here in this chapter.

this-object-prototypes/ch6.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: *this* & Object Prototypes
+# You Don't Know JS Yet: *this* & Object Prototypes - 2nd Edition
 # Chapter 6: Behavior Delegation
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 In Chapter 5, we addressed the `[[Prototype]]` mechanism  in detail, and *why* it's confusing and inappropriate (despite countless attempts for nearly two decades) to describe it as "class" or "inheritance". We trudged through not only the fairly verbose syntax (`.prototype` littering the code), but the various gotchas (like surprising `.constructor` resolution or ugly pseudo-polymorphic syntax). We explored variations of the "mixin" approach, which many people use to attempt to smooth over such rough areas.
 
 It's a common reaction at this point to wonder why it has to be so complex to do something seemingly so simple. Now that we've pulled back the curtain and seen just how dirty it all gets, it's not a surprise that most JS developers never dive this deep, and instead relegate such mess to a "class" library to handle it for them.

this-object-prototypes/foreword.md

@@ -1,4 +1,6 @@
-# You Don't Know JS Yet: *this* & Object Prototypes
+# You Don't Know JS Yet: *this* & Object Prototypes - 2nd Edition
 # Foreword
 
-TBA
+| NOTE: |
+| :--- |
+| Work in progress |

this-object-prototypes/toc.md

@@ -1,4 +1,8 @@
-# You Don't Know JS: *this* & Object Prototypes
+# You Don't Know JS Yet: *this* & Object Prototypes - 2nd Edition
+
+| NOTE: |
+| :--- |
+| Work in progress |
 
 ## Table of Contents
 
@@ -36,5 +40,3 @@
 	* Nicer Syntax
 	* Introspection
 * Appendix A: ES6 `class`
-* Appendix B: Acknowledgments
-

types-grammar/README.md

@@ -1,5 +1,9 @@
 # You Don't Know JS Yet: Types & Grammar - 2nd Edition
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
 [Table of Contents](toc.md)
 
 * [Foreword](foreword.md) (by TBA)
@@ -10,4 +14,3 @@
 * [Chapter 4: Coercion](ch4.md)
 * [Chapter 5: Grammar](ch5.md)
 * [Appendix A: Mixed Environment JavaScript](apA.md)
-* [Appendix B: Thank You's!](apB.md)

types-grammar/apA.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: Types & Grammar
+# You Don't Know JS Yet: Types & Grammar - 2nd Edition
 # Appendix A: Mixed Environment JavaScript
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 Beyond the core language mechanics we've fully explored in this book, there are several ways that your JS code can behave differently when it runs in the real world. If JS was executing purely inside an engine, it'd be entirely predictable based on nothing but the black-and-white of the spec. But JS pretty much always runs in the context of a hosting environment, which exposes your code to some degree of unpredictability.
 
 For example, when your code runs alongside code from other sources, or when your code runs in different types of JS engines (not just browsers), there are some things that may behave differently.

types-grammar/ch1.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: Types & Grammar
+# You Don't Know JS Yet: Types & Grammar - 2nd Edition
 # Chapter 1: Types
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 Most developers would say that a dynamic language (like JS) does not have *types*. Let's see what the ES5.1 specification (http://www.ecma-international.org/ecma-262/5.1/) has to say on the topic:
 
 > Algorithms within this specification manipulate values each of which has an associated type. The possible value types are exactly those defined in this clause. Types are further sub classified into ECMAScript language types and specification types.

types-grammar/ch2.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: Types & Grammar
+# You Don't Know JS Yet: Types & Grammar - 2nd Edition
 # Chapter 2: Values
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 `array`s, `string`s, and `number`s are the most basic building-blocks of any program, but JavaScript has some unique characteristics with these types that may either delight or confound you.
 
 Let's look at several of the built-in value types in JS, and explore how we can more fully understand and correctly leverage their behaviors.

types-grammar/ch3.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: Types & Grammar
+# You Don't Know JS Yet: Types & Grammar - 2nd Edition
 # Chapter 3: Natives
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 Several times in Chapters 1 and 2, we alluded to various built-ins, usually called "natives," like `String` and `Number`. Let's examine those in detail now.
 
 Here's a list of the most commonly used natives:

types-grammar/ch4.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: Types & Grammar
+# You Don't Know JS Yet: Types & Grammar - 2nd Edition
 # Chapter 4: Coercion
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 Now that we much more fully understand JavaScript's types and values, we turn our attention to a very controversial topic: coercion.
 
 As we mentioned in Chapter 1, the debates over whether coercion is a useful feature or a flaw in the design of the language (or somewhere in between!) have raged since day one. If you've read other popular books on JS, you know that the overwhelmingly prevalent *message* out there is that coercion is magical, evil, confusing, and just downright a bad idea.

types-grammar/ch5.md

@@ -1,6 +1,26 @@
-# You Don't Know JS: Types & Grammar
+# You Don't Know JS Yet: Types & Grammar - 2nd Edition
 # Chapter 5: Grammar
 
+| NOTE: |
+| :--- |
+| Work in progress |
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+.
+
+----
+
 The last major topic we want to tackle is how JavaScript's language syntax works (aka its grammar). You may think you know how to write JS, but there's an awful lot of nuance to various parts of the language grammar that lead to confusion and misconception, so we want to dive into those parts and clear some things up.
 
 **Note:** The term "grammar" may be a little less familiar to readers than the term "syntax." In many ways, they are similar terms, describing the *rules* for how the language works. There are nuanced differences, but they mostly don't matter for our discussion here. The grammar for JavaScript is a structured way to describe how the syntax (operators, keywords, etc.) fits together into well-formed, valid programs. In other words, discussing syntax without grammar would leave out a lot of the important details. So our focus here in this chapter is most accurately described as *grammar*, even though the raw syntax of the language is what developers directly interact with.

types-grammar/foreword.md

@@ -1,4 +1,6 @@
-# You Don't Know JS: Types & Grammar
+# You Don't Know JS Yet: Types & Grammar - 2nd Edition
 # Foreword
 
-TBA
+| NOTE: |
+| :--- |
+| Work in progress |

types-grammar/toc.md

@@ -1,4 +1,8 @@
-# You Don't Know JS: Types & Grammar
+# You Don't Know JS Yet: Types & Grammar - 2nd Edition
+
+| NOTE: |
+| :--- |
+| Work in progress |
 
 ## Table of Contents
 
@@ -35,5 +39,3 @@
 	* `try..finally`
 	* `switch`
 * Appendix A: Mixed Environment JavaScript
-* Appendix B: Acknowledgments
-