Merge branch 'feature/Day_6_contents' into develop

Author: Jaxolotl

.markdownlint.json

@@ -0,0 +1,6 @@
+{
+  "MD013": false,
+  "MD026": false,
+  "MD028": false,
+  "MD036": false
+}

README.md

@@ -85,41 +85,56 @@ A lot of information has been written about JavaScript and EcmaScript since both
     - The Iterable and the Iterator Protocol
     - Preliminary Practice
     - Exercises
-- DAY 6
+- [DAY 6](/day_06.md)
   - Functions
-    - <https://www.ecma-international.org/ecma-262/6.0/#sec-function-definitions>
-    - <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions>
-    - <https://github.com/Jaxolotl-Didactic-Lab/useful-info/blob/develop/functions%20-%20generators%20-%20scope%20-%20closure.md>
-    - First-Class Citizens
-    - ..
-    - .. good practices
-  - this Keyword
-    - <https://github.com/getify/You-Dont-Know-JS/blob/1st-ed/this%20%26%20object%20prototypes/ch1.md>
-    - <https://github.com/getify/You-Dont-Know-JS/blob/1st-ed/this%20%26%20object%20prototypes/ch2.md>
+    - General Definition
+    - Function declaration (function statement)
+    - Function expression
+    - Function constructor
+    - Constructor vs declaration vs expression
+    - Properties of the Function object in the prototype chain
+    - Arity & formal parameters
+    - Formal parameters and the `arguments` thing
+    - Functions as properties of an object
+    - IIFE
+    - Pure functions
+    - Side Effects
+  - Execution context
+    - Types of Execution Context (executable code)
+    - Execution Stack
+    - How Execution Context is defined?
+    - Articles and books used for this section
+  - Scope
+    - Part of a program
+    - ECMAScript definition
+    - General definitions
+    - Examples
+  - Hoisting
+  - Closure
+    - General definition
+    - Examples
+  - Can we Cheat Scope?
+    - ev[a|i]l
+    - with
+  - Relative Concepts Readings
+  - Preliminary practice
+  - Exercises
+- DAY 7
+  - `this` Keyword
+    - <https://github.com/getify/You-Dont-Know-JS/blob/master/this%20%26%20object%20prototypes/ch1.md>
+    - <https://github.com/getify/You-Dont-Know-JS/blob/master/this%20%26%20object%20prototypes/ch2.md>
     - <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/this>
     - BIND
     - APPLY
     - CALL
-    - ..
-    - .. good practices
-  - Execution context
-    - <https://github.com/Jaxolotl-Didactic-Lab/useful-info/blob/develop/execution-context.md>
-    - ...
-    - .. good practices
-  - Scope
-    - <https://github.com/Jaxolotl-Didactic-Lab/useful-info/blob/develop/scope.md>
-    - ES5 hoisting
-    - .. good practices
-- DAY 7
+  - Strict mode
+    - What happens on strict mode?
+    - Semantic Differences
   - Arrow Functions
     - ...
     - ...
     - .. good practices
-  - Closure
-    - <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Closures>
-    - IIFE
-    - .. good practices
-  - Generators & Iterators
+  - Generators
     - ..
     - ..
     - .. good practices

day_01.md

@@ -95,10 +95,10 @@ To be fair we should go back to the evolution of ES.
 
 What is important to understand is that **until ES6** all versions were **ordinal versioned** and the release pace was **freaking slow** mostly because the browsers weren't decoupled from the OS and therefore any change should be integrated at OS releasing scale.
 
-Since ES6 - AKA ES2015, a year-based schema was introduced to reflect and support the fast development pace of JavaScript particularly impulsed by the decoupling of the Web Browsers from OS first but also due to the expansive adoption of the language and the growth of its use beyond "just swapping a button img on rollover" ( A very interesting article about that was written by **Matthew MacDonald**, [read it here ](https://medium.com/young-coder/how-javascript-grew-up-and-became-a-real-language-17a0b948b77f)).
+Since ES6 - AKA ES2015, a year-based schema was introduced to reflect and support the fast development pace of JavaScript particularly impulsed by the decoupling of the Web Browsers from OS first but also due to the expansive adoption of the language and the growth of its use beyond "just swapping a button img on rollover" (A very interesting article about that was written by **Matthew MacDonald**, [read it here](https://medium.com/young-coder/how-javascript-grew-up-and-became-a-real-language-17a0b948b77f)).
 
-From ES2015 the standardization process started behaving as a **living standard** hence not tight to structured cuts but by an release based on continuous consensus and progressive adoption.
-In order to keep the pace, several improvements were required under the hood to keep it stable and scalable. Browsers will then adopt the new features based on their own pace, which left on the engineering side the responsibility for maintaining the backward compatibility, what led to an extensive growth of techniques such as [polyfilling](https://github.com/getify/You-Dont-Know-JS/blob/2nd-ed/es%3Anext%20%26%20beyond/ch1.md#shimspolyfills) and [transpiling](https://github.com/getify/You-Dont-Know-JS/blob/2nd-ed/es%3Anext%20%26%20beyond/ch1.md#transpiling)
+From ES2015 the standardization process started behaving as a **living standard** hence not tied to structured cuts but by an release based on continuous consensus and progressive adoption.
+In order to keep the pace, several improvements were required under the hood to keep it stable and scalable. Browsers will then adopt the new features based at their own pace, which left on the engineering side the responsibility for maintaining the backward compatibility, what led to an extensive growth of techniques such as [polyfilling](https://github.com/getify/You-Dont-Know-JS/blob/2nd-ed/es%3Anext%20%26%20beyond/ch1.md#shimspolyfills) and [transpiling](https://github.com/getify/You-Dont-Know-JS/blob/2nd-ed/es%3Anext%20%26%20beyond/ch1.md#transpiling)
 
 Tons of publications can be found online comparing both standards; you can read them online. I'd suggest to start with clean unbiased documents such as the [ecma-262 5.1](https://www.ecma-international.org/ecma-262/5.1) and [ecma-262 6.0](https://www.ecma-international.org/ecma-262/6.0/) ... but some find that too tedious :D ... you can check also this [ECMAScript 6 — New Features: Overview & Comparison](http://es6-features.org/) by Ralf S. Engelschall which I find very interesting, or jump into the excellent [You Don't Know JS book series](https://github.com/getify/You-Dont-Know-JS/) by Kyle Simpson, especially on the dedicated book [ES6 & Beyond](https://github.com/getify/You-Dont-Know-JS/tree/2nd-ed/es:next%20%26%20beyond) by Kyle Simpson
 

day_02.md

@@ -122,7 +122,7 @@ a = b * 2;
 
 is built by [4 simpler expressions](https://github.com/getify/You-Dont-Know-JS/blob/1st-ed/up%20%26%20going/ch1.md#expressions).
 
-You can learn more from his [YDKJS - Types & Grammar](https://github.com/getify/You-Dont-Know-JS/blob/1st-ed/types%20%26%20grammar/ch5.md#statements--expressions) book online, also take a look at a particularly little known characteristic that [all Statements have Completion Values](https://github.com/getify/You-Dont-Know-JS/blob/1st-ed/types%20&%20grammar/ch5.md#statement-completion-values) ( yup, as many of us I learned this quite late :,( )
+You can learn more from his [YDKJS - Types & Grammar](https://github.com/getify/You-Dont-Know-JS/blob/1st-ed/types%20%26%20grammar/ch5.md#statements--expressions) book online, also take a look at a particularly little known characteristic that [all Statements have Completion Values](https://github.com/getify/You-Dont-Know-JS/blob/1st-ed/types%20%26%20grammar/ch5.md#statement-completion-values) ( yup, as many of us I learned this quite late :,( )
 
 ### Semantics
 
@@ -216,10 +216,11 @@ If you want to dive into how operators are defined by the spec, there's a comple
 ### Operators precedence
 
 Just like in math, in computer programming there's a set of rules or conventions to define which procedure to perform first in order to evaluate an expression. Depending on the order we might have different results.
-Javascript is not an exception and we cas see this table very well explained at [MDN web Docs - Operator precedence](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence).
+Javascript is not an exception and we can see this table very well explained at [MDN web Docs - Operator precedence](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence).
 
 ### The case of the ... ( spread/rest "operator" )
-A new syntactic element was introduced in ES6 but surprisingly it's not listed as part of the operators but rather as a left-hand-side expression, specifically an assignment expression. 
+
+A new syntactic element was introduced in ES6 but surprisingly it's not listed as part of the operators but rather as a left-hand-side expression, specifically an assignment expression.
 
 You can search for **SpreadElement** on the [spec](http://www.ecma-international.org/ecma-262/6.0/) to see how it behaves depending on the context.
 

day_05.md

@@ -117,7 +117,7 @@ But they might be a little harsh at this moment, why don't we take a look at MDN
 > - `value` - any JavaScript value returned by the iterator. Can be omitted when `done` is `true`.
 >
 > The `next` method always has to return an object with appropriate properties including `done` and `value`. If a non-object value gets returned (such as `false` or `undefined`), a TypeError ("iterator.next() returned a non-object value") will be thrown.
-> 
+>
 > Source: [MDN - The iterator protocol](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterator_protocol)
 
 Essentially this protocols defines and interface to iterate in a consistent way across implementations opening the door for you to define your own iterables taking control of the iteration steps in a super granular way.