Resolve conflicts.

Author: odsantos

1-js/01-getting-started/1-intro/article.md

@@ -106,21 +106,12 @@ Ferramentas modernas tornam a transpilação muito rápida e transparente, permi
 
 Exemplos de tais linguagens:
 
-<<<<<<< HEAD
 - [CoffeeScript](http://coffeescript.org/) é um "açúcar sintático" para JavaScript. Ele introduz uma sintaxe mais curta, permitindo-nos escrever um código mais claro e preciso. Normalmente, Ruby devs gostam dele.
 - [TypeScript](http://www.typescriptlang.org/) está concentrado em adicionar "estritos tipos de dados" para simplificar o desenvolvimento e suporte de sistemas complexos. É desenvolvido pela Microsoft.
 - [Flow](http://flow.org/) também adiciona tipos de dados, mas de uma forma diferente. Desenvolvido pela Facebook.
 - [Dart](https://www.dartlang.org/) é uma linguagem autônoma que tem seu próprio interpretador que roda em ambientes fora do navegador (como aplicativos móveis), mas também pode ser transpilada para JavaScript. Desenvolvida pela Google.
 - [Brython](https://brython.info/) é um transpilador de Python para JavaScript que permite escrever aplicativos em puro Python, sem JavaScript.
 - [Kotlin](https://kotlinlang.org/docs/js-overview.html) é uma linguagem de programação moderna, concisa e segura, que pode ser usada no navegador ou no Node.
-=======
-- [CoffeeScript](http://coffeescript.org/) is a "syntactic sugar" for JavaScript. It introduces shorter syntax, allowing us to write clearer and more precise code. Usually, Ruby devs like it.
-- [TypeScript](http://www.typescriptlang.org/) is concentrated on adding "strict data typing" to simplify the development and support of complex systems. It is developed by Microsoft.
-- [Flow](http://flow.org/) also adds data typing, but in a different way. Developed by Facebook.
-- [Dart](https://www.dartlang.org/) is a standalone language that has its own engine that runs in non-browser environments (like mobile apps), but also can be transpiled to JavaScript. Developed by Google.
-- [Brython](https://brython.info/) is a Python transpiler to JavaScript that enables the writing of applications in pure Python without JavaScript.
-- [Kotlin](https://kotlinlang.org/docs/reference/js-overview.html) is a modern, concise and safe programming language that can target the browser or Node.
->>>>>>> 468e3552884851fcef331fbdfd58096652964b5f
 
 Há mais. Claro que, mesmo que usemos uma dessas linguagens transpiladas, também devemos saber JavaScript para entender o que estamos fazendo.
 

1-js/03-code-quality/01-debugging-chrome/article.md

@@ -134,13 +134,8 @@ Existem botões para isso no topo do painel direito. Vamos interagir com eles.
 
     Continuando a clicar nele, passará por todas as instruções do programa, uma por uma.
 
-<<<<<<< HEAD
 <span class="devtools" style="background-position:-62px -192px"></span> -- "Step over": execute o próximo comando, mas *mas não vá para dentro de uma função*, atalho `key:F10`.
-: Similar ao comando "Step" anterior, mas com um comportamento diferente se a próxima instrução for uma chamada de função. Isto é: não uma incorporada (*built-in*), como `alert`, mas uma função sua.
-=======
-<span class="devtools" style="background-position:-62px -192px"></span> -- "Step over": run the next command, but *don't go into a function*, hotkey `key:F10`.
-: Similar to the previous "Step" command, but behaves differently if the next statement is a function call. That is: not a built-in, like `alert`, but a function of our own.
->>>>>>> 468e3552884851fcef331fbdfd58096652964b5f
+: Similar ao comando "Step" anterior, mas com um comportamento diferente se a próxima instrução for uma chamada de função. Isto é: não uma incorporada (*built-in*), como `alert`, mas uma função nossa.
 
     O comando "Step", vai para dentro dela e suspende a execução na sua primeira linha, ao contrário de "Step over" que executa essa chamada de função aninhada invisívelmente, saltando sobre o funcionamento interno da função.
 

1-js/05-data-types/10-destructuring-assignment/article.md

@@ -2,11 +2,6 @@
 
 The two most used data structures in JavaScript are `Object` and `Array`.
 
-<<<<<<< HEAD
-Objects allow us to pack many pieces of information into a single entity and arrays allow us to store ordered collections. So we can make an object or an array and handle it as a single entity, or maybe pass it to a function call.
-
-*Destructuring assignment* is a special syntax that allows us to "unpack" arrays or objects into a bunch of variables, as sometimes they are more convenient. Destructuring also works great with complex functions that have a lot of parameters, default values, and soon we'll see how these are handled too.
-=======
 - Objects allow us to create a single entity that stores data items by key. 
 - Arrays allow us to gather data items into an ordered list.
 
@@ -15,7 +10,6 @@ Although, when we pass those to a function, it may need not an object/array as a
 *Destructuring assignment* is a special syntax that allows us to "unpack" arrays or objects into a bunch of variables, as sometimes that's more convenient. 
 
 Destructuring also works great with complex functions that have a lot of parameters, default values, and so on. Soon we'll see that.
->>>>>>> 468e3552884851fcef331fbdfd58096652964b5f
 
 ## Array destructuring
 
@@ -27,6 +21,8 @@ let arr = ["John", "Smith"]
 
 *!*
 // destructuring assignment
+// sets firstName = arr[0]
+// and surname = arr[1]
 let [firstName, surname] = arr;
 */!*
 
@@ -69,7 +65,7 @@ let [firstName, , title] = ["Julius", "Caesar", "Consul", "of the Roman Republic
 alert( title ); // Consul
 ```
 
-In the code above, the second element of the array is skipped, the third one is assigned to `title`, and the rest of the array is also skipped.
+In the code above, the second element of the array is skipped, the third one is assigned to `title`, and the rest of the array items is also skipped (as there are no variables for them).
 ````
 
 ````smart header="Works with any iterable on the right-side"
@@ -125,12 +121,8 @@ user.set("name", "John");
 user.set("age", "30");
 
 *!*
-<<<<<<< HEAD
-for (let [key, value] of user.entries()) {
-=======
 // Map iterates as [key, value] pairs, very convenient for destructuring
 for (let [key, value] of user) {
->>>>>>> 468e3552884851fcef331fbdfd58096652964b5f
 */!*
   alert(`${key}:${value}`); // name:John, then age:30
 }
@@ -267,7 +259,7 @@ Properties `options.title`, `options.width` and `options.height` are assigned to
 The order does not matter. This works too:
 
 ```js
-// changed the order of properties in let {...}
+// changed the order in let {...}
 let {height, width, title} = { title: "Menu", height: 200, width: 100 }
 ```
 
@@ -316,7 +308,7 @@ alert(height); // 200
 
 Just like with arrays or function parameters, default values can be any expressions or even function calls. They will be evaluated if the value is not provided.
 
-The code below asks for width, but not the title.
+In the code below `prompt` asks for `width`, but not for `title`:
 
 ```js run
 let options = {
@@ -328,7 +320,7 @@ let {width = prompt("width?"), title = prompt("title?")} = options;
 */!*
 
 alert(title);  // Menu
-alert(width);  // (whatever you the result of prompt is)
+alert(width);  // (whatever the result of prompt is)
 ```
 
 We also can combine both the colon and equality:
@@ -347,11 +339,26 @@ alert(w);      // 100
 alert(h);      // 200
 ```
 
-### The rest operator
+If we have a complex object with many properties, we can extract only what we need:
+
+```js run
+let options = {
+  title: "Menu",
+  width: 100,
+  height: 200
+};
+
+// only extract title as a variable
+let { title } = options;
+
+alert(title); // Menu
+```
+
+### The rest pattern "..."
 
 What if the object has more properties than we have variables? Can we take some and then assign the "rest" somewhere?
 
-The specification for using the rest operator (three dots) here is almost in the standard, but most browsers do not support it yet.
+We can use the rest pattern, just like we did with arrays. It's not supported by some older browsers (IE, use Babel to polyfill it), but works in modern ones.
 
 It looks like this:
 
@@ -363,6 +370,8 @@ let options = {
 };
 
 *!*
+// title = property named title
+// rest = object with the rest of properties
 let {title, ...rest} = options;
 */!*
 
@@ -371,10 +380,8 @@ alert(rest.height);  // 200
 alert(rest.width);   // 100
 ```
 
-
-
-````smart header="Gotcha without `let`"
-In the examples above variables were declared right before the assignment: `let {…} = {…}`. Of course, we could use existing variables too. But there's a catch.
+````smart header="Gotcha if there's no `let`"
+In the examples above variables were declared right in the assignment: `let {…} = {…}`. Of course, we could use existing variables too, without `let`. But there's a catch.
 
 This won't work:
 ```js run
@@ -407,14 +414,13 @@ let title, width, height;
 
 alert( title ); // Menu
 ```
-
 ````
 
 ## Nested destructuring
 
-If an object or an array contain other objects and arrays, we can use more complex left-side patterns to extract deeper portions.
+If an object or an array contain other nested objects and arrays, we can use more complex left-side patterns to extract deeper portions.
 
-In the code below `options` has another object in the property `size` and an array in the property `items`. The pattern at the left side of the assignment has the same structure:
+In the code below `options` has another object in the property `size` and an array in the property `items`. The pattern at the left side of the assignment has the same structure to extract values from them:
 
 ```js run
 let options = {
@@ -423,10 +429,10 @@ let options = {
     height: 200
   },
   items: ["Cake", "Donut"],
-  extra: true    // something extra that we will not destruct
+  extra: true   
 };
 
-// destructuring assignment on multiple lines for clarity
+// destructuring assignment split in multiple lines for clarity
 let {
   size: { // put size here
     width,
@@ -449,17 +455,11 @@ All properties of `options` object except `extra` that is absent in the left par
 
 Finally, we have `width`, `height`, `item1`, `item2` and `title` from the default value.
 
-That often happens with destructuring assignments. We have a complex object with many properties and want to extract only what we need.
-
-Even here it happens:
-```js
-// take size as a whole into a variable, ignore the rest
-let { size } = options;
-```
+Note that there are no variables for `size` and `items`, as we take their content instead.
 
 ## Smart function parameters
 
-There are times when a function may have many parameters, most of which are optional. That's especially true for user interfaces. Imagine a function that creates a menu. It may have a width, a height, a title, items list and so on.
+There are times when a function has many parameters, most of which are optional. That's especially true for user interfaces. Imagine a function that creates a menu. It may have a width, a height, a title, items list and so on.
 
 Here's a bad way to write such function:
 
@@ -526,29 +526,28 @@ function showMenu({
 showMenu(options);
 ```
 
-The syntax is the same as for a destructuring assignment:
+The full syntax is the same as for a destructuring assignment:
 ```js
 function({
-  incomingProperty: parameterName = defaultValue
+  incomingProperty: varName = defaultValue
   ...
 })
 ```
 
+Then, for an object of parameters, there will be a variable `varName` for property `incomingProperty`, with `defaultValue` by default.
+
 Please note that such destructuring assumes that `showMenu()` does have an argument. If we want all values by default, then we should specify an empty object:
 
 ```js
-showMenu({});
-
+showMenu({}); // ok, all values are default
 
 showMenu(); // this would give an error
 ```
 
-We can fix this by making `{}` the default value for the whole destructuring thing:
-
+We can fix this by making `{}` the default value for the whole object of parameters:
 
 ```js run
-// simplified parameters a bit for clarity
-function showMenu(*!*{ title = "Menu", width = 100, height = 200 } = {}*/!*) {
+function showMenu({ title = "Menu", width = 100, height = 200 }*!* = {}*/!*) {
   alert( `${title} ${width} ${height}` );
 }
 
@@ -560,19 +559,21 @@ In the code above, the whole arguments object is `{}` by default, so there's alw
 ## Summary
 
 - Destructuring assignment allows for instantly mapping an object or array onto many variables.
-- The object syntax:
+- The full object syntax:
     ```js
-    let {prop : varName = default, ...} = object
+    let {prop : varName = default, ...rest} = object
     ```
 
     This means that property `prop` should go into the variable `varName` and, if no such property exists, then the `default` value should be used.
 
-- The array syntax:
+    Object properties that have no mapping are copied to the `rest` object.
+
+- The full array syntax:
 
     ```js
     let [item1 = default, item2, ...rest] = array
     ```
 
     The first item goes to `item1`; the second goes into `item2`, all the rest makes the array `rest`.
 
-- For more complex cases, the left side must have the same structure as the right one.
+- It's possible to extract data from nested arrays/objects, for that the left side must have the same structure as the right one.

1-js/06-advanced-functions/10-bind/article.md

@@ -5,13 +5,13 @@ libs:
 
 # Function binding
 
-When using `setTimeout` with object methods or passing object methods along, there's a known problem: "losing `this`".
+When passing object methods as callbacks, for instance to `setTimeout`, there's a known problem: "losing `this`".
 
-Suddenly, `this` just stops working right. The situation is typical for novice developers, but happens with experienced ones as well.
+In this chapter we'll see the ways to fix it.
 
 ## Losing "this"
 
-We already know that in JavaScript it's easy to lose `this`. Once a method is passed somewhere separately from the object -- `this` is lost.
+We've already seen examples of losing `this`. Once a method is passed somewhere separately from the object -- `this` is lost.
 
 Here's how it may happen with `setTimeout`:
 
@@ -37,7 +37,7 @@ let f = user.sayHi;
 setTimeout(f, 1000); // lost user context
 ```
 
-The method `setTimeout` in-browser is a little special: it sets `this=window` for the function call (for Node.js, `this` becomes the timer object, but doesn't really matter here). So for `this.firstName` it tries to get `window.firstName`, which does not exist. In other similar cases as we'll see, usually `this` just becomes `undefined`.
+The method `setTimeout` in-browser is a little special: it sets `this=window` for the function call (for Node.js, `this` becomes the timer object, but doesn't really matter here). So for `this.firstName` it tries to get `window.firstName`, which does not exist. In other similar cases, usually `this` just becomes `undefined`.
 
 The task is quite typical -- we want to pass an object method somewhere else (here -- to the scheduler) where it will be called. How to make sure that it will be called in the right context?
 
@@ -102,7 +102,7 @@ The basic syntax is:
 ```js
 // more complex syntax will come a little later
 let boundFunc = func.bind(context);
-````
+```
 
 The result of `func.bind(context)` is a special function-like "exotic object", that is callable as function and transparently passes the call to `func` setting `this=context`.
 
@@ -321,4 +321,8 @@ Also there's a ready [_.partial](https://lodash.com/docs#partial) implementation
 
 Method `func.bind(context, ...args)` returns a "bound variant" of function `func` that fixes the context `this` and first arguments if given.
 
-Usually we apply `bind` to fix `this` in an object method, so that we can pass it somewhere. For example, to `setTimeout`. There are more reasons to `bind` in the modern development, we'll meet them later.
+Usually we apply `bind` to fix `this` for an object method, so that we can pass it somewhere. For example, to `setTimeout`.
+
+When we fix some arguments of an existing function, the resulting (less universal) function is called *partially applied* or *partial*.
+
+Partials are convenient when we don't want to repeat the same argument over and over again. Like if we have a `send(from, to)` function, and `from` should always be the same for our task, we can get a partial and go on with it.