diff --git a/1-js/01-getting-started/1-intro/article.md b/1-js/01-getting-started/1-intro/article.md
index 74521076..69bb189a 100644
--- a/1-js/01-getting-started/1-intro/article.md
+++ b/1-js/01-getting-started/1-intro/article.md
@@ -25,12 +25,12 @@ The browser has an embedded engine, sometimes it's also called a "JavaScript vir
 Different engines have different "codenames", for example:
 
 - [V8](https://en.wikipedia.org/wiki/V8_(JavaScript_engine)) -- in Chrome and Opera.
-- [Gecko](https://en.wikipedia.org/wiki/Gecko_(software)) -- in Firefox.
+- [SpiderMonkey](https://en.wikipedia.org/wiki/SpiderMonkey) -- in Firefox.
 - ...There are other codenames like "Trident", "Chakra" for different versions of IE, "ChakraCore" for Microsoft Edge, "Nitro" and "SquirrelFish" for Safari etc.
 
 The terms above are good to remember, because they are used in developer articles on the internet. We'll use them too. For instance, if "a feature X is supported by V8", then it probably works in Chrome and Opera.
 
-```smart header="How engines work?"
+```smart header="How do engines work?"
 
 Engines are complicated. But the basics are easy.
 
@@ -108,7 +108,7 @@ Modern tools make the transpilation very fast and transparent, actually allowing
 
 Examples of such languages:
 
-- [CoffeeScript](http://coffeescript.org/) is a "syntax sugar" for JavaScript, it introduces shorter syntax, allowing to write more precise and clear code. Usually Ruby devs like it.
+- [CoffeeScript](http://coffeescript.org/) is a "syntactic sugar" for JavaScript, it introduces shorter syntax, allowing to write more precise and clear code. Usually Ruby devs like it.
 - [TypeScript](http://www.typescriptlang.org/) is concentrated on adding "strict data typing", to simplify development and support of complex systems. It is developed by Microsoft.
 - [Dart](https://www.dartlang.org/) is a standalone language that has its own engine that runs in non-browser environments (like mobile apps). It was initially offered by Google as a replacement for JavaScript, but as of now, browsers require it to be transpiled to JavaScript just like the ones above.
 
diff --git a/1-js/01-getting-started/2-code-editors/article.md b/1-js/01-getting-started/2-code-editors/article.md
index 65ef7476..0d714cdb 100644
--- a/1-js/01-getting-started/2-code-editors/article.md
+++ b/1-js/01-getting-started/2-code-editors/article.md
@@ -1,26 +1,22 @@
 # Code editors
 
-A code editor is the place where a programmer spends most of his time.
+A code editor is the place where programmers spend most of their time.
 
 There are two archetypes: IDE and lightweight editors. Many people feel comfortable choosing one tool of each type.
 
-[cut]
-
 ## IDE
 
-The term [IDE](https://en.wikipedia.org/wiki/Integrated_development_environment) (Integrated Development Environment) means a powerful editor with many features that usually operates on a "whole project". As said, that's not just an editor, but a full-scale "development environment".
+The term [IDE](https://en.wikipedia.org/wiki/Integrated_development_environment) (Integrated Development Environment) means a powerful editor with many features that usually operates on a "whole project". As the name suggests, that's not just an editor, but a full-scale "development environment".
 
-An IDE loads the project (can be many files), and then allows navigation between files, provides autocompletion based on the whole project, integrates with a version management system (like [git](https://git-scm.com/)), a testing environment and other "project-level" stuff.
+An IDE loads the project (can be many files), allows navigation between files, provides autocompletion based on the whole project (not just the open file), integrates with a version management system (like [git](https://git-scm.com/)), a testing environment and other "project-level" stuff.
 
 If you haven't considered selecting an IDE yet, look at the following variants:
 
-- IntelliJ editors: [WebStorm](http://www.jetbrains.com/webstorm/) for frontend development and [PHPStorm (PHP)](http://www.jetbrains.com/phpstorm/), [IDEA (Java)](http://www.jetbrains.com/idea/), [RubyMine (Ruby)](http://www.jetbrains.com/ruby/) and others if you need additional languages.
+- [WebStorm](http://www.jetbrains.com/webstorm/) for frontend development and other editors of the same company if you need additional languages.
 - Visual Studio is fine if you're a .NET developer, and a free version is available ([Visual Studio Community](https://www.visualstudio.com/vs/community/))
-- Eclipse-based products, like [Aptana](http://www.aptana.com/) and Zend Studio.
-- [Komodo IDE](http://www.activestate.com/komodo-ide) and its lightweight free version [Komodo Edit](http://www.activestate.com/komodo-edit).
 - [Netbeans](http://netbeans.org/).
 
-All of the IDEs listed above are available on both Windows and Mac, and the IDEs other than Visual Studio are also available on Linux.
+All of the IDEs except Visual Studio are available on Windows, MacOs and Linux. Visual Studio doesn't work on Linux.
 
 Most IDEs are paid, but have a trial period. Their cost is usually negligible compared to a qualified developer's salary, so just choose the best one for you.
 
@@ -40,7 +36,7 @@ The following options deserve your attention:
 - [Atom](https://atom.io/) (cross-platform, free).
 - [Sublime Text](http://www.sublimetext.com) (cross-platform, shareware).
 - [Notepad++](https://notepad-plus-plus.org/) (Windows, free).
-- Vim and Emacs are also cool, if you know how to use them.
+- [Vim](http://www.vim.org/) and [Emacs](https://www.gnu.org/software/emacs/) are also cool, if you know how to use them.
 
 ## My favorites
 
@@ -48,11 +44,9 @@ The personal preference of the author is to have both an IDE for projects and a
 
 I'm using:
 
-- [WebStorm](http://www.jetbrains.com/webstorm/) for JS, and if there is one more language in the project, then I switch to other Jetbrains editors like [PHPStorm](http://www.jetbrains.com/phpstorm/) (PHP), [IDEA](http://www.jetbrains.com/idea/) (Java), [RubyMine](http://www.jetbrains.com/ruby/) (Ruby). There are editors for other languages too, but I haven't used them.
+- [WebStorm](http://www.jetbrains.com/webstorm/) for JS, and if there is one more language in the project, then I switch to one of the other Jetbrains offerings listed above.
 - As a lightweight editor -- [Sublime Text](http://www.sublimetext.com) or [Atom](https://atom.io/).
 
-If you don't know what to choose, you can consider these ones.
-
 ## Let's not argue
 
 The editors in the lists above are those that either I or my friends who I consider good developers have been using for a long time and are happy with.
diff --git a/1-js/01-getting-started/3-devtools/article.md b/1-js/01-getting-started/3-devtools/article.md
index 34e5c9a7..f250502d 100644
--- a/1-js/01-getting-started/3-devtools/article.md
+++ b/1-js/01-getting-started/3-devtools/article.md
@@ -10,8 +10,6 @@ Most often developers lean towards Chrome or Firefox for development, because th
 
 Developer tools are really powerful, there are many features. To start, we'll learn how to open them, look at errors and run JavaScript commands.
 
-[cut]
-
 ## Google Chrome
 
 Open the page [bug.html](bug.html).
diff --git a/1-js/02-first-steps/01-hello-world/article.md b/1-js/02-first-steps/01-hello-world/article.md
index e69a25f0..69d2ba97 100644
--- a/1-js/02-first-steps/01-hello-world/article.md
+++ b/1-js/02-first-steps/01-hello-world/article.md
@@ -7,8 +7,6 @@ But, we need a working environment to run our scripts, and, just because this bo
 So first, let's see how to attach a script to a webpage. For server-side environments, you can just execute it with a command like `"node my.js"` for Node.JS.
 
 
-[cut]
-
 ## The "script" tag
 
 JavaScript programs can be inserted in any part of an HTML document with the help of the `<script>` tag.
diff --git a/1-js/02-first-steps/02-structure/article.md b/1-js/02-first-steps/02-structure/article.md
index fc1dc46e..ebaa3752 100644
--- a/1-js/02-first-steps/02-structure/article.md
+++ b/1-js/02-first-steps/02-structure/article.md
@@ -2,8 +2,6 @@
 
 The first thing to study is the building blocks of the code.
 
-[cut]
-
 ## Statements
 
 Statements are syntax constructs and commands that perform actions.
@@ -102,7 +100,7 @@ As time goes on, the program becomes more and more complex. It becomes necessary
 
 Comments can be put into any place of the script. They don't affect the execution, because the engine simply ignores them.
 
-**One-line comments start with the two forward slash characters `//`.**
+**One-line comments start with two forward slash characters `//`.**
 
 The rest of the line is a comment. It may occupy a full line of its own or follow a statement.
 
diff --git a/1-js/02-first-steps/03-strict-mode/article.md b/1-js/02-first-steps/03-strict-mode/article.md
index a7bb414b..35b4ef2b 100644
--- a/1-js/02-first-steps/03-strict-mode/article.md
+++ b/1-js/02-first-steps/03-strict-mode/article.md
@@ -6,8 +6,6 @@ That had the benefit of never breaking existing code. But the downside was that
 
 It had been so until 2009 when ECMAScript 5 (ES5) appeared. It added new features to the language and modified some of the existing ones. To keep the old code working, most modifications are off by default. One needs to enable them explicitly with a special directive `"use strict"`.
 
-[cut]
-
 ## "use strict"
 
 The directive looks like a string: `"use strict"` or `'use strict'`. When it is located on the top of the script, then the whole script works the "modern" way.
diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md
index 9c4c9642..264755f8 100644
--- a/1-js/02-first-steps/04-variables/article.md
+++ b/1-js/02-first-steps/04-variables/article.md
@@ -1,10 +1,10 @@
 # Variables
 
-Most of the time, a script needs to work with information. If it's an online-shop -- that's going to be the goods and a shopping cart. If it's a chat -- users, messages and so on.
+Most of the time, a JavaScript application needs to work with information. Here are 2 examples:
+1. An online-shop -- the information might include goods being sold and a shopping cart. 
+2. A chat application -- the information might include users, messages, and much more.
 
-Variables are used to store the information.
-
-[cut]
+Variables are used to store this information.
 
 ## A variable
 
@@ -97,7 +97,7 @@ There are subtle differences between `let` and `var`, but they do not matter for
 
 We can easily grasp the concept of a "variable" if we imagine it as a "box" for data, with a uniquely-named sticker on it.
 
-For instance, the variable `message` can be imagined as a box labelled `"message"` with the value `"Hello!"` in it:
+For instance, the variable `message` can be imagined as a box labeled `"message"` with the value `"Hello!"` in it:
 
 ![](variable.png)
 
@@ -296,23 +296,23 @@ Please name the variables sensibly. Take time to think if needed.
 
 Variable naming is one of the most important and complex skills in programming. A quick glance at variable names can reveal which code is written by a beginner and which by an experienced developer.
 
-In a real project, most of the time is spent on modifying and extending the existing code base, rather than writing something completely separate from the scratch. And when we return to the code after some time of doing something else, it's much easier to find information that is well-labelled. Or, in other words, when the variables have good names.
+In a real project, most of the time is spent on modifying and extending the existing code base, rather than writing something completely separate from scratch. And when we return to the code after some time of doing something else, it's much easier to find information that is well-labeled. Or, in other words, when the variables have good names.
 
-Please spend some time thinking about the right name for a variable before declaring it. That will repay you a lot.
+Please spend some time thinking about the right name for a variable before declaring it. This will repay you a lot.
 
 Some good-to-follow rules are:
 
 - Use human-readable names like `userName` or `shoppingCart`.
 - Stay away from abbreviations or short names like `a`, `b`, `c`, unless you really know what you're doing.
 - Make the name maximally descriptive and concise. Examples of bad names are `data` and `value`. Such a name says nothing. It is only ok to use them if it's exceptionally obvious from the context which data or value is meant.
-- Agree on terms within the team and in your own mind. If a site visitor is called a "user" then we should name related variables like `currentUser` or `newUser`, but not `currentVisitor` or a `newManInTown`.
+- Agree on terms within your team and in your own mind. If a site visitor is called a "user" then we should name related variables like `currentUser` or `newUser`, but not `currentVisitor` or a `newManInTown`.
 
 Sounds simple? Indeed it is, but creating good descriptive-and-concise names in practice is not. Go for it.
 
 ```smart header="Reuse or create?"
 And the last note. There are some lazy programmers who, instead of declaring a new variable, tend to reuse the existing ones.
 
-As the result, the variable is like a box where people throw different things without changing the sticker. What is inside it now? Who knows... We need to come closer and check.
+As a result, the variable is like a box where people throw different things without changing the sticker. What is inside it now? Who knows... We need to come closer and check.
 
 Such a programmer saves a little bit on variable declaration, but loses ten times more on debugging the code.
 
diff --git a/1-js/02-first-steps/05-types/article.md b/1-js/02-first-steps/05-types/article.md
index dd7a3481..9ed9a2d3 100644
--- a/1-js/02-first-steps/05-types/article.md
+++ b/1-js/02-first-steps/05-types/article.md
@@ -12,8 +12,6 @@ Programming languages that allow such things are called "dynamically typed", mea
 
 There are seven basic data types in JavaScript. Here we'll study the basics, and in the next chapters we'll talk about each of them in detail.
 
-[cut]
-
 ## A number
 
 ```js
@@ -162,7 +160,7 @@ let x;
 alert(x); // shows "undefined"
 ```
 
-Technically, it is possible to assign any variable to `undefined`:
+Technically, it is possible to assign `undefined` to any variable:
 
 ```js run
 let x = 123;
@@ -191,7 +189,7 @@ It supports two forms of syntax:
 1. As an operator: `typeof x`.
 2. Function style: `typeof(x)`.
 
-In other words, it works both with the brackets or without them. The result is the same.
+In other words, it works both with parentheses or without them. The result is the same.
 
 The call to `typeof x` returns a string with the type name:
 
diff --git a/1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/solution.md b/1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/solution.md
index 0e1be244..ce48cbff 100644
--- a/1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/solution.md
+++ b/1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/solution.md
@@ -17,6 +17,6 @@ undefined + 1 = NaN // (4)
 ```
 
 1. The addition with a string `"" + 1` converts `1` to a string: `"" + 1 = "1"`, and then we have `"1" + 0`, the same rule is applied.
-2. The substruction `"-"` (like most math operations) only works with numbers, it converts an empty string `""` to `0`.
+2. The subtraction `-` (like most math operations) only works with numbers, it converts an empty string `""` to `0`.
 3. `null` becomes `0` after the numeric conversion.
 4. `undefined` becomes `NaN` after the numeric conversion.
diff --git a/1-js/02-first-steps/06-type-conversions/article.md b/1-js/02-first-steps/06-type-conversions/article.md
index df14571a..90a418e3 100644
--- a/1-js/02-first-steps/06-type-conversions/article.md
+++ b/1-js/02-first-steps/06-type-conversions/article.md
@@ -6,8 +6,6 @@ For example, `alert` automatically converts any value to a string to show it. Ma
 
 There are also cases when we need to explicitly convert a value to put things right.
 
-[cut]
-
 ```smart header="Not talking about objects yet"
 In this chapter we don't cover objects yet. Here we study primitives first. Later, after we learn objects, we'll see how object conversion works in the chapter <info:object-toprimitive>.
 ```
diff --git a/1-js/02-first-steps/07-operators/article.md b/1-js/02-first-steps/07-operators/article.md
index 61f119b3..6a2121fb 100644
--- a/1-js/02-first-steps/07-operators/article.md
+++ b/1-js/02-first-steps/07-operators/article.md
@@ -4,14 +4,12 @@ Many operators are known to us from school. They are addition `+`, a multiplicat
 
 In this chapter we concentrate on aspects that are not covered by school arithmetic.
 
-[cut]
-
 ## Terms: "unary", "binary", "operand"
 
 Before we move on, let's grasp the common terminology.
 
 - *An operand* -- is what operators are applied to. For instance in multiplication `5 * 2` there are two operands: the left operand is `5`, and the right operand is `2`. Sometimes people say "arguments" instead of "operands".
-- An operator is *unary* if it has a single operand. For example, the unary negation `"-"` reverses the sign of the number:
+- An operator is *unary* if it has a single operand. For example, the unary negation `-` reverses the sign of the number:
 
     ```js run
     let x = 1;
@@ -34,7 +32,7 @@ Before we move on, let's grasp the common terminology.
 
 Now let's see special features of JavaScript operators that are beyond school arithmetics.
 
-Usually the plus operator `'+'` sums numbers.
+Usually the plus operator `+` sums numbers.
 
 But if the binary `+` is applied to strings, it merges (concatenates) them:
 
@@ -43,7 +41,7 @@ let s = "my" + "string";
 alert(s); // mystring
 ```
 
-Note that if any of operands is a string, then the other one is converted to a string too.
+Note that if any of the operands is a string, then the other one is converted to a string too.
 
 For example:
 
@@ -54,7 +52,14 @@ alert( 2 + '1' ); // "21"
 
 See, it doesn't matter whether the first operand is a string or the second one. The rule is simple: if either operand is a string, then convert the other one into a string as well.
 
-String concatenation and conversion is a special feature of the binary plus `"+"`. Other arithmetic operators work only with numbers. They always convert their operands to numbers.
+However, note that operations run from left to right. If there are two numbers followed by a string, the numbers will be added before being converted to a string:
+
+
+```js run
+alert(2 + 2 + '1' ); // "41" and not "221"
+```
+
+String concatenation and conversion is a special feature of the binary plus `+`. Other arithmetic operators work only with numbers. They always convert their operands to numbers.
 
 For instance, subtraction and division:
 
@@ -65,7 +70,7 @@ alert( '6' / '2' ); // 3
 
 ## Numeric conversion, unary +
 
-The plus `+` exist in two forms. The binary form that we used above and the unary form.
+The plus `+` exists in two forms. The binary form that we used above and the unary form.
 
 The unary plus or, in other words, the plus operator `+` applied to a single value, doesn't do anything with numbers, but if the operand is not a number, then it is converted into it.
 
@@ -86,9 +91,9 @@ alert( +"" );   // 0
 */!*
 ```
 
-It actually does the same as `Number(...)`, but shorter.
+It actually does the same as `Number(...)`, but is shorter.
 
-A need to convert string to number arises very often. For example, if we are getting values from HTML form fields, then they are usually strings.
+A need to convert strings to numbers arises very often. For example, if we are getting values from HTML form fields, then they are usually strings.
 
 What if we want to sum them?
 
@@ -173,7 +178,7 @@ alert( b ); // 4
 alert( c ); // 4
 ```
 
-Chained assignments evaluate from right to left. First the rightmost expression `2+2` is evaluated then assigned to the variables on the left: `c`, `b` and `a`. At the end, all variables share a single value.
+Chained assignments evaluate from right to left. First the rightmost expression `2 + 2` is evaluated then assigned to the variables on the left: `c`, `b` and `a`. At the end, all variables share a single value.
 
 ````smart header="The assignment operator `\"=\"` returns a value"
 An operator always returns a value. That's obvious for most of them like an addition `+` or a multiplication `*`. But the assignment operator follows that rule too.
@@ -246,14 +251,14 @@ So, there are special operators for that:
 
     ```js run no-beautify
     let counter = 2;
-    counter++;      // works same as counter = counter + 1, but shorter
+    counter++;      // works the same as counter = counter + 1, but is shorter
     alert( counter ); // 3
     ```
 - **Decrement** `--` decreases a variable by 1:
 
     ```js run no-beautify
     let counter = 2;
-    counter--;      // works same as counter = counter - 1, but shorter
+    counter--;      // works the same as counter = counter - 1, but is shorter
     alert( counter ); // 1
     ```
 
@@ -281,7 +286,7 @@ let a = ++counter; // (*)
 alert(a); // *!*2*/!*
 ```
 
-Here in the line `(*)` the prefix call `++counter` increments `i` and returns the new value that is `2`. So the `alert` shows `2`.
+Here in the line `(*)` the prefix call `++counter` increments `counter` and returns the new value that is `2`. So the `alert` shows `2`.
 
 Now let's use the postfix form:
 
@@ -292,7 +297,7 @@ let a = counter++; // (*) changed ++counter to counter++
 alert(a); // *!*1*/!*
 ```
 
-In the line `(*)` the *postfix* form `counter++` also increments `i`, but returns the *old* value (prior to increment). So the `alert` shows `1`.
+In the line `(*)` the *postfix* form `counter++` also increments `counter`, but returns the *old* value (prior to increment). So the `alert` shows `1`.
 
 To summarize:
 
@@ -381,8 +386,8 @@ This notation can be shortened using operators `+=` and `*=`:
 
 ```js run
 let n = 2;
-n += 5; // now n=7 (same as n = n + 5)
-n *= 2; // now n=14 (same as n = n * 2)
+n += 5; // now n = 7 (same as n = n + 5)
+n *= 2; // now n = 14 (same as n = n * 2)
 
 alert( n ); // 14
 ```
@@ -401,26 +406,26 @@ alert( n ); // 16  (right part evaluated first, same as n *= 8)
 
 ## Comma
 
-The comma operator `','` is one of most rare and unusual operators. Sometimes it's used to write shorter code, so we need to know it in order to understand what's going on.
+The comma operator `,` is one of most rare and unusual operators. Sometimes it's used to write shorter code, so we need to know it in order to understand what's going on.
 
-The comma operator allows us to evaluate several expressions, dividing them with a comma `','`. Each of them is evaluated, but the result of only the last one is returned.
+The comma operator allows us to evaluate several expressions, dividing them with a comma `,`. Each of them is evaluated, but the result of only the last one is returned.
 
 For example:
 
 ```js run
 *!*
-let a = (1+2, 3+4);
+let a = (1 + 2, 3 + 4);
 */!*
 
-alert( a ); // 7 (the result of 3+4)
+alert( a ); // 7 (the result of 3 + 4)
 ```
 
-Here, the first expression `1+2` is evaluated, and its result is thrown away, then `3+4` is evaluated and returned as the result.
+Here, the first expression `1 + 2` is evaluated, and its result is thrown away, then `3 + 4` is evaluated and returned as the result.
 
 ```smart header="Comma has a very low precedence"
 Please note that the comma operator has very low precedence, lower than `=`, so parentheses are important in the example above.
 
-Without them: `a=1+2,3+4` evaluates `+` first, summing the numbers into `a=3,7`, then the assignment operator `=` assigns `a=3`, and then the number after the comma `7` is not processed anyhow, so it's ignored.
+Without them: `a = 1 + 2, 3 + 4` evaluates `+` first, summing the numbers into `a = 3, 7`, then the assignment operator `=` assigns    `a = 3`, and then the number after the comma `7` is not processed anyhow, so it's ignored.
 ```
 
 Why do we need such an operator which throws away everything except the last part?
diff --git a/1-js/02-first-steps/08-comparison/1-comparison-questions/solution.md b/1-js/02-first-steps/08-comparison/1-comparison-questions/solution.md
index e1f50ce1..5c8bd2bc 100644
--- a/1-js/02-first-steps/08-comparison/1-comparison-questions/solution.md
+++ b/1-js/02-first-steps/08-comparison/1-comparison-questions/solution.md
@@ -13,7 +13,7 @@ null === +"\n0\n" → false
 Some of the reasons:
 
 1. Obviously, true.
-2. Dictionary comparison, hence true.
+2. Dictionary comparison, hence false.
 3. Again, dictionary comparison, first char of `"2"` is greater than the first char of `"1"`.
 4. Values `null` and `undefined` equal each other only.
 5. Strict equality is strict. Different types from both sides lead to false.
diff --git a/1-js/02-first-steps/08-comparison/article.md b/1-js/02-first-steps/08-comparison/article.md
index ed0034fe..00ae53f1 100644
--- a/1-js/02-first-steps/08-comparison/article.md
+++ b/1-js/02-first-steps/08-comparison/article.md
@@ -4,11 +4,9 @@ Many comparison operators we know from maths:
 
 - Greater/less than: <code>a &gt; b</code>, <code>a &lt; b</code>.
 - Greater/less than or equals: <code>a &gt;= b</code>, <code>a &lt;= b</code>.
-- Equality check is written as `a == b` (please note the double equation sign `'='`. A single symbol `a = b` would mean an assignment).
+- Equality check is written as `a == b` (please note the double equation sign `=`. A single symbol `a = b` would mean an assignment).
 - Not equals. In maths the notation is <code>&ne;</code>, in JavaScript it's written as an assignment with an exclamation sign before it: <code>a != b</code>.
 
-[cut]
-
 ## Boolean is the result
 
 Just as all other operators, a comparison returns a value. The value is of the boolean type.
@@ -108,7 +106,7 @@ From JavaScript's standpoint that's quite normal. An equality check converts usi
 
 ## Strict equality
 
-A regular equality check `"=="` has a problem. It cannot differ `0` from `false`:
+A regular equality check `==` has a problem. It cannot differ `0` from `false`:
 
 ```js run
 alert( 0 == false ); // true
@@ -146,7 +144,7 @@ There's a non-intuitive behavior when `null` or `undefined` are compared with ot
 
 
 For a strict equality check `===`
-: These values are different, because each of them belong to a separate type of it's own.
+: These values are different, because each of them belongs to a separate type of its own.
 
     ```js run
     alert( null === undefined ); // false
diff --git a/1-js/02-first-steps/09-alert-prompt-confirm/article.md b/1-js/02-first-steps/09-alert-prompt-confirm/article.md
index 3b393fbc..65a42557 100644
--- a/1-js/02-first-steps/09-alert-prompt-confirm/article.md
+++ b/1-js/02-first-steps/09-alert-prompt-confirm/article.md
@@ -4,8 +4,6 @@ This part of the tutorial aims to cover JavaScript "as is", without environment-
 
 But still we use a browser as the demo environment. So we should know at least a few user-interface functions. In this chapter we'll get familiar with the browser functions `alert`, `prompt` and `confirm`.
 
-[cut]
-
 ## alert
 
 Syntax:
diff --git a/1-js/02-first-steps/10-ifelse/4-check-login/solution.md b/1-js/02-first-steps/10-ifelse/4-check-login/solution.md
index cfe52074..b535650e 100644
--- a/1-js/02-first-steps/10-ifelse/4-check-login/solution.md
+++ b/1-js/02-first-steps/10-ifelse/4-check-login/solution.md
@@ -9,13 +9,13 @@ if (userName == 'Admin') {
 
   if (pass == 'TheMaster') {
     alert( 'Welcome!' );
-  } else if (pass == null) {
+  } else if (pass == '' || pass == null) {
     alert( 'Canceled.' );
   } else {
     alert( 'Wrong password' );
   }
 
-} else if (userName == null) {
+} else if (userName == '' || userName == null) {
   alert( 'Canceled' );
 } else {
   alert( "I don't know you" );
diff --git a/1-js/02-first-steps/10-ifelse/4-check-login/task.md b/1-js/02-first-steps/10-ifelse/4-check-login/task.md
index 4b371a1d..1d12cb09 100644
--- a/1-js/02-first-steps/10-ifelse/4-check-login/task.md
+++ b/1-js/02-first-steps/10-ifelse/4-check-login/task.md
@@ -20,4 +20,6 @@ The schema:
 
 Please use nested `if` blocks. Mind the overall readability of the code.
 
+Hint: passing an empty input to a prompt returns an empty string `''`. Pressing `key:ESC` during a prompt returns `null`.
+
 [demo]
diff --git a/1-js/02-first-steps/10-ifelse/article.md b/1-js/02-first-steps/10-ifelse/article.md
index 2fd4ca88..b3ab5997 100644
--- a/1-js/02-first-steps/10-ifelse/article.md
+++ b/1-js/02-first-steps/10-ifelse/article.md
@@ -2,13 +2,11 @@
 
 Sometimes we need to perform different actions based on a condition.
 
-There is the `if` statement for that and also the conditional (ternary) operator for conditional evaluation which we will be referring as  the “question mark” operator: `"?"` for simplicity.
-
-[cut]
+There is the `if` statement for that and also the conditional (ternary) operator for conditional evaluation which we will be referring as  the “question mark” operator `?` for simplicity.
 
 ## The "if" statement
 
-The "if" statement gets a condition, evaluates it and, if the result is `true`, executes the code.
+The `if` statement gets a condition, evaluates it and, if the result is `true`, executes the code.
 
 For example:
 
@@ -22,7 +20,7 @@ if (year == 2015) alert( 'You are right!' );
 
 In the example above, the condition is a simple equality check: `year == 2015`, but it can be much more complex.
 
-If there is more than one command to execute, we can use a code block in figure brackets:
+If there is more than one statement to be executed, we have to wrap our code block inside curly braces:
 
 ```js
 if (year == 2015) {
@@ -31,7 +29,7 @@ if (year == 2015) {
 }
 ```
 
-It is recommended to use figure brackets every time with `if`, even if there is only one command. That improves readability.
+It is recommended to wrap your code block with curly braces `{}` every time with `if`, even if there is only one statement. That improves readability.
 
 ## Boolean conversion
 
@@ -128,7 +126,7 @@ alert(accessAllowed);
 
 The so-called "ternary" or "question mark" operator lets us do that shorter and simpler.
 
-The operator is represented by a question mark `"?"`.  The formal term "ternary" means that the operator has three operands. It is actually the one and only operator in JavaScript which has that many.
+The operator is represented by a question mark `?`.  The formal term "ternary" means that the operator has three operands. It is actually the one and only operator in JavaScript which has that many.
 
 The syntax is:
 ```js
@@ -151,7 +149,7 @@ Technically, we can omit parentheses around `age > 18`. The question mark operat
 let accessAllowed = age > 18 ? true : false;
 ```
 
-...But parentheses make the code more readable. So it's recommended to use them.
+But parentheses make the code more readable, so it's recommended to use them.
 
 ````smart
 In the example above it's possible to evade the question mark operator, because the comparison by itself returns `true/false`:
@@ -164,7 +162,7 @@ let accessAllowed = age > 18;
 
 ## Multiple '?'
 
-A sequence of question mark `"?"` operators allows returning a value that depends on more than one condition.
+A sequence of question mark `?` operators allows returning a value that depends on more than one condition.
 
 For instance:
 ```js run
@@ -190,7 +188,7 @@ The same logic using `if..else`:
 ```js
 if (age < 3) {
   message = 'Hi, baby!';
-} else if (a < 18) {
+} else if (age < 18) {
   message = 'Hello!';
 } else if (age < 100) {
   message = 'Greetings!';
@@ -201,7 +199,7 @@ if (age < 3) {
 
 ## Non-traditional use of '?'
 
-Sometimes the question mark `'?'` is used as a replacement for `if`:
+Sometimes the question mark `?` is used as a replacement for `if`:
 
 ```js run no-beautify
 let company = prompt('Which company created JavaScript?', '');
@@ -212,7 +210,7 @@ let company = prompt('Which company created JavaScript?', '');
 */!*
 ```
 
-Depending on the condition `company == 'Netscape'`, either the first or the second part after `"?"` gets executed and shows the alert.
+Depending on the condition `company == 'Netscape'`, either the first or the second part after `?` gets executed and shows the alert.
 
 We don't assign a result to a variable here. The idea is to execute different code depending on the condition.
 
@@ -236,4 +234,4 @@ if (company == 'Netscape') {
 
 Our eyes scan the code vertically. The constructs which span several lines are easier to understand than a long horizontal instruction set.
 
-The idea of a question mark `'?'` is to return one or another value depending on the condition. Please use it for exactly that. There is `if` to execute different branches of the code.
+The idea of a question mark `?` is to return one or another value depending on the condition. Please use it for exactly that. There is `if` to execute different branches of the code.
diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index b3aecc31..d2431494 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -6,8 +6,6 @@ Although they are called "logical", they can be applied to values of any type, n
 
 Let's see the details.
 
-[cut]
-
 ## || (OR)
 
 The "OR" operator is represented with two vertical line symbols:
@@ -68,7 +66,7 @@ if (hour < 10 || hour > 18 || isWeekend) {
 
 ## OR seeks the first truthy value
 
-The logic described above is somewhat classical. Now let's bring in the "extra" features of JavaScipt.
+The logic described above is somewhat classical. Now let's bring in the "extra" features of JavaScript.
 
 The extended algorithm works as follows.
 
@@ -78,11 +76,11 @@ Given multiple OR'ed values:
 result = value1 || value2 || value3;
 ```
 
-The OR `"||"` operator does the following:
+The OR `||` operator does the following:
 
 - Evaluate operands from left to right.
 - For each operand, convert it to boolean. If the result is `true`, then stop and return the original value of that operand.
-- If all other operands have been assessed (i.e. all were `falsy`), return the last operand.
+- If all other operands have been assessed (i.e. all were `false`), return the last operand.
 
 A value is returned in its original form, without the conversion.
 
@@ -196,7 +194,7 @@ Given multiple AND'ed values:
 result = value1 && value2 && value3;
 ```
 
-The AND `"&&"` operator does the following:
+The AND `&&` operator does the following:
 
 - Evaluate operands from left to right.
 - For each operand, convert it to a boolean. If the result is `false`, stop and return the original value of that operand.
@@ -232,14 +230,10 @@ When all values are truthy, the last value is returned:
 alert( 1 && 2 && 3 ); // 3, the last one
 ```
 
-````smart header="AND `&&` executes before OR `||`"
-The precedence of the AND `&&` operator is higher than OR `||`, so it executes before OR.
+````smart header="Precedence of AND `&&` is higher than OR `||`"
+The precedence of AND `&&` operator is higher than OR `||`.
 
-In the code below `1 && 0` is calculated first:
-
-```js run
-alert( 5 || 1 && 0 ); // 5
-```
+So the code `a && b || c && d` is essentially the same as if `&&` were in parentheses: `(a && b) || (c && d)`.
 ````
 
 Just like OR, the AND `&&` operator can sometimes replace `if`.
@@ -270,7 +264,7 @@ So it is recommended to use every construct for its purpose. Use `if` if we want
 
 ## ! (NOT)
 
-The boolean NOT operator is represented with an exclamation sign `"!"`.
+The boolean NOT operator is represented with an exclamation sign `!`.
 
 The syntax is pretty simple:
 
@@ -305,3 +299,5 @@ There's a little more verbose way to do the same thing -- a built-in `Boolean` f
 alert( Boolean("non-empty string") ); // true
 alert( Boolean(null) ); // false
 ```
+
+The precedence of NOT `!` is the highest of all bitwise operators, so it always executes first, before any `&&`, `||`.
diff --git a/1-js/02-first-steps/12-while-for/3-which-value-for/solution.md b/1-js/02-first-steps/12-while-for/3-which-value-for/solution.md
index 766278fd..e2e28e75 100644
--- a/1-js/02-first-steps/12-while-for/3-which-value-for/solution.md
+++ b/1-js/02-first-steps/12-while-for/3-which-value-for/solution.md
@@ -8,8 +8,8 @@ for (let i = 0; i < 5; i++) alert( i );
 
 That can be easily deducted from the algorithm of `for`:
 
-1. Execute once `i=0` before everything (begin).
-2. Check the condition `i<5`
+1. Execute once `i = 0` before everything (begin).
+2. Check the condition `i < 5`
 3. If `true` -- execute the loop body `alert(i)`, and then `i++`
 
 The increment `i++` is separated from the condition check (2). That's just another statement.
diff --git a/1-js/02-first-steps/12-while-for/6-repeat-until-correct/solution.md b/1-js/02-first-steps/12-while-for/6-repeat-until-correct/solution.md
index 31ca18d9..2e04a78c 100644
--- a/1-js/02-first-steps/12-while-for/6-repeat-until-correct/solution.md
+++ b/1-js/02-first-steps/12-while-for/6-repeat-until-correct/solution.md
@@ -10,6 +10,6 @@ do {
 The loop `do..while` repeats while both checks are truthy:
 
 1. The check for `num <= 100` -- that is, the entered value is still not greater than `100`.
-2. The check `&& num` is false when `num` is `null` or a empty strig. Then the `while` loop stops too.
+2. The check `&& num` is false when `num` is `null` or a empty string. Then the `while` loop stops too.
 
 P.S. If `num` is `null` then `num <= 100` is `true`, so without the 2nd check the loop wouldn't stop if the user clicks CANCEL. Both checks are required.
diff --git a/1-js/02-first-steps/12-while-for/7-list-primes/task.md b/1-js/02-first-steps/12-while-for/7-list-primes/task.md
index 0f92fecf..6344b9f6 100644
--- a/1-js/02-first-steps/12-while-for/7-list-primes/task.md
+++ b/1-js/02-first-steps/12-while-for/7-list-primes/task.md
@@ -6,12 +6,12 @@ importance: 3
 
 An integer number greater than `1` is called a [prime](https://en.wikipedia.org/wiki/Prime_number) if it cannot be divided without a remainder by anything except `1` and itself.
 
-In other words, `n>1` is a prime if it can't be evenly divided by anything except `1` and `n`.
+In other words, `n > 1` is a prime if it can't be evenly divided by anything except `1` and `n`.
 
 For example, `5` is a prime, because it cannot be divided without a remainder by `2`, `3` and `4`.
 
 **Write the code which outputs prime numbers in the interval from `2` to `n`.**
 
-For `n=10` the result will be `2,3,5,7`.
+For `n = 10` the result will be `2,3,5,7`.
 
 P.S. The code should work for any `n`, not be hard-tuned for any fixed value.
diff --git a/1-js/02-first-steps/12-while-for/article.md b/1-js/02-first-steps/12-while-for/article.md
index 55ea6302..e600b8c4 100644
--- a/1-js/02-first-steps/12-while-for/article.md
+++ b/1-js/02-first-steps/12-while-for/article.md
@@ -6,8 +6,6 @@ For example, when we need to output goods from a list one after another. Or just
 
 *Loops* are a way to repeat the same part of code multiple times.
 
-[cut]
-
 ## The "while" loop
 
 The `while` loop has the following syntax:
@@ -21,7 +19,7 @@ while (condition) {
 
 While the `condition` is `true`, the `code` from the loop body is executed.
 
-For instance, the loop below outputs `i` while `i<3`:
+For instance, the loop below outputs `i` while `i < 3`:
 
 ```js run
 let i = 0;
@@ -35,9 +33,9 @@ A single execution of the loop body is called *an iteration*. The loop in the ex
 
 If there were no `i++` in the example above, the loop would repeat (in theory) forever. In practice, the browser provides ways to stop such loops, and for server-side JavaScript we can kill the process.
 
-Any expression or a variable can be a loop condition, not just a comparison. They are evaluated and converted to boolean by `while`.
+Any expression or a variable can be a loop condition, not just a comparison. They are evaluated and converted to a boolean by `while`.
 
-For instance, the shorter way to write `while (i!=0)` could be `while (i)`:
+For instance, the shorter way to write `while (i != 0)` could be `while (i)`:
 
 ```js run
 let i = 3;
@@ -108,8 +106,8 @@ Let's examine the `for` statement part by part:
 
 | part  |          |                                                                            |
 |-------|----------|----------------------------------------------------------------------------|
-| begin | `i=0`    | Executes once upon entering the loop.                                      |
-| condition | `i<3`| Checked before every loop iteration, if fails the loop stops.              |
+| begin | `i = 0`    | Executes once upon entering the loop.                                      |
+| condition | `i < 3`| Checked before every loop iteration, if fails the loop stops.              |
 | step| `i++`      | Executes after the body on each iteration, but before the condition check. |
 | body | `alert(i)`| Runs again and again while the condition is truthy                         |
 
@@ -188,11 +186,11 @@ We can also remove the `step` part:
 let i = 0;
 
 for (; i < 3;) {
-  alert( i );
+  alert( i++ );
 }
 ```
 
-The loop became identical to `while (i<3)`.
+The loop became identical to `while (i < 3)`.
 
 We can actually remove everything, thus creating an infinite loop:
 
@@ -229,7 +227,7 @@ while (true) {
 alert( 'Sum: ' + sum );
 ```
 
-The `break` directive is activated in the line `(*)` if the user enters an empty line or cancels the input. It stops the loop immediately, passing the control to the first line after the loop. Namely, `alert`.
+The `break` directive is activated at the line `(*)` if the user enters an empty line or cancels the input. It stops the loop immediately, passing the control to the first line after the loop. Namely, `alert`.
 
 The combination "infinite loop + `break` as needed" is great for situations when the condition must be checked not in the beginning/end of the loop, but in the middle, or even in several places of the body.
 
@@ -239,7 +237,7 @@ The `continue` directive is a "lighter version" of `break`. It doesn't stop the
 
 We can use it if we're done on the current iteration and would like to move on to the next.
 
-The loop above uses `continue` to output only odd values:
+The loop below uses `continue` to output only odd values:
 
 ```js run no-beautify
 for (let i = 0; i < 10; i++) {
@@ -268,11 +266,11 @@ for (let i = 0; i < 10; i++) {
 
 From a technical point of view it's identical to the example above. Surely, we can just wrap the code in the `if` block instead of `continue`.
 
-But as a side-effect we got one more figure brackets nesting level. If the code inside `if` is longer than a few lines, that may decrease the overall readability.
+But as a side-effect we got one more nesting level (the `alert` call inside the curly braces). If the code inside `if` is longer than a few lines, that may decrease the overall readability.
 ````
 
 ````warn header="No `break/continue` to the right side of '?'"
-Please note that syntax constructs that are not expressions cannot be used in `'?'`. In particular, directives `break/continue` are disallowed there.
+Please note that syntax constructs that are not expressions cannot be used with the ternary operator `?`. In particular, directives such as `break/continue` are disallowed there.
 
 For example, if we take this code:
 
@@ -294,7 +292,7 @@ if (i > 5) {
 ...Then it stops working. The code like this will give a syntax error:
 
 
-That's just another reason not to use a question mark operator `'?'` instead of `if`.
+That's just another reason not to use a question mark operator `?` instead of `if`.
 ````
 
 ## Labels for break/continue
@@ -324,7 +322,7 @@ The ordinary `break` after `input` would only break the inner loop. That's not s
 
 A *label* is an identifier with a colon before a loop:
 ```js
-labelName: for(...) {
+labelName: for (...) {
   ...
 }
 ```
@@ -369,7 +367,7 @@ For example, it is impossible to do this:
 ```js
 break label;  // jumps to label? No.
 
-label: for(...)
+label: for (...)
 ```
 
 The call to a `break/continue` is only possible from inside the loop, and the label must be somewhere upwards from the directive.
@@ -381,10 +379,10 @@ We covered 3 types of loops:
 
 - `while` -- The condition is checked before each iteration.
 - `do..while` -- The condition is checked after each iteration.
-- `for(;;)` -- The condition is checked before each iteration, additional settings available.
+- `for (;;)` -- The condition is checked before each iteration, additional settings available.
 
 To make an "infinite" loop, usually the `while(true)` construct is used. Such a loop, just like any other, can be stopped with the `break` directive.
 
 If we don't want to do anything on the current iteration and would like to forward to the next one, the `continue` directive does it.
 
-`Break/continue` support labels before the loop. A label is the only way for `break/continue` to escape the nesting and go to the outer loop.
+`break/continue` support labels before the loop. A label is the only way for `break/continue` to escape the nesting and go to the outer loop.
diff --git a/1-js/02-first-steps/13-switch/article.md b/1-js/02-first-steps/13-switch/article.md
index 0ac71d16..ae114923 100644
--- a/1-js/02-first-steps/13-switch/article.md
+++ b/1-js/02-first-steps/13-switch/article.md
@@ -4,8 +4,6 @@ A `switch` statement can replace multiple `if` checks.
 
 It gives a more descriptive way to compare a value with multiple variants.
 
-[cut]
-
 ## The syntax
 
 The `switch` has one or more `case` blocks and an optional default.
diff --git a/1-js/02-first-steps/14-function-basics/1-if-else-required/task.md b/1-js/02-first-steps/14-function-basics/1-if-else-required/task.md
index 743ba78a..4f69a5c8 100644
--- a/1-js/02-first-steps/14-function-basics/1-if-else-required/task.md
+++ b/1-js/02-first-steps/14-function-basics/1-if-else-required/task.md
@@ -35,4 +35,4 @@ function checkAge(age) {
 }
 ```
 
-Is there any difference in the bahavior of these two variants?
+Is there any difference in the behavior of these two variants?
diff --git a/1-js/02-first-steps/14-function-basics/2-rewrite-function-question-or/task.md b/1-js/02-first-steps/14-function-basics/2-rewrite-function-question-or/task.md
index f70ad6fa..523bb127 100644
--- a/1-js/02-first-steps/14-function-basics/2-rewrite-function-question-or/task.md
+++ b/1-js/02-first-steps/14-function-basics/2-rewrite-function-question-or/task.md
@@ -22,5 +22,5 @@ Rewrite it, to perform the same, but without `if`, in a single line.
 
 Make two variants of `checkAge`:
 
-1. Using a question mark operator `'?'`
+1. Using a question mark operator `?`
 2. Using OR `||`
diff --git a/1-js/02-first-steps/14-function-basics/4-pow/solution.md b/1-js/02-first-steps/14-function-basics/4-pow/solution.md
index 79eb2b44..5ef20c38 100644
--- a/1-js/02-first-steps/14-function-basics/4-pow/solution.md
+++ b/1-js/02-first-steps/14-function-basics/4-pow/solution.md
@@ -13,7 +13,7 @@ function pow(x, n) {
 let x = prompt("x?", '');
 let n = prompt("n?", '');
 
-if (n <= 1) {
+if (n < 1) {
   alert(`Power ${n} is not supported,
     use an integer greater than 0`);
 } else {
diff --git a/1-js/02-first-steps/14-function-basics/4-pow/task.md b/1-js/02-first-steps/14-function-basics/4-pow/task.md
index e4f885a5..f569320c 100644
--- a/1-js/02-first-steps/14-function-basics/4-pow/task.md
+++ b/1-js/02-first-steps/14-function-basics/4-pow/task.md
@@ -9,7 +9,7 @@ Write a function `pow(x,n)` that returns `x` in power `n`. Or, in other words, m
 ```js
 pow(3, 2) = 3 * 3 = 9
 pow(3, 3) = 3 * 3 * 3 = 27
-pow(1, 100) = 1 * 1 * ...*1 = 1
+pow(1, 100) = 1 * 1 * ...* 1 = 1
 ```
 
 Create a web-page that prompts for `x` and `n`, and then shows the result of `pow(x,n)`.
diff --git a/1-js/02-first-steps/14-function-basics/article.md b/1-js/02-first-steps/14-function-basics/article.md
index 35e77b03..9f405128 100644
--- a/1-js/02-first-steps/14-function-basics/article.md
+++ b/1-js/02-first-steps/14-function-basics/article.md
@@ -6,8 +6,6 @@ For example, we need to show a nice-looking message when a visitor logs in, logs
 
 Functions are the main "building blocks" of the program. They allow the code to be called many times without repetition.
 
-[cut]
-
 We've already seen examples of built-in functions, like `alert(message)`, `prompt(message, default)` and `confirm(question)`. But we can create functions of our own as well.
 
 ## Function Declaration
@@ -22,7 +20,7 @@ function showMessage() {
 }
 ```
 
-The `function` keyword goes first, then goes the *name of the function*, then a list of *parameters* in the brackets (empty in the example above) and finally the code of the function, also named "the function body".
+The `function` keyword goes first, then goes the *name of the function*, then a list of *parameters* between the parentheses (empty in the example above) and finally the code of the function, also named "the function body", between curly braces.
 
 ![](function_basics.png)
 
@@ -43,7 +41,7 @@ showMessage();
 
 The call `showMessage()` executes the code of the function. Here we will see the message two times.
 
-This example clearly demonstrates one of the main purposes of functions: to evade code duplication.
+This example clearly demonstrates one of the main purposes of functions: to avoid code duplication.
 
 If we ever need to change the message or the way it is shown, it's enough to modify the code in one place: the function which outputs it.
 
@@ -119,7 +117,7 @@ function showMessage() {
   alert(message);
 }
 
-// the function will create and use it's own userName
+// the function will create and use its own userName
 showMessage();
 
 alert( userName ); // *!*John*/!*, unchanged, the function did not access the outer variable
@@ -130,7 +128,7 @@ Variables declared outside of any function, such as the outer `userName` in the
 
 Global variables are visible from any function (unless shadowed by locals).
 
-Usually, a function declares all variables specific to its task, and global variables only store project-level data, so important that it really must be seen from anywhere. Modern code has few or no globals. Most variables reside in their functions.
+Usually, a function declares all variables specific to its task. Global variables only store project-level data, so when it's important that these variables are accesible from anywhere. Modern code has few or no globals. Most variables reside in their functions.
 ```
 
 ## Parameters
@@ -150,7 +148,7 @@ showMessage('Ann', "What's up?"); // Ann: What's up? (**)
 */!*
 ```
 
-When the function is called in lines `(*)` and `(**)`, the given values are copied to local variables `from` and `next`. Then the function uses them.
+When the function is called in lines `(*)` and `(**)`, the given values are copied to local variables `from` and `text`. Then the function uses them.
 
 Here's one more example: we have a variable `from` and pass it to the function. Please note: the function changes `from`, but the change is not seen outside, because a function always gets a copy of the value:
 
@@ -378,7 +376,7 @@ These examples assume common meanings of prefixes. What they mean for you is det
 ```smart header="Ultrashort function names"
 Functions that are used *very often* sometimes have ultrashort names.
 
-For example, [jQuery](http://jquery.com) framework defines a function `$`, [LoDash](http://lodash.com/) library has it's core function named `_`.
+For example, the [jQuery](http://jquery.com) framework defines a function `$`. The [LoDash](http://lodash.com/) library has its core function named `_`.
 
 These are exceptions. Generally functions names should be concise, but descriptive.
 ```
@@ -426,7 +424,7 @@ function isPrime(n) {
 }
 ```
 
-The second variant is easier to understand isn't it? Instead of the code piece we see a name of the action (`isPrime`). Sometimes people refer to such code as *self-describing*.
+The second variant is easier to understand, isn't it? Instead of the code piece we see a name of the action (`isPrime`). Sometimes people refer to such code as *self-describing*.
 
 So, functions can be created even if we don't intend to reuse them. They structure the code and make it readable.
 
@@ -442,7 +440,7 @@ function name(parameters, delimited, by, comma) {
 
 - Values passed to a function as parameters are copied to its local variables.
 - A function may access outer variables. But it works only from inside out. The code outside of the function doesn't see its local variables.
-- A function can return a value. If it doesn't then its result is `undefined`.
+- A function can return a value. If it doesn't, then its result is `undefined`.
 
 To make the code clean and easy to understand, it's recommended to use mainly local variables and parameters in the function, not outer variables.
 
diff --git a/1-js/02-first-steps/15-function-expressions-arrows/article.md b/1-js/02-first-steps/15-function-expressions-arrows/article.md
index eca7019b..201a1ffe 100644
--- a/1-js/02-first-steps/15-function-expressions-arrows/article.md
+++ b/1-js/02-first-steps/15-function-expressions-arrows/article.md
@@ -2,8 +2,6 @@
 
 In JavaScript, a function is not a "magical language structure", but a special kind of value.
 
-[cut]
-
 The syntax that we used before is called a *Function Declaration*:
 
 ```js
@@ -135,13 +133,11 @@ function showCancel() {
 ask("Do you agree?", showOk, showCancel);
 ```
 
-Before we explore how we can write it in a much shorter way, let's note that in the browser (and on the server-side in some cases) such functions are quite popular.
+Before we explore how we can write it in a much shorter way, let's note that in the browser (and on the server-side in some cases) such functions are quite popular. The major difference between a real-life implementation and the example above is that real-life functions use more complex ways to interact with the user than a simple `confirm`. In the browser, such a function usually draws a nice-looking question window. But that's another story.
 
-The major difference between a real-life implementation and the example above is that real-life functions use more complex ways to interact with the user than a simple `confirm`. In the browser, such a function usually draws a nice-looking question window. But that's another story.
+**The arguments of `ask` are called *callback functions* or just *callbacks*.**
 
-**The arguments of `ask` are called *callback functions* or just *callbacks*. The idea is that we pass a function and expect it to be "called back" in certain circumstances.**
-
-So, `showOk` becomes the callback for the "yes" answer, and `showCancel` for the "no" answer.
+The idea is that we pass a function and expect it to be "called back" later if necessary. In our case, `showOk` becomes the callback for the "yes" answer, and `showCancel` for the "no" answer.
 
 We can use Function Expressions to write the same function much shorter:
 
@@ -160,6 +156,7 @@ ask(
 */!*
 ```
 
+
 Here, functions are declared right inside the `ask(...)` call. They have no name, and so are called *anonymous*. Such functions are not accessible outside of `ask` (because they are not assigned to variables), but that's just what we want here.
 
 Such code appears in our scripts very naturally, it's in the spirit of JavaScript.
@@ -188,9 +185,8 @@ First, the syntax: how to see what is what in the code.
       return a + b;
     }
     ```
-- *Function Expression:* a function, created inside an expression or inside another syntax construct.
-
-    Here, the function is created at the right side of the "assignment expression =":
+- *Function Expression:* a function, created inside an expression or inside another syntax construct. Here, the function is created at the right side of the "assignment expression" `=`:
+    
     ```js
     // Function Expression
     let sum = function(a, b) {
@@ -242,20 +238,18 @@ let sayHi = function(name) {  // (*) no magic any more
 
 Function Expressions are created when the execution reaches them. That would happen only in the line `(*)`. Too late.
 
-
-### Function Declaration in a block
-
-When a Function Declaration is made within a code block, it is visible everywhere inside that block. But not outside of it.
+**When a Function Declaration is made within a code block, it is visible everywhere inside that block. But not outside of it.**
 
 Sometimes that's handy to declare a local function only needed in that block alone. But that feature may also cause problems.
 
-For instance, let's imagine that we need to declare a function `welcome()` depending on the `age` variable that we get in run time. And then we plan to use it some time later.
+For instance, let's imagine that we need to declare a function `welcome()` depending on the `age` variable that we get during runtime. And then we plan to use it some time later.
 
 The code below doesn't work:
 
 ```js run
 let age = prompt("What is your age?", 18);
 
+// conditionally declare a function
 if (age < 18) {
 
   function welcome() {
@@ -270,14 +264,15 @@ if (age < 18) {
 
 }
 
+// ...use it later
 *!*
 welcome(); // Error: welcome is not defined
 */!*
 ```
 
-A Function Declaration is only visible inside the code block in which it resides.
+That's because a Function Declaration is only visible inside the code block in which it resides.
 
-We can call it from within the block, but not from outside:
+Here's another example:
 
 ```js run
 let age = 16; // take 16 as an example
@@ -296,14 +291,13 @@ if (age < 18) {
 */!*
 
 } else {
-                           // \
-  function welcome() {     //  |  
-    alert("Greetings!");   //  |  if age=16, the the execution does not go here,
-  }                        //  |  so this "welcome" is never created
-                           // /
+
+  function welcome() {     //  for age = 16, this "welcome" is never created
+    alert("Greetings!");
+  }
 }
 
-// Here we're out of figure brackets,
+// Here we're out of curly braces,
 // so we can not see Function Declarations made inside of them.
 
 *!*
@@ -313,7 +307,9 @@ welcome(); // Error: welcome is not defined
 
 What can we do to make `welcome` visible outside of `if`?
 
-The correct approach would be to use a Function Expression and assign `welcome` to the variable that is declared outside of `if` and has the proper visibility:
+The correct approach would be to use a Function Expression and assign `welcome` to the variable that is declared outside of `if` and has the proper visibility.
+
+Now it works as intended:
 
 ```js run
 let age = prompt("What is your age?", 18);
@@ -354,7 +350,7 @@ welcome(); // ok now
 ```
 
 
-```smart header="What to choose: Function Declaration or Function Expression?"
+```smart header="When to choose Function Declaration versus Function Expression?"
 As a rule of thumb, when we need to declare a function, the first to consider is Function Declaration syntax, the one we used before. It gives more freedom in how to organize our code, because we can call such functions before they are declared.
 
 It's also a little bit easier to look up `function f(…) {…}` in the code than `let f = function(…) {…}`. Function Declarations are more "eye-catching".
@@ -365,7 +361,7 @@ It's also a little bit easier to look up `function f(…) {…}` in the code tha
 
 ## Arrow functions [#arrow-functions]
 
-There's one more very simple and concise syntax for creating functions. It's called "arrow functions", because it looks like this:
+There's one more very simple and concise syntax for creating functions, that's often better than Function Expressions. It's called "arrow functions", because it looks like this:
 
 
 ```js
@@ -382,37 +378,37 @@ let func = function(arg1, arg2, ...argN) {
 }
 ```
 
-...But much shorter.
+...But much more concise.
 
 Let's see an example:
 
 ```js run
 let sum = (a, b) => a + b;
 
-alert( sum(1, 2) ); // 3
-```
+/* The arrow function is a shorter form of:
 
-Here the arrow function is a shorter form of:
-
-```js
 let sum = function(a, b) {
   return a + b;
 };
+*/
+
+alert( sum(1, 2) ); // 3
+
 ```
 
 If we have only one argument, then parentheses can be omitted, making that even shorter:
 
 ```js run
 // same as
-// let double = function(n) { return n*2 }
+// let double = function(n) { return n * 2 }
 *!*
-let double = n => n*2;
+let double = n => n * 2;
 */!*
 
 alert( double(3) ); // 6
 ```
 
-If there are no arguments, we can insert empty parentheses:
+If there are no arguments, parentheses should be empty (but they should be present):
 
 ```js run
 let sayHi = () => alert("Hello!");
@@ -434,23 +430,23 @@ let welcome = (age < 18) ?
 welcome(); // ok now
 ```
 
-The syntax may appear unfamiliar and not very readable at first, but that quickly changes as the eyes get used to the structure.
+Arrow functions may appear unfamiliar and not very readable at first, but that quickly changes as the eyes get used to the structure.
 
-Arrow functions are very convenient for simple one-line actions, when we're just too lazy to write many words.
+They are very convenient for simple one-line actions, when we're just too lazy to write many words.
 
 ```smart header="Multiline arrow functions"
 
 The examples above took arguments from the left of `=>` and evaluated the right-side expression with them.
 
-Sometimes we need something a little bit more complex, like multiple expressions or statements. It is also possible, but we should enclose them in figure brackets. Then use a normal `return` within them.
+Sometimes we need something a little bit more complex, like multiple expressions or statements. It is also possible, but we should enclose them in curly braces. Then use a normal `return` within them.
 
 Like this:
 
 ```js run
-let sum = (a, b) => {  // the figure bracket opens a multiline function
+let sum = (a, b) => {  // the curly brace opens a multiline function
   let result = a + b;
 *!*
-  return result; // if we use figure brackets, use return to get results
+  return result; // if we use curly braces, use return to get results
 */!*
 };
 
@@ -478,5 +474,5 @@ So we should use a Function Expression only when a Function Declaration is not f
 
 Arrow functions are handy for one-liners. They come in two flavors:
 
-1. Without figure brackets: `(...args) => expression` -- the right side is an expression: the function evaluates it and returns the result.
-2. With figure brackets: `(...args) => { body }` -- brackets allow us to write multiple statements inside the function, but we need an explicit `return` to return something.
+1. Without curly braces: `(...args) => expression` -- the right side is an expression: the function evaluates it and returns the result.
+2. With curly braces: `(...args) => { body }` -- brackets allow us to write multiple statements inside the function, but we need an explicit `return` to return something.
diff --git a/1-js/02-first-steps/16-javascript-specials/article.md b/1-js/02-first-steps/16-javascript-specials/article.md
index 39e75370..44dd8e3e 100644
--- a/1-js/02-first-steps/16-javascript-specials/article.md
+++ b/1-js/02-first-steps/16-javascript-specials/article.md
@@ -2,8 +2,6 @@
 
 This chapter briefly recaps the features of JavaScript that we've learned by now, paying special attention to subtle moments.
 
-[cut]
-
 ## Code structure
 
 Statements are delimited with a semicolon:
@@ -90,7 +88,7 @@ There are 7 data types:
 - `boolean` for logical values: `true/false`,
 - `null` -- a type with a single value `null`, meaning "empty" or "does not exist",
 - `undefined` -- a type with a single value `undefined`, meaning "not assigned",
-- `object` and `symbol` -- for complex data structures and unique identifiers, we didn't learn them yet.
+- `object` and `symbol` -- for complex data structures and unique identifiers, we haven't learnt them yet.
 
 The `typeof` operator returns the type for a value, with two exceptions:
 ```js
@@ -134,7 +132,7 @@ JavaScript supports the following operators:
 Arithmetical
 : Regular: `* + - /`, also `%` for the remainder and `**` for power of a number.
 
-    Binary plus `+` concatenates strings. And if any of the operands is a string, the other one is converted to string too:
+    The binary plus `+` concatenates strings. And if any of the operands is a string, the other one is converted to string too:
 
     ```js run
     alert( '1' + 2 ); // '12', string
@@ -148,7 +146,7 @@ Bitwise
 : Bitwise operators work with integers on bit-level: see the [docs](mdn:/JavaScript/Reference/Operators/Bitwise_Operators) when they are needed.
 
 Ternary
-: The only operator with three parameters: `cond ? resultA : result B`. If `cond` is truthy, returns `resultA`, otherwise `resultB`.
+: The only operator with three parameters: `cond ? resultA : resultB`. If `cond` is truthy, returns `resultA`, otherwise `resultB`.
 
 Logical operators
 : Logical AND `&&` and OR `||` perform short-circuit evaluation and then return the value where it stopped.
@@ -204,7 +202,7 @@ Later we'll study more types of loops to deal with objects.
 
 ## The "switch" construct
 
-The "switch" construct can replace multiple `if` checks. It uses `===` for comparisons.
+The "switch" construct can replace multiple `if` checks. It uses `===` (strict equality) for comparisons.
 
 For instance:
 
@@ -216,7 +214,7 @@ switch (age) {
     alert("Won't work"); // the result of prompt is a string, not a number
 
   case "18":
-    alert("This works!"");
+    alert("This works!");
     break;
 
   default:
@@ -250,7 +248,7 @@ We covered three ways to create a function in JavaScript:
     }
     ```
 
-    Function expression can have a name, like `sum = function name(a, b)`, but that `name` is only visible inside that function.
+    Function expressions can have a name, like `sum = function name(a, b)`, but that `name` is only visible inside that function.
 
 3. Arrow functions:
 
@@ -273,7 +271,7 @@ We covered three ways to create a function in JavaScript:
 
 
 - Functions may have local variables: those declared inside its body. Such variables are only visible inside the function.
-- Parameters can have default values: `function sum(a=1, b=2) {...}`.
+- Parameters can have default values: `function sum(a = 1, b = 2) {...}`.
 - Functions always return something. If there's no `return` statement, then the result is `undefined`.
 
 
diff --git a/1-js/03-code-quality/01-debugging-chrome/article.md b/1-js/03-code-quality/01-debugging-chrome/article.md
index 14efb9a5..d09493a2 100644
--- a/1-js/03-code-quality/01-debugging-chrome/article.md
+++ b/1-js/03-code-quality/01-debugging-chrome/article.md
@@ -6,8 +6,6 @@ All modern browsers and most other environments support "debugging" -- a special
 
 We'll be using Chrome here, because it's probably the most feature-rich in this aspect.
 
-[cut]
-
 ## The "sources" pane
 
 Your Chrome version may look a little bit different, but it still should be obvious what's there.
@@ -28,9 +26,9 @@ Let's click it and select `index.html` and then `hello.js` in the tree view. Her
 
 Here we can see three zones:
 
-1. **Resources zone** lists html, javascript, css and other files including images that are attached to the page. Chrome extensions may appear here too.
-2. **Source zone** shows the source code.
-3. **Information and control zone** is for debugging, we'll explore it soon.
+1. The **Resources zone** lists HTML, JavaScript, CSS and other files, including images that are attached to the page. Chrome extensions may appear here too.
+2. The **Source zone** shows the source code.
+3. The **Information and control zone** is for debugging, we'll explore it soon.
 
 Now you could click the same toggler <span class="devtools" style="background-position:-200px -76px"></span> again to hide the resources list and give the code some space.
 
@@ -46,7 +44,7 @@ For example, here `1+2` results in `3`, and `hello("debugger")` returns nothing,
 
 ## Breakpoints
 
-Let's examine what's going on within the code of the [example page](debugging/index.html). In `hello.js`, click at the line number `4`. Yes, right on the `"4"` digit, not on the code.
+Let's examine what's going on within the code of the [example page](debugging/index.html). In `hello.js`, click at line number `4`. Yes, right on the `4` digit, not on the code.
 
 Congratulations! You've set a breakpoint. Please also click on the number for line `8`.
 
@@ -101,7 +99,7 @@ Please open the informational dropdowns to the right (labeled with arrows). They
 
 1. **`Watch` -- shows current values for any expressions.**
 
-    You can click the plus `+` and input an expression. The debugger will show its value at any moment, automatically recalculating it in in the process of execution.
+    You can click the plus `+` and input an expression. The debugger will show its value at any moment, automatically recalculating it in the process of execution.
 
 2. **`Call Stack` -- shows the nested calls chain.**
 
@@ -123,7 +121,7 @@ Now it's time to *trace* the script.
 There are buttons for it at the top of the right pane. Let's engage them.
 
 <span class="devtools" style="background-position:-7px -76px"></span> -- continue the execution, hotkey `key:F8`.
-: Resumes the execution. If there are no additional breakpoints, then the execution just continues and the debugger looses the control.
+: Resumes the execution. If there are no additional breakpoints, then the execution just continues and the debugger loses control.
 
     Here's what we can see after a click on it:
 
@@ -178,7 +176,7 @@ As we can see, there are three main ways to pause a script:
 
 Then we can examine variables and step on to see where the execution goes wrong.
 
-There are many more options in developer tools than covered here. The full manual is at <https://developers.google.com/web/tools/chrome-devtools>
+There are many more options in developer tools than covered here. The full manual is at <https://developers.google.com/web/tools/chrome-devtools>.
 
 The information from this chapter is enough to begin debugging, but later, especially if you do a lot of browser stuff, please go there and look through more advanced capabilities of developer tools.
 
diff --git a/1-js/03-code-quality/02-coding-style/article.md b/1-js/03-code-quality/02-coding-style/article.md
index 2ea6fb7b..3ab32554 100644
--- a/1-js/03-code-quality/02-coding-style/article.md
+++ b/1-js/03-code-quality/02-coding-style/article.md
@@ -6,8 +6,6 @@ That is actually an art of programming -- to take a complex task and code it in
 
 One thing to help is the good code style.
 
-[cut]
-
 ## Syntax
 
 A cheatsheet with the rules (more details below):
@@ -42,9 +40,9 @@ Now let's discuss the rules and reasons for them in detail.
 
 Nothing is "carved in stone" here. Everything is optional and can be changed: these are coding rules, not religious dogmas.
 
-### Figure brackets
+### Curly braces
 
-In most JavaScript projects figure brackets are written on the same line, not on the new line. A so-called "egyptian" style. There's also a space before an opening bracket.
+In most JavaScript projects curly braces are written on the same line as the corresponding keyword, not on the new line, a so-called "Egyptian" style. There's also a space before an opening bracket.
 
 Like this:
 
@@ -295,7 +293,7 @@ Most linters are integrated with editors: just enable the plugin in the editor a
 For instance, for ESLint you should do the following:
 
 1. Install [Node.JS](https://nodejs.org/).
-2. Install ESLint with the command `npm install -g eslint` (npm is Node.JS package installer).
+2. Install ESLint with the command `npm install -g eslint` (npm is a JavaScript package installer).
 3. Create a config file named `.eslintrc` in the root of your JavaScript project (in the folder that contains all your files).
 
 Here's an example of `.eslintrc`:
@@ -331,6 +329,6 @@ Also certain IDEs support built-in linting, that also may be good, but not so tu
 
 All syntax rules from this chapter and the style guides aim to increase readability, so all of them are debatable.
 
-When we think about "how to write better?", the sole criterion is "what makes the code more readable and easier to understand? what helps to evade errors?" That's the main thing to keep in mind when choosing the style or discussing which one is better.
+When we think about "how to write better?", the sole criterion is "what makes the code more readable and easier to understand? what helps to avoid errors?" That's the main thing to keep in mind when choosing the style or discussing which one is better.
 
 Read style guides to see the latest ideas about that and follow those that you find the best.
diff --git a/1-js/03-code-quality/03-comments/article.md b/1-js/03-code-quality/03-comments/article.md
index fbc49628..744751cc 100644
--- a/1-js/03-code-quality/03-comments/article.md
+++ b/1-js/03-code-quality/03-comments/article.md
@@ -18,7 +18,7 @@ complex;
 code;
 ```
 
-But in a good code the amount of such "explanatory" comments should be minimal. Seriously, a code should be easy to understand without them.
+But in good code the amount of such "explanatory" comments should be minimal. Seriously, code should be easy to understand without them.
 
 There's a great rule about that: "if the code is so unclear that it requires a comment, then maybe it should be rewritten instead".
 
@@ -58,8 +58,9 @@ function showPrimes(n) {
 
 function isPrime(n) {
   for (let i = 2; i < n; i++) {
-    if ( n % i == 0) return false;
+    if (n % i == 0) return false;
   }
+
   return true;
 }
 ```
@@ -112,7 +113,7 @@ function addJuice(container) {
 
 Once again, functions themselves tell what's going on. There's nothing to comment. And also the code structure is better when split. It's clear what every function does, what it takes and what it returns.
 
-In reality, we can't totally evade "explanatory" comments. There are complex algorithms. And there are smart "tweaks" for purposes of optimization. But generally we should try to keep the code simple and self-descriptive.
+In reality, we can't totally avoid "explanatory" comments. There are complex algorithms. And there are smart "tweaks" for purposes of optimization. But generally we should try to keep the code simple and self-descriptive.
 
 ## Good comments
 
@@ -145,7 +146,7 @@ Document a function usage
     Also, there are tools like [JSDoc 3](https://github.com/jsdoc3/jsdoc) that can generate HTML-documentation from the comments. You can read more information about JSDoc at <http://usejsdoc.org/>.
 
 Why is the task solved this way?
-: What's written is important. But what's *not* written maybe even more important to understand what's going on. Why is the task solved exactly this way? The code gives no answer.
+: What's written is important. But what's *not* written may be even more important to understand what's going on. Why is the task solved exactly this way? The code gives no answer.
 
     If there are many ways to solve the task, why this one? Especially when it's not the most obvious one.
 
@@ -157,7 +158,7 @@ Why is the task solved this way?
     Comments that explain the solution are very important. They help to continue development the right way.
 
 Any subtle features of the code? Where they are used?
-: If the code has anything subtle and counter-obvious, it's definitely worth commenting.
+: If the code has anything subtle and counter-intuitive, it's definitely worth commenting.
 
 ## Summary
 
@@ -171,7 +172,7 @@ Good comments allow us to maintain the code well, come back to it after a delay
 - Function usage.
 - Important solutions, especially when not immediately obvious.
 
-**Evade comments:**
+**Avoid comments:**
 
 - That tell "how code works" and "what it does".
 - Put them only if it's impossible to make the code so simple and self-descriptive that it doesn't require those.
diff --git a/1-js/03-code-quality/04-ninja-code/article.md b/1-js/03-code-quality/04-ninja-code/article.md
index 0b97b3ff..4dffbcaf 100644
--- a/1-js/03-code-quality/04-ninja-code/article.md
+++ b/1-js/03-code-quality/04-ninja-code/article.md
@@ -1,15 +1,24 @@
 # Ninja code
 
-Programmer ninjas of the past used these tricks to make code maintainers cry. Code review gurus look for them in test tasks. Novice developers sometimes use them even better than programmer ninjas.
+
+```quote author="Confucius"
+Learning without thought is labor lost; thought without learning is perilous.
+```
+
+Programmer ninjas of the past used these tricks to make sharpen the mind of code maintainers.
+
+Code review gurus look for them in test tasks.
+
+Novice developers sometimes use them even better than programmer ninjas.
 
 Read them carefully and find out who you are -- a ninja, a novice, or maybe a code reviewer?
 
-[cut]
 
 ```warn header="Irony detected"
-These are rules of writing bad code. Just... You know, some people miss the point.
+Many try to follow ninja paths. Few succeed.
 ```
 
+
 ## Brevity is the soul of wit
 
 Make the code as short as possible. Show how smart you are.
@@ -34,7 +43,7 @@ The Dao hides in wordlessness. Only the Dao is well begun and well
 completed.
 ```
 
-Another way to code faster (and much worse!) is to use single-letter variable names everywhere. Like `a`, `b` or `c`.
+Another way to code faster is to use single-letter variable names everywhere. Like `a`, `b` or `c`.
 
 A short variable disappears in the code like a real ninja in the forest. No one will be able to find it using "search" of the editor. And even if someone does, he won't be able to "decipher" what the name `a` or `b` means.
 
@@ -70,19 +79,21 @@ While choosing a name try to use the most abstract word. Like `obj`, `data`, `va
 
     ...But what to do if `data` is already taken? Try `value`, it's also universal. After all, a variable eventually gets a *value*.
 
-- **Name the variable by its type: `str`, `num`...**
+- **Name a variable by its type: `str`, `num`...**
 
-    Give them a try. A young ninja may wonder -- do such names make the code worse? Actually, yes!
+    Give them a try. A young initiate may wonder -- are such names really useful for a ninja? Indeed, they are!
 
-    From one hand, the variable name still means something. It says what's inside the variable: a string, a number or something else. But when an outsider tries to understand the code, he'll be surprised to see that there's actually no information at all!
+    Sure, the variable name still means something. It says what's inside the variable: a string, a number or something else. But when an outsider tries to understand the code, he'll be surprised to see that there's actually no information at all! And will ultimately fail to alter your well-thought code.
 
-    Indeed, the value type is easy to find out by debugging. But what's the meaning of the variable? Which string/number does it store? There's just no way to figure out without a good meditation!
+    The value type is easy to find out by debugging. But what's the meaning of the variable? Which string/number does it store?
 
-- **...But what if there are no more such names?** Just add a letter: `item1, item2, elem5, data1`...
+    There's just no way to figure out without a good meditation!
+
+- **...But what if there are no more such names?** Just add a number: `data1, item2, elem5`...
 
 ## Attention test
 
-Only a truly attentive programmer should be able to understand the code. But how to check that?
+Only a truly attentive programmer should be able to understand your code. But how to check that?
 
 **One of the ways -- use similar variable names, like `date` and `data`.**
 
diff --git a/1-js/03-code-quality/05-testing-mocha/article.md b/1-js/03-code-quality/05-testing-mocha/article.md
index 1b7e52d1..311a0528 100644
--- a/1-js/03-code-quality/05-testing-mocha/article.md
+++ b/1-js/03-code-quality/05-testing-mocha/article.md
@@ -4,8 +4,6 @@ Automated testing will be used in further tasks.
 
 It's actually a part of the "educational minimum" of a developer.
 
-[cut]
-
 ## Why we need tests?
 
 When we write a function, we can usually imagine what it should do: which parameters give which results.
diff --git a/1-js/03-code-quality/06-polyfills/article.md b/1-js/03-code-quality/06-polyfills/article.md
index 37ea9f89..caf0826c 100644
--- a/1-js/03-code-quality/06-polyfills/article.md
+++ b/1-js/03-code-quality/06-polyfills/article.md
@@ -46,7 +46,7 @@ alert('Press the "Play" button in the upper-right corner to run');
 ```
 
 Examples that use modern JS will work only if your browser supports it.
-```
+````
 
 ```offline
 As you're reading the offline version, examples are not runnable. But they usually work :)
diff --git a/1-js/04-object-basics/01-object/3-is-empty/solution.md b/1-js/04-object-basics/01-object/3-is-empty/solution.md
index cd50543e..b3f40e3d 100644
--- a/1-js/04-object-basics/01-object/3-is-empty/solution.md
+++ b/1-js/04-object-basics/01-object/3-is-empty/solution.md
@@ -2,7 +2,7 @@ Just loop over the object and `return false` immediately if there's at least one
 
 ```js
 function isEmpty(obj) {
-  for(let key in obj) {
+  for (let key in obj) {
     return false;
   }
   return true;
diff --git a/1-js/04-object-basics/01-object/5-sum-object/solution.md b/1-js/04-object-basics/01-object/5-sum-object/solution.md
index eb5b176a..63df8784 100644
--- a/1-js/04-object-basics/01-object/5-sum-object/solution.md
+++ b/1-js/04-object-basics/01-object/5-sum-object/solution.md
@@ -4,10 +4,10 @@ let salaries = {
   John: 100,
   Ann: 160,
   Pete: 130
-}
+};
 
 let sum = 0;
-for(let key in salaries) {
+for (let key in salaries) {
   sum += salaries[key];
 }
 
diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md
index ce86f7fb..3014f896 100644
--- a/1-js/04-object-basics/01-object/article.md
+++ b/1-js/04-object-basics/01-object/article.md
@@ -5,11 +5,9 @@ As we know from the chapter <info:types>, there are seven language types in Java
 
 In contrast, objects are used to store keyed collections of various data and more complex entities. In JavaScript, objects penetrate almost every aspect of the language. So we must understand them first before going in-depth anywhere else.
 
-[cut]
-
 An object can be created with figure brackets `{…}` with an optional list of *properties*. A property is a "key: value" pair, where `key` is a string (also called a "property name"), and `value` can be anything.
 
-We can imagine an object as a cabinet with signed files. Every piece of data is stored in it's file by the key. It's easy to find a file by it's name or add/remove a file.
+We can imagine an object as a cabinet with signed files. Every piece of data is stored in its file by the key. It's easy to find a file by its name or add/remove a file.
 
 ![](object.png)
 
@@ -85,7 +83,6 @@ let user = {
 ![](object-user-props.png)
 
 
-````smart header="Trailing comma"
 The last property in the list may end with a comma:
 ```js
 let user = {
@@ -94,7 +91,6 @@ let user = {
 }
 ```
 That is called a "trailing" or "hanging" comma. Makes it easier to add/remove/move around properties, because all lines become alike.
-````
 
 ## Square brackets
 
@@ -189,7 +185,7 @@ We can use more complex expressions inside square brackets:
 ```js
 let fruit = 'apple';
 let bag = {
-  ['apple' + 'Computers']: 5 // bag.appleComputers = 5
+  [fruit + 'Computers']: 5 // bag.appleComputers = 5
 };
 ```
 
@@ -222,7 +218,14 @@ obj.__proto__ = 5;
 alert(obj.__proto__); // [object Object], didn't work as intended
 ```
 
-As we see from the code, the assignment to a primitive `5` is ignored. If we want to store *arbitrary* (user-provided) keys, then such behavior can be the source of bugs and even vulnerabilities, because it's unexpected. There's another data structure [Map](info:map-set-weakmap-weakset), that we'll learn in the chapter <info:map-set-weakmap-weakset>, which supports arbitrary keys.
+As we see from the code, the assignment to a primitive `5` is ignored.
+
+That can become a source of bugs and even vulnerabilies if we intent to store arbitrary key-value pairs in an object, and allow a visitor to specify the keys.
+
+In that case the visitor may choose "__proto__" as the key, and the assignment logic will be ruined (as shown above).
+
+There is a way to make objects treat `__proto__` as a regular property, which we'll cover later, but first we need to know more about objects.
+There's also another data structure [Map](info:map-set-weakmap-weakset), that we'll learn in the chapter <info:map-set-weakmap-weakset>, which supports arbitrary keys.
 ````
 
 
@@ -365,7 +368,7 @@ Also, we could use another variable name here instead of `key`. For instance, `"
 
 ### Ordered like an object
 
-Are objects ordered? In other words, if we loop over an object, do we get all properties in the same order that they are added in it? Can we rely on it?
+Are objects ordered? In other words, if we loop over an object, do we get all properties in the same order they were added? Can we rely on this?
 
 The short answer is: "ordered in a special fashion": integer properties are sorted, others appear in creation order. The details follow.
 
@@ -404,8 +407,8 @@ So, "49" is an integer property name, because when it's transformed to an intege
 ```js run
 // Math.trunc is a built-in function that removes the decimal part
 alert( String(Math.trunc(Number("49"))) ); // "49", same, integer property
-alert( String(Math.trunc(Number("+49"))) ); // "49", not same ⇒ not integer property
-alert( String(Math.trunc(Number("1.2"))) ); // "1", not same ⇒ not integer property
+alert( String(Math.trunc(Number("+49"))) ); // "49", not same "+49" ⇒ not integer property
+alert( String(Math.trunc(Number("1.2"))) ); // "1", not same "1.2" ⇒ not integer property
 ```
 ````
 
@@ -465,7 +468,7 @@ As a result we have two independent variables, each one is storing the string `"
 
 Objects are not like that.
 
-**A variable stores not the object itself, but it's "address in memory", in other words "a reference" to it.**
+**A variable stores not the object itself, but its "address in memory", in other words "a reference" to it.**
 
 Here's the picture for the object:
 
@@ -509,7 +512,7 @@ admin.name = 'Pete'; // changed by the "admin" reference
 alert(*!*user.name*/!*); // 'Pete', changes are seen from the "user" reference
 ```
 
-The example above demonstrates that there is only one object. Like if we had a cabinet with two keys and used one of them (`admin`) to get into it. Then, if we later use the other key (`user`) we would see changes.
+The example above demonstrates that there is only one object. As if we had a cabinet with two keys and used one of them (`admin`) to get into it. Then, if we later use the other key (`user`) we would see changes.
 
 ### Comparison by reference
 
@@ -536,7 +539,7 @@ let b = {}; // two independent objects
 alert( a == b ); // false
 ```
 
-For comparisons like `obj1 > obj2` or for a comparison against a primitive `obj == 5`, objects are converted to primitives. We'll study how object conversions work very soon, but to say the truth, such comparisons are necessary very rarely and usually are a result of a coding mistake.
+For comparisons like `obj1 > obj2` or for a comparison against a primitive `obj == 5`, objects are converted to primitives. We'll study how object conversions work very soon, but to tell the truth, such comparisons are necessary very rarely and usually are a result of a coding mistake.
 
 ### Const object
 
@@ -696,9 +699,9 @@ user.sizes.width++;       // change a property from one place
 alert(clone.sizes.width); // 51, see the result from the other one
 ```
 
-To fix that, we should use the cloning loop that examines each value of `user[key]` and, if it's an object, then replicate it's structure as well. That is called a "deep cloning".
+To fix that, we should use the cloning loop that examines each value of `user[key]` and, if it's an object, then replicate its structure as well. That is called a "deep cloning".
 
-There's a standard algorithm for deep cloning that handles the case above and more complex cases, called the [Structured cloning algorithm](https://w3c.github.io/html/infrastructure.html#internal-structured-cloning-algorithm). In order not to reinvent the wheel, we can use a working implementation of it from the JavaScript library [lodash](https://lodash.com), the method is called [_.cloneDeep(obj)](https://lodash.com/docs#cloneDeep).
+There's a standard algorithm for deep cloning that handles the case above and more complex cases, called the [Structured cloning algorithm](http://w3c.github.io/html/infrastructure.html#safe-passing-of-structured-data). In order not to reinvent the wheel, we can use a working implementation of it from the JavaScript library [lodash](https://lodash.com), the method is called [_.cloneDeep(obj)](https://lodash.com/docs#cloneDeep).
 
 
 
@@ -734,4 +737,4 @@ There are many other kinds of objects in JavaScript:
 
 They have their special features that we'll study later. Sometimes people say something like "Array type" or "Date type", but formally they are not types of their own, but belong to a single "object" data type. And they extend it in various ways.
 
-Objects in JavaScript are very powerful. Here we've just scratched the surface of the topic that is really huge. We'll be closely working with objects and learning more about them in further parts of the tutorial.
+Objects in JavaScript are very powerful. Here we've just scratched the surface of a topic that is really huge. We'll be closely working with objects and learning more about them in further parts of the tutorial.
diff --git a/1-js/04-object-basics/02-garbage-collection/article.md b/1-js/04-object-basics/02-garbage-collection/article.md
index 6796c43e..27682ef4 100644
--- a/1-js/04-object-basics/02-garbage-collection/article.md
+++ b/1-js/04-object-basics/02-garbage-collection/article.md
@@ -4,8 +4,6 @@ Memory management in JavaScript is performed automatically and invisibly to us.
 
 What happens when something is not needed any more? How does the JavaScript engine discover it and clean it up?
 
-[cut]
-
 ## Reachability
 
 The main concept of memory management in JavaScript is *reachability*.
diff --git a/1-js/04-object-basics/03-symbol/article.md b/1-js/04-object-basics/03-symbol/article.md
index 47fdc28b..ba398941 100644
--- a/1-js/04-object-basics/03-symbol/article.md
+++ b/1-js/04-object-basics/03-symbol/article.md
@@ -5,22 +5,27 @@ By specification, object property keys may be either of string type, or of symbo
 
 Till now we've only seen strings. Now let's see the advantages that symbols can give us.
 
-[cut]
-
 ## Symbols
 
-"Symbol" value represents an unique identifier with a given name.
+"Symbol" value represents a unique identifier.
 
-A value of this type can be created using `Symbol(name)`:
+A value of this type can be created using `Symbol()`:
 
 ```js
-// id is a symbol with the name "id"
+// id is a new symbol
+let id = Symbol();
+```
+
+We can also give symbol a description (also called a symbol name), mostly useful for debugging purposes:
+
+```js
+// id is a symbol with the description "id"
 let id = Symbol("id");
 ```
 
-Symbols are guaranteed to be unique. Even if we create many symbols with the same name, they are different values.
+Symbols are guaranteed to be unique. Even if we create many symbols with the same description, they are different values. The description is just a label that doesn't affect anything.
 
-For instance, here are two symbols with the same name -- they are not equal:
+For instance, here are two symbols with the same description -- they are not equal:
 
 ```js run
 let id1 = Symbol("id");
@@ -56,13 +61,11 @@ alert(id.toString()); // Symbol(id), now it works
 That's a "language guard" against messing up, because strings and symbols are fundamentally different and should not occasionally convert one into another.
 ````
 
-
-
 ## "Hidden" properties
 
 Symbols allow us to create "hidden" properties of an object, that no other part of code can occasionally access or overwrite.
 
-For instance, if we want to store an "identifier" for the object `user`, we can create a symbol with the name `id` for it:
+For instance, if we want to store an "identifier" for the object `user`, we can use a symbol as a key for it:
 
 ```js run
 let user = { name: "John" };
@@ -72,11 +75,13 @@ user[id] = "ID Value";
 alert( user[id] ); // we can access the data using the symbol as the key
 ```
 
-Now let's imagine that another script wants to have its own "id" property inside `user`, for its own purposes. That may be another JavaScript library, so the scripts are completely unaware of each other.
+What's the benefit over using `Symbol("id")` over a string `"id"`?
 
-No problem. It can create its own `Symbol("id")`.
+Let's make the example a bit deeper to see that.
 
-The script:
+Imagine that another script wants to have its own "id" property inside `user`, for its own purposes. That may be another JavaScript library, so the scripts are completely unaware of each other.
+
+Then that script can create its own `Symbol("id")`, like this:
 
 ```js
 // ...
@@ -87,7 +92,7 @@ user[id] = "Their id value";
 
 There will be no conflict, because symbols are always different, even if they have the same name.
 
-Please note that if we used a string `"id"` instead of a symbol for the same purpose, then there *would* be a conflict:
+Now note that if we used a string `"id"` instead of a symbol for the same purpose, then there *would* be a conflict:
 
 ```js run
 let user = { name: "John" };
@@ -134,7 +139,7 @@ let user = {
 };
 
 *!*
-for(let key in user) alert(key); // name, age (no symbols)
+for (let key in user) alert(key); // name, age (no symbols)
 */!*
 
 // the direct access by the symbol works
@@ -176,25 +181,27 @@ alert( obj[0] ); // test (same property)
 
 ## Global symbols
 
-As we've seen, usually all symbols are different, even if they have the same name. But sometimes we want same-named symbols to be the same entities.
+As we've seen, usually all symbols are different, even if they have the same names. But sometimes we want same-named symbols to be same entities.
 
 For instance, different parts of our application want to access symbol `"id"` meaning exactly the same property.
 
 To achieve that, there exists a *global symbol registry*. We can create symbols in it and access them later, and it guarantees that repeated accesses by the same name return exactly the same symbol.
 
-In order to create or read a symbol in the registry, use `Symbol.for(name)`.
+In order to create or read a symbol in the registry, use `Symbol.for(key)`.
+
+That call checks the global registry, and if there's a symbol described as `key`, then returns it, otherwise creates a new symbol `Symbol(key)` and stores it in the registry by the given `key`.
 
 For instance:
 
 ```js run
 // read from the global registry
-let name = Symbol.for("name"); // if the symbol did not exist, it is created
+let id = Symbol.for("id"); // if the symbol did not exist, it is created
 
 // read it again
-let nameAgain = Symbol.for("name");
+let idAgain = Symbol.for("id");
 
 // the same symbol
-alert( name === nameAgain ); // true
+alert( id === idAgain ); // true
 ```
 
 Symbols inside the registry are called *global symbols*. If we want an application-wide symbol, accessible everywhere in the code -- that's what they are for.
@@ -207,7 +214,7 @@ In JavaScript, as we can see, that's right for global symbols.
 
 ### Symbol.keyFor
 
-For global symbols, not only `Symbol.for(name)` returns a symbol by name, but there's a reverse call: `Symbol.keyFor(sym)`, that does the reverse: returns a name by a global symbol.
+For global symbols, not only `Symbol.for(key)` returns a symbol by name, but there's a reverse call: `Symbol.keyFor(sym)`, that does the reverse: returns a name by a global symbol.
 
 For instance:
 
@@ -220,20 +227,16 @@ alert( Symbol.keyFor(sym) ); // name
 alert( Symbol.keyFor(sym2) ); // id
 ```
 
-The `Symbol.keyFor` internally uses the global symbol registry to look up the name for the symbol. So it doesn't work for non-global symbols. If the symbol is not global, it won't be able to find it and return `undefined`.
+The `Symbol.keyFor` internally uses the global symbol registry to look up the key for the symbol. So it doesn't work for non-global symbols. If the symbol is not global, it won't be able to find it and return `undefined`.
 
 For instance:
 
 ```js run
 alert( Symbol.keyFor(Symbol.for("name")) ); // name, global symbol
 
-alert( Symbol.keyFor(Symbol("name2")) ); // undefined, non-global symbol
+alert( Symbol.keyFor(Symbol("name2")) ); // undefined, the argument isn't a global symbol
 ```
 
-So, for global symbols the name may be indeed helpful, as we can get a symbol by id.
-
-And for non-global symbols the name is only used for debugging purposes, like printing out a symbol.
-
 ## System symbols
 
 There exist many "system" symbols that JavaScript uses internally, and we can use them to fine-tune various aspects of our objects.
@@ -254,9 +257,9 @@ Other symbols will also become familiar when we study the corresponding language
 
 `Symbol` is a primitive type for unique identifiers.
 
-Symbols are created with `Symbol(name)` call.
+Symbols are created with `Symbol()` call with an optional description.
 
-Symbols are always different values, even if they have the same name. If we want same-named symbols to be equal, then we should use the global registry: `Symbol.for(name)` returns (creates if needed) a global symbol with the given name. Multiple calls of `Symbol.for` return exactly the same symbol.
+Symbols are always different values, even if they have the same name. If we want same-named symbols to be equal, then we should use the global registry: `Symbol.for(key)` returns (creates if needed) a global symbol with `key` as the name. Multiple calls of `Symbol.for` return exactly the same symbol.
 
 Symbols have two main use cases:
 
diff --git a/1-js/04-object-basics/04-object-methods/article.md b/1-js/04-object-basics/04-object-methods/article.md
index c3a2eb62..f6e8728f 100644
--- a/1-js/04-object-basics/04-object-methods/article.md
+++ b/1-js/04-object-basics/04-object-methods/article.md
@@ -13,8 +13,6 @@ And, in the real world, a user can *act*: select something from the shopping car
 
 Actions are represented in JavaScript by functions in properties.
 
-[cut]
-
 ## Method examples
 
 For the start, let's teach the `user` to say hello:
@@ -314,11 +312,11 @@ The result of a property access `user.hi` is not a function, but a value of Refe
 (user, "hi", true)
 ```
 
-When parentheses `()` are called on the Reference Type, they receive the full information about the object and it's method, and can set the right `this` (`=user` in this case).
+When parentheses `()` are called on the Reference Type, they receive the full information about the object and its method, and can set the right `this` (`=user` in this case).
 
 Any other operation like assignment `hi = user.hi` discards the reference type as a whole, takes the value of `user.hi` (a function) and passes it on. So any further operation "loses" `this`.
 
-So, as the result, the value of `this` is only passed the right way if the function is called directly using a dot `obj.method()` or square brackets `obj[method]()` syntax (they do the same here).
+So, as the result, the value of `this` is only passed the right way if the function is called directly using a dot `obj.method()` or square brackets `obj[method]()` syntax (they do the same here). Later in this tutorial, we will learn various ways to solve this problem such as [func.bind()](/bind#solution-2-bind).
 
 ## Arrow functions have no "this"
 
diff --git a/1-js/04-object-basics/05-object-toprimitive/article.md b/1-js/04-object-basics/05-object-toprimitive/article.md
index 943fd022..a44cf4f4 100644
--- a/1-js/04-object-basics/05-object-toprimitive/article.md
+++ b/1-js/04-object-basics/05-object-toprimitive/article.md
@@ -7,8 +7,6 @@ There are special methods in objects that do the conversion.
 
 In the chapter <info:type-conversions> we've seen the rules for numeric, string and boolean conversions of primitives. But we left a gap for objects. Now, as we know about methods and symbols it becomes possible to close it.
 
-[cut]
-
 For objects, there's no to-boolean conversion, because all objects are `true` in a boolean context. So there are only string and numeric conversions.
 
 The numeric conversion happens when we subtract objects or apply mathematical functions. For instance, `Date` objects (to be covered in the chapter <info:date>) can be subtracted, and the result of `date1 - date2` is the time difference between two dates.
@@ -213,7 +211,7 @@ For instance:
 ```smart header="Historical notes"
 For historical reasons, methods `toString` or `valueOf` *should* return a primitive: if any of them returns an object, then there's no error, but that object is ignored (like if the method didn't exist).
 
-In contrast, `Symbol.toPrimitive` *must* return an primitive, otherwise there will be an error.
+In contrast, `Symbol.toPrimitive` *must* return a primitive, otherwise, there will be an error.
 ```
 
 ## Summary
diff --git a/1-js/04-object-basics/06-constructor-new/article.md b/1-js/04-object-basics/06-constructor-new/article.md
index 4d77d608..5fe6e5d9 100644
--- a/1-js/04-object-basics/06-constructor-new/article.md
+++ b/1-js/04-object-basics/06-constructor-new/article.md
@@ -4,8 +4,6 @@ The regular `{...}` syntax allows to create one object. But often we need to cre
 
 That can be done using constructor functions and the `"new"` operator.
 
-[cut]
-
 ## Constructor function
 
 Constructor functions technically are regular functions. There are two conventions though:
@@ -87,6 +85,10 @@ The constructor can't be called again, because it is not saved anywhere, just cr
 
 ## Dual-syntax constructors: new.target
 
+```smart header="Advanced stuff"
+The syntax from this section is rarely used, skip it unless you want to know everything.
+```
+
 Inside a function, we can check whether it was called with `new` or without it, using a special `new.target` property.
 
 It is empty for regular calls and equals the function if called with `new`:
@@ -96,14 +98,18 @@ function User() {
   alert(new.target);
 }
 
-// without new:
+// without "new":
+*!*
 User(); // undefined
+*/!*
 
-// with new:
+// with "new":
+*!*
 new User(); // function User { ... }
+*/!*
 ```
 
-That can be used to allow both `new` and regular syntax to work the same:
+That can be used to allow both `new` and regular calls to work the same. That is, create the same object:
 
 ```js run
 function User(name) {
@@ -118,7 +124,9 @@ let john = User("John"); // redirects call to new User
 alert(john.name); // John
 ```
 
-This approach is sometimes used in libraries to make the syntax more flexible. Probably not a good thing to use everywhere though, because omitting `new` makes it a bit less obvious what's going on. With `new` we all know that the new object is being created, that's a good thing.
+This approach is sometimes used in libraries to make the syntax more flexible. So that people may call the function with or without `new`, and it still works.
+
+Probably not a good thing to use everywhere though, because omitting `new` makes it a bit less obvious what's going on. With `new` we all know that the new object is being created.
 
 ## Return from constructors
 
diff --git a/1-js/05-data-types/01-primitives-methods/article.md b/1-js/05-data-types/01-primitives-methods/article.md
index c583eced..e9075ef0 100644
--- a/1-js/05-data-types/01-primitives-methods/article.md
+++ b/1-js/05-data-types/01-primitives-methods/article.md
@@ -4,8 +4,6 @@ JavaScript allows us to work with primitives (strings, numbers etc) as if they w
 
 They also provide methods to call and such. We will study those soon, but first we'll see how it works, because, of course, primitives are not objects (and here we will make it even more clear).
 
-[cut]
-
 Let's look at the key distinction between primitives and objects.
 
 A primitive
@@ -70,7 +68,7 @@ So primitives can provide methods, but they still remain lightweight.
 
 The JavaScript engine highly optimizes this process. It may even skip the creation of the extra object at all. But it must still adhere to the specification and behave as if it creates one.
 
-A number has methods of it's own, for instance, [toFixed(n)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed) rounds the number to the given precision:
+A number has methods of its own, for instance, [toFixed(n)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed) rounds the number to the given precision:
 
 ```js run
 let n = 1.23456;
diff --git a/1-js/05-data-types/02-number/2-why-rounded-down/solution.md b/1-js/05-data-types/02-number/2-why-rounded-down/solution.md
index 2152d73d..a17a4671 100644
--- a/1-js/05-data-types/02-number/2-why-rounded-down/solution.md
+++ b/1-js/05-data-types/02-number/2-why-rounded-down/solution.md
@@ -28,6 +28,6 @@ Note that `63.5` has no precision loss at all. That's because the decimal part `
 
 
 ```js run
-alert( Math.round(6.35 * 10) / 10); // 6.35 -> 63.5 -> 63(rounded) -> 6.3
+alert( Math.round(6.35 * 10) / 10); // 6.35 -> 63.5 -> 64(rounded) -> 6.4
 ```
 
diff --git a/1-js/05-data-types/02-number/8-random-min-max/task.md b/1-js/05-data-types/02-number/8-random-min-max/task.md
index cde399db..7037cfcb 100644
--- a/1-js/05-data-types/02-number/8-random-min-max/task.md
+++ b/1-js/05-data-types/02-number/8-random-min-max/task.md
@@ -15,5 +15,3 @@ alert( random(1, 5) ); // 1.2345623452
 alert( random(1, 5) ); // 3.7894332423
 alert( random(1, 5) ); // 4.3435234525
 ```
-
-You can use the solution of the [previous task](info:task/random-min-max) as the base.
\ No newline at end of file
diff --git a/1-js/05-data-types/02-number/9-random-int-min-max/solution.md b/1-js/05-data-types/02-number/9-random-int-min-max/solution.md
index 1b007032..0950ff81 100644
--- a/1-js/05-data-types/02-number/9-random-int-min-max/solution.md
+++ b/1-js/05-data-types/02-number/9-random-int-min-max/solution.md
@@ -27,7 +27,7 @@ Now we can clearly see that `1` gets twice less values than `2`. And the same wi
 
 # The correct solution
 
-There are many correct solutions to the task. One of them is to adjust interval borders. To ensure the same intervals, we can generate values from `0.5 to 2.5`, thus adding the required probabilities to the edges:
+There are many correct solutions to the task. One of them is to adjust interval borders. To ensure the same intervals, we can generate values from `0.5 to 3.5`, thus adding the required probabilities to the edges:
 
 ```js run
 *!*
diff --git a/1-js/05-data-types/02-number/9-random-int-min-max/task.md b/1-js/05-data-types/02-number/9-random-int-min-max/task.md
index 71d83f01..29341b2a 100644
--- a/1-js/05-data-types/02-number/9-random-int-min-max/task.md
+++ b/1-js/05-data-types/02-number/9-random-int-min-max/task.md
@@ -15,4 +15,6 @@ Examples of its work:
 alert( random(1, 5) ); // 1
 alert( random(1, 5) ); // 3
 alert( random(1, 5) ); // 5
-```
\ No newline at end of file
+```
+
+You can use the solution of the [previous task](info:task/random-min-max) as the base.
diff --git a/1-js/05-data-types/02-number/article.md b/1-js/05-data-types/02-number/article.md
index 0a9feb1c..16e4275e 100644
--- a/1-js/05-data-types/02-number/article.md
+++ b/1-js/05-data-types/02-number/article.md
@@ -249,10 +249,10 @@ Can we work around the problem? Sure, there're a number of ways:
 2. We can temporarily turn numbers into integers for the maths and then revert it back. It works like this:
 
     ```js run
-    alert( (0.1*10 + 0.2*10) / 10 ); // 0.3
+    alert( (0.1 * 10 + 0.2 * 10) / 10 ); // 0.3
     ```
 
-    This works because when we do `0.1*10 = 1` and `0.2 * 10 = 2` then both numbers become integers, and there's no precision loss. 
+    This works because when we do `0.1 * 10 = 1` and `0.2 * 10 = 2` then both numbers become integers, and there's no precision loss. 
 
 3. If we were dealing with a shop, then the most radical solution would be to store all prices in cents and use no fractions at all. But what if we apply a discount of 30%? In practice, totally evading fractions is rarely feasible, so the solutions above help avoid this pitfall.
 
@@ -270,7 +270,7 @@ JavaScript doesn't trigger an error in such events. It does its best to fit the
 ````
 
 ```smart header="Two zeroes"
-Another funny consequence of the internal representation of numbers is the existance of two zeroes: `0` and `-0`.
+Another funny consequence of the internal representation of numbers is the existence of two zeroes: `0` and `-0`.
 
 That's because a sign is represented by a single bit, so every number can be positive or negative, including a zero. 
 
diff --git a/1-js/05-data-types/03-string/3-truncate/_js.view/test.js b/1-js/05-data-types/03-string/3-truncate/_js.view/test.js
index c252f16b..99149233 100644
--- a/1-js/05-data-types/03-string/3-truncate/_js.view/test.js
+++ b/1-js/05-data-types/03-string/3-truncate/_js.view/test.js
@@ -1,5 +1,5 @@
 describe("truncate", function() {
-  it("truncate the long string to the given lenth (including the ellipsis)", function() {
+  it("truncate the long string to the given length (including the ellipsis)", function() {
     assert.equal(
       truncate("What I'd like to tell on this topic is:", 20),
       "What I'd like to te…"
@@ -13,4 +13,4 @@ describe("truncate", function() {
     );
   });
 
-});
\ No newline at end of file
+});
diff --git a/1-js/05-data-types/03-string/article.md b/1-js/05-data-types/03-string/article.md
index 0258675e..8b169470 100644
--- a/1-js/05-data-types/03-string/article.md
+++ b/1-js/05-data-types/03-string/article.md
@@ -4,8 +4,6 @@ In JavaScript, the textual data is stored as strings. There is no separate type
 
 The internal format for strings is always [UTF-16](https://en.wikipedia.org/wiki/UTF-16), it is not tied to the page encoding.
 
-[cut]
-
 ## Quotes
 
 Let's recall the kinds of quotes.
@@ -19,7 +17,7 @@ let double = "double-quoted";
 let backticks = `backticks`;
 ```
 
-Single and double quotes are essentially the same. Backticks however allow us to embed any expression into the string, including function calls:
+Single and double quotes are essentially the same. Backticks, however, allow us to embed any expression into the string, including function calls:
 
 ```js run
 function sum(a, b) {
@@ -49,7 +47,7 @@ let guestList = "Guests:  // Error: Unexpected token ILLEGAL
 
 Single and double quotes come from ancient times of language creation when the need for multiline strings was not taken into account. Backticks appeared much later and thus are more versatile.
 
-Backticks also allow us to specify a "template function" before the first backtick. The syntax is: <code>func&#96;string&#96;</code>. The function `func` is called automatically, receives the string and embedded expressions and can process them. You can read more about it in the [docs](mdn:JavaScript/Reference/Template_literals#Tagged_template_literals). This is called "tagged templates". This feature makes it easier to wrap strings into custom templating or other functionality, but it is rarely used.
+Backticks also allow us to specify a "template function" before the first backtick. The syntax is: <code>func&#96;string&#96;</code>. The function `func` is called automatically, receives the string and embedded expressions and can process them. You can read more about it in the [docs](mdn:/JavaScript/Reference/Template_literals#Tagged_template_literals). This is called "tagged templates". This feature makes it easier to wrap strings into custom templating or other functionality, but it is rarely used.
 
 
 ## Special characters
@@ -88,8 +86,8 @@ Examples with unicode:
 
 ```js run
 alert( "\u00A9" ); // ©
-alert( "\u{20331}" ); // 𠌱, a rare chinese hieroglyph (long unicode)
-alert( "\u{1F60D}"); // a smiling face sumbol (another long unicode)
+alert( "\u{20331}" ); // 佫, a rare chinese hieroglyph (long unicode)
+alert( "\u{1F60D}" ); // 😍, a smiling face symbol (another long unicode)
 ```
 
 All special characters start with a backslash character `\`. It is also called an "escape character".
@@ -166,7 +164,7 @@ alert( str.charAt(1000) ); // '' (an empty string)
 We can also iterate over characters using `for..of`:
 
 ```js run
-for(let char of "Hello") {
+for (let char of "Hello") {
   alert(char); // H,e,l,l,o (char becomes "H", then "e", then "l" etc)
 }
 ```
@@ -236,7 +234,7 @@ alert( str.indexOf("id") ); // 1, "id" is found at the position 1 (..idget with
 
 The optional second parameter allows us to search starting from the given position.
 
-For instance, the first occurence of `"id"` is at position `1`. To look for the next occurence, let's start the search from position `2`:
+For instance, the first occurrence of `"id"` is at position `1`. To look for the next occurrence, let's start the search from position `2`:
 
 ```js run
 let str = 'Widget with id';
@@ -280,7 +278,7 @@ while ((pos = str.indexOf(target, pos + 1)) != -1) {
 ```smart header="`str.lastIndexOf(pos)`"
 There is also a similar method [str.lastIndexOf(pos)](mdn:js/String/lastIndexOf) that searches from the end of a string to its beginning.
 
-It would list the occurences in the reverse order.
+It would list the occurrences in the reverse order.
 ```
 
 There is a slight inconvenience with `indexOf` in the `if` test. We can't put it in the `if` like this:
@@ -379,8 +377,8 @@ There are 3 methods in JavaScript to get a substring: `substring`, `substr` and
 
     ```js run
     let str = "stringify";
-    alert( str.slice(0,5) ); // 'strin', the substring from 0 to 5 (not including 5)
-    alert( str.slice(0,1) ); // 's', from 0 to 1, but not including 1, so only character at 0
+    alert( str.slice(0, 5) ); // 'strin', the substring from 0 to 5 (not including 5)
+    alert( str.slice(0, 1) ); // 's', from 0 to 1, but not including 1, so only character at 0
     ```
 
     If there is no second argument, then `slice` goes till the end of the string:
@@ -445,7 +443,7 @@ Let's recap these methods to avoid any confusion:
 
 | method | selects... | negatives |
 |--------|-----------|-----------|
-| `slice(start, end)` | from `start` to `end` | allows negatives |
+| `slice(start, end)` | from `start` to `end` (not including `end`) | allows negatives |
 | `substring(start, end)` | between `start` and `end` | negative values mean `0` |
 | `substr(start, length)` | from `start` get `length` characters | allows negative `start` |
 
@@ -548,7 +546,7 @@ For instance:
 alert( 'Österreich'.localeCompare('Zealand') ); // -1
 ```
 
-This method actually has two additional arguments specified in [the documentation](mdn:js/String/localeCompare), which allow it to specify the language (by default taken from the environment) and setup additional rules like case sensivity or should `"a"` and `"á"` be treated as the same etc.
+This method actually has two additional arguments specified in [the documentation](mdn:js/String/localeCompare), which allows it to specify the language (by default taken from the environment) and setup additional rules like case sensitivity or should `"a"` and `"á"` be treated as the same etc.
 
 ## Internals, Unicode
 
diff --git a/1-js/05-data-types/04-array/2-create-array/solution.md b/1-js/05-data-types/04-array/2-create-array/solution.md
index 24351434..eec9055e 100644
--- a/1-js/05-data-types/04-array/2-create-array/solution.md
+++ b/1-js/05-data-types/04-array/2-create-array/solution.md
@@ -3,7 +3,7 @@
 ```js run
 let styles = ["Jazz", "Blues"];
 styles.push("Rock-n-Roll");
-styles[(styles.length + 1) / 2] = "Classics";
+styles[Math.floor((styles.length - 1) / 2)] = "Classics";
 alert( styles.shift() );
 styles.unshift("Rap", "Reggie");
 ```
diff --git a/1-js/05-data-types/04-array/2-create-array/task.md b/1-js/05-data-types/04-array/2-create-array/task.md
index e6dab6a9..3e930079 100644
--- a/1-js/05-data-types/04-array/2-create-array/task.md
+++ b/1-js/05-data-types/04-array/2-create-array/task.md
@@ -10,7 +10,7 @@ Let's try 5 array operations.
 2. Append "Rock-n-Roll" to the end.
 3. Replace the value in the middle by "Classics". Your code for finding the middle value should work for any arrays with odd length.
 4. Strip off the first value of the array and show it.
-5. Prepend `Rap` and `Reggie` to the array.
+5. Prepend `Rap` and `Reggae` to the array.
 
 The array in the process:
 
@@ -19,6 +19,6 @@ Jazz, Blues
 Jazz, Bues, Rock-n-Roll
 Jazz, Classics, Rock-n-Roll
 Classics, Rock-n-Roll
-Rap, Reggie, Classics, Rock-n-Roll
+Rap, Reggae, Classics, Rock-n-Roll
 ```
 
diff --git a/1-js/04-object-basics/06-constructor-new/4-calculator-extendable/_js.view/solution.js b/1-js/05-data-types/04-array/6-calculator-extendable/_js.view/solution.js
similarity index 100%
rename from 1-js/04-object-basics/06-constructor-new/4-calculator-extendable/_js.view/solution.js
rename to 1-js/05-data-types/04-array/6-calculator-extendable/_js.view/solution.js
diff --git a/1-js/04-object-basics/06-constructor-new/4-calculator-extendable/_js.view/test.js b/1-js/05-data-types/04-array/6-calculator-extendable/_js.view/test.js
similarity index 100%
rename from 1-js/04-object-basics/06-constructor-new/4-calculator-extendable/_js.view/test.js
rename to 1-js/05-data-types/04-array/6-calculator-extendable/_js.view/test.js
diff --git a/1-js/04-object-basics/06-constructor-new/4-calculator-extendable/solution.md b/1-js/05-data-types/04-array/6-calculator-extendable/solution.md
similarity index 100%
rename from 1-js/04-object-basics/06-constructor-new/4-calculator-extendable/solution.md
rename to 1-js/05-data-types/04-array/6-calculator-extendable/solution.md
diff --git a/1-js/04-object-basics/06-constructor-new/4-calculator-extendable/task.md b/1-js/05-data-types/04-array/6-calculator-extendable/task.md
similarity index 84%
rename from 1-js/04-object-basics/06-constructor-new/4-calculator-extendable/task.md
rename to 1-js/05-data-types/04-array/6-calculator-extendable/task.md
index 1f6368c0..cc5453ce 100644
--- a/1-js/04-object-basics/06-constructor-new/4-calculator-extendable/task.md
+++ b/1-js/05-data-types/04-array/6-calculator-extendable/task.md
@@ -17,7 +17,7 @@ The task consists of two parts.
 
     alert( calc.calculate("3 + 7") ); // 10
     ```
-2. Then add the method `addOperator(name, func)` that teaches the calculator a new operation. It takes the operator `name` and the two-argument function `func(a,b)` that implements it.
+2. Then add the method `addMethod(name, func)` that teaches the calculator a new operation. It takes the operator `name` and the two-argument function `func(a,b)` that implements it.
 
     For instance, let's add the multiplication `*`, division `/` and power `**`:
 
diff --git a/1-js/05-data-types/04-array/article.md b/1-js/05-data-types/04-array/article.md
index 781699f7..7d78ecd8 100644
--- a/1-js/05-data-types/04-array/article.md
+++ b/1-js/05-data-types/04-array/article.md
@@ -8,8 +8,6 @@ It is not convenient to use an object here, because it provides no methods to ma
 
 There exists a special data structure named `Array`, to store ordered collections. 
 
-[cut]
-
 ## Declaration
 
 There are two syntaxes for creating an empty array:
@@ -113,7 +111,7 @@ There's another use case for arrays -- the data structure named [stack](https://
 It supports two operations:
 
 - `push` adds an element to the end.
-- `pop` takes an element to the end.
+- `pop` takes an element from the end.
 
 So new elements are added or taken always from the "end".
 
@@ -297,7 +295,7 @@ But for arrays there is another form of loop, `for..of`:
 let fruits = ["Apple", "Orange", "Plum"];
 
 // iterates over array elements
-for(let fruit of fruits) {
+for (let fruit of fruits) {
   alert( fruit ); 
 }
 ```
@@ -356,7 +354,7 @@ arr.length = 5; // return length back
 alert( arr[3] ); // undefined: the values do not return
 ```
 
-So, the simplest way to clear the array is: `arr.length=0`.
+So, the simplest way to clear the array is: `arr.length = 0;`.
 
 
 ## new Array() [#new-array]
@@ -385,9 +383,9 @@ In the code above, `new Array(number)` has all elements `undefined`.
 
 To evade such surprises, we usually use square brackets, unless we really know what we're doing.
 
-## Multidimentional arrays
+## Multidimensional arrays
 
-Arrays can have items that are also arrays. We can use it for multidimentional arrays, to store matrices:
+Arrays can have items that are also arrays. We can use it for multidimensional arrays, to store matrices:
 
 ```js run
 let matrix = [
@@ -458,9 +456,9 @@ We can use an array as a deque with the following operations:
 - `unshift(...items)` adds items to the beginning.
 
 To loop over the elements of the array:
-  - `for(let i=0; i<arr.length; i++)` -- works fastest, old-browser-compatible.
-  - `for(let item of arr)` -- the modern syntax for items only,
-  - `for(let i in arr)` -- never use.
+  - `for (let i=0; i<arr.length; i++)` -- works fastest, old-browser-compatible.
+  - `for (let item of arr)` -- the modern syntax for items only,
+  - `for (let i in arr)` -- never use.
 
 We will return to arrays and study more methods to add, remove, extract elements and sort arrays in the chapter <info:array-methods>.
 
diff --git a/1-js/05-data-types/05-array-methods/10-average-age/solution.md b/1-js/05-data-types/05-array-methods/10-average-age/solution.md
index 5e19fb5a..f5d4df93 100644
--- a/1-js/05-data-types/05-array-methods/10-average-age/solution.md
+++ b/1-js/05-data-types/05-array-methods/10-average-age/solution.md
@@ -3,9 +3,9 @@ function getAverageAge(users) {
   return users.reduce((prev, user) => prev + user.age, 0) / users.length;
 }
 
-let john = { name: "John", age: 25 }
-let pete = { name: "Pete", age: 30 }
-let mary = { name: "Mary", age: 29 }
+let john = { name: "John", age: 25 };
+let pete = { name: "Pete", age: 30 };
+let mary = { name: "Mary", age: 29 };
 
 let arr = [ john, pete, mary ];
 
diff --git a/1-js/05-data-types/05-array-methods/10-average-age/task.md b/1-js/05-data-types/05-array-methods/10-average-age/task.md
index ccb2142d..a991c156 100644
--- a/1-js/05-data-types/05-array-methods/10-average-age/task.md
+++ b/1-js/05-data-types/05-array-methods/10-average-age/task.md
@@ -11,12 +11,12 @@ The formula for the average is `(age1 + age2 + ... + ageN) / N`.
 For instance:
 
 ```js no-beautify
-let john = { name: "John", age: 25 }
-let pete = { name: "Pete", age: 30 }
-let mary = { name: "Mary", age: 29 }
+let john = { name: "John", age: 25 };
+let pete = { name: "Pete", age: 30 };
+let mary = { name: "Mary", age: 29 };
 
 let arr = [ john, pete, mary ];
 
-alert( getAverageAge(arr) ); // (25+30+29)/3 = 28
+alert( getAverageAge(arr) ); // (25 + 30 + 29) / 3 = 28
 ```
 
diff --git a/1-js/05-data-types/05-array-methods/11-array-unique/solution.md b/1-js/05-data-types/05-array-methods/11-array-unique/solution.md
index 5b565d42..8f7fd9af 100644
--- a/1-js/05-data-types/05-array-methods/11-array-unique/solution.md
+++ b/1-js/05-data-types/05-array-methods/11-array-unique/solution.md
@@ -7,7 +7,7 @@ function unique(arr) {
   let result = [];
 
   for (let str of arr) {
-    if (!result.includes(str) {
+    if (!result.includes(str)) {
       result.push(str);
     }
   }
diff --git a/1-js/05-data-types/05-array-methods/2-filter-range/task.md b/1-js/05-data-types/05-array-methods/2-filter-range/task.md
index fb6f06ee..18b2c1d9 100644
--- a/1-js/05-data-types/05-array-methods/2-filter-range/task.md
+++ b/1-js/05-data-types/05-array-methods/2-filter-range/task.md
@@ -2,7 +2,7 @@ importance: 4
 
 ---
 
-# Filter "in place"
+# Filter range
 
 Write a function `filterRange(arr, a, b)` that gets an array `arr`, looks for elements between `a` and `b` in it and returns an array of them. 
 
diff --git a/1-js/05-data-types/05-array-methods/3-filter-range-in-place/task.md b/1-js/05-data-types/05-array-methods/3-filter-range-in-place/task.md
index a737a525..7066a51a 100644
--- a/1-js/05-data-types/05-array-methods/3-filter-range-in-place/task.md
+++ b/1-js/05-data-types/05-array-methods/3-filter-range-in-place/task.md
@@ -4,7 +4,7 @@ importance: 4
 
 # Filter range "in place"
 
-Write a function `filterRangeInPlace(arr, a, b)` that gets an array `arr` and removes from it all values except those that are between `a` and `b. The test is: `a ≤ arr[i] ≤ b`.
+Write a function `filterRangeInPlace(arr, a, b)` that gets an array `arr` and removes from it all values except those that are between `a` and `b`. The test is: `a ≤ arr[i] ≤ b`.
 
 The function should only modify the array. It should not return anything.
 
diff --git a/1-js/05-data-types/05-array-methods/4-sort-back/solution.md b/1-js/05-data-types/05-array-methods/4-sort-back/solution.md
index 5a9f076b..cdf13351 100644
--- a/1-js/05-data-types/05-array-methods/4-sort-back/solution.md
+++ b/1-js/05-data-types/05-array-methods/4-sort-back/solution.md
@@ -3,7 +3,7 @@
 ```js run
 let arr = [5, 2, 1, -10, 8];
 
-arr.sort((a,b) => b - a);
+arr.sort((a, b) => b - a);
 
 alert( arr );
 ```
diff --git a/1-js/05-data-types/05-array-methods/7-map-objects/solution.md b/1-js/05-data-types/05-array-methods/7-map-objects/solution.md
index 5e9b815f..5d8bf4a1 100644
--- a/1-js/05-data-types/05-array-methods/7-map-objects/solution.md
+++ b/1-js/05-data-types/05-array-methods/7-map-objects/solution.md
@@ -21,8 +21,8 @@ usersMapped = [
 ]
 */
 
-alert( usersMapped[0].id ) // 1
-alert( usersMapped[0].fullName ) // John Smith
+alert( usersMapped[0].id ); // 1
+alert( usersMapped[0].fullName ); // John Smith
 ```
 
 Please note that in for the arrow functions we need to use additional brackets. 
@@ -43,7 +43,7 @@ Here JavaScript would treat `{` as the start of function body, not the start of
 let usersMapped = users.map(user => *!*({*/!*
   fullName: `${user.name} ${user.surname}`,
   id: user.id
-});
+}));
 ```
 
 Now fine.
diff --git a/1-js/05-data-types/05-array-methods/8-sort-objects/solution.md b/1-js/05-data-types/05-array-methods/8-sort-objects/solution.md
index 2c7c5181..8d56db9d 100644
--- a/1-js/05-data-types/05-array-methods/8-sort-objects/solution.md
+++ b/1-js/05-data-types/05-array-methods/8-sort-objects/solution.md
@@ -12,6 +12,6 @@ let arr = [ john, pete, mary ];
 sortByName(arr);
 
 // now sorted is: [john, mary, pete]
-alert(arr[1].name) // Mary
+alert(arr[1].name); // Mary
 ```
 
diff --git a/1-js/05-data-types/05-array-methods/8-sort-objects/task.md b/1-js/05-data-types/05-array-methods/8-sort-objects/task.md
index 935c27fc..8a3f5a97 100644
--- a/1-js/05-data-types/05-array-methods/8-sort-objects/task.md
+++ b/1-js/05-data-types/05-array-methods/8-sort-objects/task.md
@@ -9,15 +9,15 @@ Write the function `sortByName(users)` that gets an array of objects with proper
 For instance:
 
 ```js no-beautify
-let john = { name: "John", age: 25 }
-let pete = { name: "Pete", age: 30 }
-let mary = { name: "Mary", age: 28 }
+let john = { name: "John", age: 25 };
+let pete = { name: "Pete", age: 30 };
+let mary = { name: "Mary", age: 28 };
 
 let arr = [ john, pete, mary ];
 
-lsortByName(arr);
+sortByName(arr);
 
 // now: [john, mary, pete]
-alert(arr[1].name) // Mary
+alert(arr[1].name); // Mary
 ```
 
diff --git a/1-js/05-data-types/05-array-methods/9-shuffle/solution.md b/1-js/05-data-types/05-array-methods/9-shuffle/solution.md
index 12cf7551..a43715db 100644
--- a/1-js/05-data-types/05-array-methods/9-shuffle/solution.md
+++ b/1-js/05-data-types/05-array-methods/9-shuffle/solution.md
@@ -12,7 +12,7 @@ shuffle(arr);
 alert(arr);
 ```
 
-That somewhat works, because `Math.random()-0.5` is a random number that may be positive or negative, so the sorting function reorders elements randomly.
+That somewhat works, because `Math.random() - 0.5` is a random number that may be positive or negative, so the sorting function reorders elements randomly.
 
 But because the sorting function is not meant to be used this way, not all permutations have the same probability.
 
@@ -33,14 +33,14 @@ let count = {
   '312': 0
 };
 
-for(let i = 0; i < 1000000; i++) {
+for (let i = 0; i < 1000000; i++) {
   let array = [1, 2, 3];
   shuffle(array);
   count[array.join('')]++;
 }
 
 // show counts of all possible permutations
-for(let key in count) {
+for (let key in count) {
   alert(`${key}: ${count[key]}`);
 }
 ```
@@ -66,8 +66,8 @@ There are other good ways to do the task. For instance, there's a great algorith
 
 ```js
 function shuffle(array) {
-  for(let i = array.length - 1; i > 0; i--) {
-    let j = Math.floor(Math.random() * (i+1)); // random index from 0 to i
+  for (let i = array.length - 1; i > 0; i--) {
+    let j = Math.floor(Math.random() * (i + 1)); // random index from 0 to i
     [array[i], array[j]] = [array[j], array[i]]; // swap elements
   }
 }
@@ -77,8 +77,8 @@ Let's test it the same way:
 
 ```js run
 function shuffle(array) {
-  for(let i = array.length - 1; i > 0; i--) {
-    let j = Math.floor(Math.random() * (i+1));
+  for (let i = array.length - 1; i > 0; i--) {
+    let j = Math.floor(Math.random() * (i + 1));
     [array[i], array[j]] = [array[j], array[i]];
   }
 }
@@ -93,14 +93,14 @@ let count = {
   '312': 0
 };
 
-for(let i = 0; i < 1000000; i++) {
+for (let i = 0; i < 1000000; i++) {
   let array = [1, 2, 3];
   shuffle(array);
   count[array.join('')]++;
 }
 
 // show counts of all possible permutations
-for(let key in count) {
+for (let key in count) {
   alert(`${key}: ${count[key]}`);
 }
 ```
diff --git a/1-js/05-data-types/05-array-methods/article.md b/1-js/05-data-types/05-array-methods/article.md
index 26163457..83487cee 100644
--- a/1-js/05-data-types/05-array-methods/article.md
+++ b/1-js/05-data-types/05-array-methods/article.md
@@ -2,8 +2,6 @@
 
 Arrays provide a lot of methods. To make things easier, in this chapter they are split into groups.
 
-[cut]
-
 ## Add/remove items
 
 We already know methods that add and remove items from the beginning or the end:
@@ -64,13 +62,13 @@ alert( arr ); // ["I", "JavaScript"]
 
 Easy, right? Starting from the index `1` it removed `1` element.
 
-In the next example we remove 3 elements and replace them by the other two:
+In the next example we remove 3 elements and replace them with the other two:
 
 ```js run
 let arr = [*!*"I", "study", "JavaScript",*/!* "right", "now"];
 
-// remove 3 first elements and replace them by another
-arr.splice(0, 3, "Let's", "dance")
+// remove 3 first elements and replace them with another
+arr.splice(0, 3, "Let's", "dance");
 
 alert( arr ) // now [*!*"Let's", "dance"*/!*, "right", "now"]
 ```
@@ -103,7 +101,7 @@ alert( arr ); // "I", "study", "complex", "language", "JavaScript"
 Here and in other array methods, negative indexes are allowed. They specify the position from the end of the array, like here:
 
 ```js run
-let arr = [1, 2, 5]
+let arr = [1, 2, 5];
 
 // from index -1 (one step from the end)
 // delete 0 elements,
@@ -155,7 +153,7 @@ It accepts any number of arguments -- either arrays or values.
 
 The result is a new array containing items from `arr`, then `arg1`, `arg2` etc.
 
-If an argument is an array or has `Symbol.isConcatSpreadable` property, then all its elements are copied. Otherwise the argument itself is copied.
+If an argument is an array or has `Symbol.isConcatSpreadable` property, then all its elements are copied. Otherwise, the argument itself is copied.
 
 For instance:
 
@@ -172,7 +170,7 @@ alert( arr.concat([3, 4], [5, 6])); // 1,2,3,4,5,6
 alert( arr.concat([3, 4], 5, 6)); // 1,2,3,4,5,6
 ```
 
-Normally, it only copies elements from arrays ("spreads" them), other objects even if they look like arrays and added as a whole:
+Normally, it only copies elements from arrays ("spreads" them). Other objects, even if they look like arrays, added as a whole:
 
 ```js run
 let arr = [1, 2];
@@ -211,7 +209,7 @@ These are methods to search for something in an array.
 
 The methods [arr.indexOf](mdn:js/Array/indexOf), [arr.lastIndexOf](mdn:js/Array/lastIndexOf) and [arr.includes](mdn:js/Array/includes) have the same syntax and do essentially the same as their string counterparts, but operate on items instead of characters:
 
-- `arr.indexOf(item, from)` looks for `item` starting from index `from`, and returns the index where it was found, otheriwse `-1`.
+- `arr.indexOf(item, from)` looks for `item` starting from index `from`, and returns the index where it was found, otherwise `-1`.
 - `arr.lastIndexOf(item, from)` -- same, but looks from right to left.
 - `arr.includes(item, from)` -- looks for `item` starting from index `from`, returns `true` if found.
 
@@ -231,6 +229,13 @@ Note that the methods use `===` comparison. So, if we look for `false`, it finds
 
 If we want to check for inclusion, and don't want to know the exact index, then `arr.includes` is preferred.
 
+Also, a very minor difference of `includes` is that it correctly handles `NaN`, unlike `indexOf/lastIndexOf`:
+
+```js run
+const arr = [NaN];
+alert( arr.indexOf(NaN) ); // -1 (should be 0, but === equality doesn't work for NaN)
+alert( arr.includes(NaN) );// true (correct)
+```
 
 ### find and findIndex
 
@@ -316,7 +321,7 @@ The syntax is:
 ```js
 let result = arr.map(function(item, index, array) {
   // returns the new value instead of item
-}
+})
 ```
 
 It calls the function for each element of the array and returns the array of results.
@@ -472,7 +477,7 @@ alert( str.split('') ); // t,e,s,t
 ```
 ````
 
-The call [arr.join(str)](mdn:js/Array/join) does the reverse to `split`. It creates a string of `arr` items glued by `str` beween them.
+The call [arr.join(str)](mdn:js/Array/join) does the reverse to `split`. It creates a string of `arr` items glued by `str` between them.
 
 For instance:
 
@@ -515,7 +520,7 @@ The easiest way to grasp that is by example.
 Here we get a sum of array in one line:
 
 ```js run
-let arr = [1, 2, 3, 4, 5]
+let arr = [1, 2, 3, 4, 5];
 
 let result = arr.reduce((sum, current) => sum + current, 0);
 
@@ -528,7 +533,7 @@ Let's see the details of what's going on.
 
 1. On the first run, `sum` is the initial value (the last argument of `reduce`), equals `0`, and `current` is the first array element, equals `1`. So the result is `1`.
 2. On the second run, `sum = 1`, we add the second array element (`2`) to it and return.
-3. On the 3rd run, `sum = 3` and we add one more element ot it, and so on...
+3. On the 3rd run, `sum = 3` and we add one more element to it, and so on...
 
 The calculation flow:
 
@@ -687,7 +692,7 @@ A cheatsheet of array methods:
 - To search among elements:
   - `indexOf/lastIndexOf(item, pos)` -- look for `item` starting from position `pos`, return the index or `-1` if not found.
   - `includes(value)` -- returns `true` if the array has `value`, otherwise `false`.
-  - `find/filter(func)` -- filter elements of through the function, return first/all values that make it return `true`.
+  - `find/filter(func)` -- filter elements through the function, return first/all values that make it return `true`.
   - `findIndex` is like `find`, but returns the index instead of a value.
 
 - To transform the array:
@@ -703,7 +708,7 @@ A cheatsheet of array methods:
 - Additionally:
   - `Array.isArray(arr)` checks `arr` for being an array.
 
-Of all these methods only `sort`, `reverse` and `splice` modify the array itself, the other ones only return a value.
+Please note that methods `sort`, `reverse` and `splice` modify the array itself.
 
 These methods are the most used ones, they cover 99% of use cases. But there are few others:
 
diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index cd6c074b..300d8f26 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -7,8 +7,6 @@ Arrays by themselves are iterable. But not only arrays. Strings are iterable too
 
 Iterables are widely used by the core JavaScript. As we'll see many built-in operators and methods rely on them.
 
-[cut]
-
 ## Symbol.iterator
 
 We can easily grasp the concept of iterables by making one of our own.
@@ -121,7 +119,7 @@ Arrays and strings are most widely used built-in iterables.
 For a string, `for..of` loops over its characters:
 
 ```js run
-for(let char of "test") {
+for (let char of "test") {
   alert( char ); // t, then e, then s, then t
 }
 ```
@@ -130,8 +128,8 @@ And it works right with surrogate pairs!
 
 ```js run
 let str = '𝒳😂';
-for(let char of str) {
-    alert(char); // 𝒳, and then 😂
+for (let char of str) {
+    alert( char ); // 𝒳, and then 😂
 }
 ```
 
@@ -139,7 +137,7 @@ for(let char of str) {
 
 Normally, internals of iterables are hidden from the external code. There's a `for..of` loop, that works, that's all it needs to know.
 
-But to understand things a little bit more deeper let's see how to create an iterator explicitly.
+But to understand things a little bit deeper let's see how to create an iterator explicitly.
 
 We'll iterate over a string the same way as `for..of`, but with direct calls. This code gets a string iterator and calls it "manually":
 
@@ -151,7 +149,7 @@ let str = "Hello";
 
 let iterator = str[Symbol.iterator]();
 
-while(true) {
+while (true) {
   let result = iterator.next();
   if (result.done) break;
   alert(result.value); // outputs characters one by one
@@ -184,11 +182,11 @@ let arrayLike = { // has indexes and length => array-like
 
 *!*
 // Error (no Symbol.iterator)
-for(let item of arrayLike) {}
+for (let item of arrayLike) {}
 */!*
 ```
 
-What they share in common -- both iterables and array-likes are usually *not arrays*, they don't have `push`, `pop` etc. That's rather inconvenient if we have such an object and want to work with it as with an array.
+What do they have in common? Both iterables and array-likes are usually *not arrays*, they don't have `push`, `pop` etc. That's rather inconvenient if we have such an object and want to work with it as with an array.
 
 ## Array.from
 
@@ -258,7 +256,7 @@ Technically here it does the same as:
 let str = '𝒳😂';
 
 let chars = []; // Array.from internally does the same loop
-for(let char of str) {
+for (let char of str) {
   chars.push(char);
 }
 
@@ -295,8 +293,8 @@ Objects that can be used in `for..of` are called *iterable*.
 - String iterator knows about surrogate pairs.
 
 
-Objects that have indexed properties and `length` are called *array-like*. Such objects may also have other properties and methods, but lack built-in methods of arrays.
+Objects that have indexed properties and `length` are called *array-like*. Such objects may also have other properties and methods, but lack the built-in methods of arrays.
 
 If we look inside the specification -- we'll see that most built-in methods assume that they work with iterables or array-likes instead of "real" arrays, because that's more abstract.
 
-`Array.from(obj[, mapFn, thisArg])` makes a real `Array` of an iterable or array-like `obj`, and then we can use array methods on it. The optional arguments `mapFn` and `thisArg` allow to apply a function to each item.
+`Array.from(obj[, mapFn, thisArg])` makes a real `Array` of an iterable or array-like `obj`, and we can then use array methods on it. The optional arguments `mapFn` and `thisArg` allow us to apply a function to each item.
diff --git a/1-js/05-data-types/07-map-set-weakmap-weakset/02-filter-anagrams/solution.md b/1-js/05-data-types/07-map-set-weakmap-weakset/02-filter-anagrams/solution.md
index f95b41aa..dacb4285 100644
--- a/1-js/05-data-types/07-map-set-weakmap-weakset/02-filter-anagrams/solution.md
+++ b/1-js/05-data-types/07-map-set-weakmap-weakset/02-filter-anagrams/solution.md
@@ -15,7 +15,7 @@ We'll use the letter-sorted variants as map keys to store only one value per eac
 function aclean(arr) {
   let map = new Map();
 
-  for(let word of arr) {
+  for (let word of arr) {
     // split the word by letters, sort them and join back
 *!*
     let sorted = word.toLowerCase().split('').sort().join(''); // (*)
diff --git a/1-js/05-data-types/07-map-set-weakmap-weakset/article.md b/1-js/05-data-types/07-map-set-weakmap-weakset/article.md
index 40ff18b5..0175243f 100644
--- a/1-js/05-data-types/07-map-set-weakmap-weakset/article.md
+++ b/1-js/05-data-types/07-map-set-weakmap-weakset/article.md
@@ -1,26 +1,26 @@
 
 # Map, Set, WeakMap and WeakSet
 
-Now we know the following complex data structures:
+Now we've learned about the following complex data structures:
 
 - Objects for storing keyed collections.
 - Arrays for storing ordered collections.
 
-But that's not enough for real life. That's why there also exist `Map` and `Set`.
+But that's not enough for real life. That's why `Map` and `Set` also exist.
 
 ## Map
 
-[Map](mdn:js/Map) is a collection of keyed data items. Just like an `Object`. But the main difference is that `Map` allows keys of any type.
+[Map](mdn:js/Map) is a collection of keyed data items, just like an `Object`. But the main difference is that `Map` allows keys of any type.
 
 The main methods are:
 
 - `new Map()` -- creates the map.
 - `map.set(key, value)` -- stores the value by the key.
-- `map.get(key)` -- returns the value by the key.
+- `map.get(key)` -- returns the value by the key, `undefined` if `key` doesn't exist in map.
 - `map.has(key)` -- returns `true` if the `key` exists, `false` otherwise.
 - `map.delete(key)` -- removes the value by the key.
 - `map.clear()` -- clears the map
-- `map.size` -- is the current elements count.
+- `map.size` -- returns the current element count.
 
 For instance:
 
@@ -76,7 +76,7 @@ alert( visitsCounts[john.id] ); // 123
 
 
 ```smart header="How `Map` compares keys"
-To test values for equivalence, `Map` uses the algorithm [SameValueZero](https://tc39.github.io/ecma262/#sec-samevaluezero). It is roughly the same as the strict equality `===`, but the difference is that `NaN` is considered equal to `NaN`. So `NaN` can be used as the key as well.
+To test values for equivalence, `Map` uses the algorithm [SameValueZero](https://tc39.github.io/ecma262/#sec-samevaluezero). It is roughly the same as strict equality `===`, but the difference is that `NaN` is considered equal to `NaN`. So `NaN` can be used as the key as well.
 
 This algorithm can't be changed or customized.
 ```
@@ -106,7 +106,7 @@ let map = new Map([
 ]);
 ```
 
-There is a built-in method [Object.entries(obj)](mdn:js/Object/entries) that returns the array of key/value pairs for an object exactly in that format.
+There is a built-in method [Object.entries(obj)](mdn:js/Object/entries) that returns an array of key/value pairs for an object exactly in that format.
 
 So we can initialize a map from an object like this:
 
@@ -137,18 +137,18 @@ let recipeMap = new Map([
 ]);
 
 // iterate over keys (vegetables)
-for(let vegetable of recipeMap.keys()) {
-  alert(vegetable); // cucumber, tomateos, onion
+for (let vegetable of recipeMap.keys()) {
+  alert(vegetable); // cucumber, tomatoes, onion
 }
 
 // iterate over values (amounts)
-for(let amount of recipeMap.values()) {
+for (let amount of recipeMap.values()) {
   alert(amount); // 500, 350, 50
 }
 
 // iterate over [key, value] entries
-for(let entry of recipeMap) { // the same as of recipeMap.entries()
-  alert(entry); // cucumber,50 (and so on)
+for (let entry of recipeMap) { // the same as of recipeMap.entries()
+  alert(entry); // cucumber,500 (and so on)
 }
 ```
 
@@ -160,16 +160,16 @@ Besides that, `Map` has a built-in `forEach` method, similar to `Array`:
 
 ```js
 recipeMap.forEach( (value, key, map) => {
-  alert(`${key}: ${value}`); // cucumber: 50 etc
+  alert(`${key}: ${value}`); // cucumber: 500 etc
 });
 ```
 
 
 ## Set
 
-`Set` -- is a collection of values, where each value may occur only once.
+A `Set` is a collection of values, where each value may occur only once.
 
-The main methods are:
+Its main methods are:
 
 - `new Set(iterable)` -- creates the set, optionally from an array of values (any iterable will do).
 - `set.add(value)` -- adds a value, returns the set itself.
@@ -199,7 +199,7 @@ set.add(mary);
 // set keeps only unique values
 alert( set.size ); // 3
 
-for(let user of set) {
+for (let user of set) {
   alert(user.name); // John (then Pete and Mary)
 }
 ```
@@ -213,7 +213,7 @@ We can loop over a set either with `for..of` or using `forEach`:
 ```js run
 let set = new Set(["oranges", "apples", "bananas"]);
 
-for(let value of set) alert(value);
+for (let value of set) alert(value);
 
 // the same with forEach:
 set.forEach((value, valueAgain, set) => {
@@ -223,9 +223,9 @@ set.forEach((value, valueAgain, set) => {
 
 Note the funny thing. The `forEach` function in the `Set` has 3 arguments: a value, then *again a value*, and then the target object. Indeed, the same value appears in the arguments twice.
 
-That's made for compatibility with `Map` where `forEach` has three arguments.
+That's for compatibility with `Map` where `forEach` has three arguments.
 
-The same methods as `Map` has for iterators are also supported:
+The same methods `Map` has for iterators are also supported:
 
 - `set.keys()` -- returns an iterable object for values,
 - `set.values()` -- same as `set.keys`, for compatibility with `Map`,
@@ -330,9 +330,9 @@ weakMap.put(john, "secret documents");
 
 That's useful for situations when we have a main storage for the objects somewhere and need to keep additional information that is only relevant while the object lives.
 
-Let's see an example.
+Let's look at an example.
 
-For instance, we have a code that keeps a visit count for each user. The information is stored in a map: a user is the key and the visit count is the value. When a user leaves, we don't want to store his visit count any more.
+For instance, we have code that keeps a visit count for each user. The information is stored in a map: a user is the key and the visit count is the value. When a user leaves, we don't want to store his visit count anymore.
 
 One way would be to keep track of leaving users and clean up the storage manually:
 
@@ -345,7 +345,7 @@ let visitsCountMap = new Map();
 // john is the key for the map
 visitsCountMap.set(john, 123);
 
-// now john leaves us, we don't need him any more
+// now john leaves us, we don't need him anymore
 john = null;
 
 *!*
@@ -364,7 +364,7 @@ let visitsCountMap = new WeakMap();
 
 visitsCountMap.set(john, 123);
 
-// now john leaves us, we don't need him any more
+// now john leaves us, we don't need him anymore
 john = null;
 
 // there are no references except WeakMap,
@@ -408,7 +408,7 @@ The most notable limitation of `WeakMap` and `WeakSet` is the absence of iterati
 
 ## Summary
 
-- `Map` -- is a a collection of keyed values.
+- `Map` -- is a collection of keyed values.
 
     The differences from a regular `Object`:
 
@@ -421,12 +421,12 @@ The most notable limitation of `WeakMap` and `WeakSet` is the absence of iterati
     - Unlike an array, does not allow to reorder elements.
     - Keeps the insertion order.
 
-- `WeakMap` -- a variant of `Map` that allows only objects as keys and removes them once they become unaccessible by other means.
+- `WeakMap` -- a variant of `Map` that allows only objects as keys and removes them once they become inaccessible by other means.
 
     - It does not support operations on the structure as a whole: no `size`, no `clear()`, no iterations.
 
-- `WeakSet` -- is a variant of `Set` that only stores objects and removes them once they become unaccessible by other means.
+- `WeakSet` -- is a variant of `Set` that only stores objects and removes them once they become inaccessible by other means.
 
     - Also does not support `size/clear()` and iterations.
 
-`WeakMap` and `WeakSet` are used as "secondary" data structures in additional to the "main" object storage. Once the object is removed from the main storage, so it only stays in `WeakMap/WeakSet`, they clean up aumatically.
+`WeakMap` and `WeakSet` are used as "secondary" data structures in addition to the "main" object storage. Once the object is removed from the main storage, so it only stays in `WeakMap/WeakSet`, they clean up automatically.
diff --git a/1-js/05-data-types/08-keys-values-entries/article.md b/1-js/05-data-types/08-keys-values-entries/article.md
index 083ed9a3..50ba91ce 100644
--- a/1-js/05-data-types/08-keys-values-entries/article.md
+++ b/1-js/05-data-types/08-keys-values-entries/article.md
@@ -32,7 +32,7 @@ For plain objects, the following methods are available:
 
 The first difference is that we have to call `Object.keys(obj)`, and not `obj.keys()`.
 
-Why so? There main reason is flexibility. Remember, objects are a base of all complex structures in JavaScript. So we may have an object of our own like `order` that implements its own `order.values()` method. And we still can call `Object.values(order)` on it.
+Why so? The main reason is flexibility. Remember, objects are a base of all complex structures in JavaScript. So we may have an object of our own like `order` that implements its own `order.values()` method. And we still can call `Object.values(order)` on it.
 
 The second difference is that `Object.*` methods return "real" array objects, not just an iterable. That's mainly for historical reasons.
 
@@ -58,7 +58,7 @@ let user = {
 };
 
 // loop over values
-for(let value of Object.values(user)) {
+for (let value of Object.values(user)) {
   alert(value); // John, then 30
 }
 ```
diff --git a/1-js/05-data-types/09-destructuring-assignment/1-destructuring-assignment/solution.md b/1-js/05-data-types/09-destructuring-assignment/1-destruct-user/solution.md
similarity index 100%
rename from 1-js/05-data-types/09-destructuring-assignment/1-destructuring-assignment/solution.md
rename to 1-js/05-data-types/09-destructuring-assignment/1-destruct-user/solution.md
diff --git a/1-js/05-data-types/09-destructuring-assignment/1-destructuring-assignment/task.md b/1-js/05-data-types/09-destructuring-assignment/1-destruct-user/task.md
similarity index 100%
rename from 1-js/05-data-types/09-destructuring-assignment/1-destructuring-assignment/task.md
rename to 1-js/05-data-types/09-destructuring-assignment/1-destruct-user/task.md
diff --git a/1-js/05-data-types/09-destructuring-assignment/article.md b/1-js/05-data-types/09-destructuring-assignment/article.md
index 1eb37ebe..6dfa754f 100644
--- a/1-js/05-data-types/09-destructuring-assignment/article.md
+++ b/1-js/05-data-types/09-destructuring-assignment/article.md
@@ -2,11 +2,9 @@
 
 The two most used data structures in JavaScript are `Object` and `Array`.
 
-Objects allow to pack many pieces of information into a single entity and arrays allow to store ordered collections. So we can make an object or an array and handle it as a single thing, maybe pass to a function call.
+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 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.
-
-[cut]
+*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.
 
 ## Array destructuring
 
@@ -34,9 +32,9 @@ let [firstName, surname] = "Ilya Kantor".split(' ');
 ```
 
 ````smart header="\"Destructuring\" does not mean \"destructive\""
-That's called "destructuring assignment", because it "destructurizes" by copying items into variables. But the array itself is not modified.
+It's called "destructuring assignment", because it "destructurizes" by copying items into variables. But the array itself is not modified.
 
-That's just a shorter way to write:
+It's just a shorter way to write:
 ```js
 // let [firstName, surname] = arr;
 let firstName = arr[0];
@@ -56,12 +54,12 @@ let [, , title] = ["Julius", "Caesar", "Consul", "of the Roman Republic"];
 alert( title ); // Consul
 ```
 
-In the code above, the first and second elements of the array are skipped, the third one is assigned to `title`, and the rest is also skipped.
+In the code above, although the first and second elements of the array are skipped, the third one is assigned to `title`, and the rest are also skipped.
 ````
 
 ````smart header="Works with any iterable on the right-side"
 
-...Actually, we can use it with any iterable, not only an array:
+...Actually, we can use it with any iterable, not only arrays:
 
 ```js
 let [a, b, c] = "abc"; // ["a", "b", "c"]
@@ -87,7 +85,7 @@ alert(user.name); // Ilya
 
 ````smart header="Looping with .entries()"
 
-In the previous chapter we saw [Object.entries(obj)](mdn:js/Object/entries) method.
+In the previous chapter we saw the [Object.entries(obj)](mdn:js/Object/entries) method.
 
 We can use it with destructuring to loop over keys-and-values of an object:
 
@@ -99,7 +97,7 @@ let user = {
 
 // loop over keys-and-values
 *!*
-for(let [key, value] of Object.entries(user)) {
+for (let [key, value] of Object.entries(user)) {
 */!*
   alert(`${key}:${value}`); // name:John, then age:30
 }
@@ -113,7 +111,7 @@ user.set("name", "John");
 user.set("age", "30");
 
 *!*
-for(let [key, value] of user.entries()) {
+for (let [key, value] of user.entries()) {
 */!*
   alert(`${key}:${value}`); // name:John, then age:30
 }
@@ -121,7 +119,7 @@ for(let [key, value] of user.entries()) {
 ````
 ### The rest '...'
 
-If we want not just to get first values, but also to gather all that follows -- we can add one more parameter that gets "the rest" using the three dots `"..."`:
+If we want not just to get first values, but also to gather all that follows -- we can add one more parameter that gets "the rest" using three dots `"..."`:
 
 ```js run
 let [name1, name2, *!*...rest*/!*] = ["Julius", "Caesar", *!*"Consul", "of the Roman Republic"*/!*];
@@ -136,11 +134,11 @@ alert(rest.length); // 2
 */!*
 ```
 
-The value of `rest` is the array of the remaining array elements. We can use any other variable name in place of `rest`, just make sure it has three dots before it and goes the last.
+The value of `rest` is the array of the remaining array elements. We can use any other variable name in place of `rest`, just make sure it has three dots before it and goes last in the destructuring assignment.
 
 ### Default values
 
-If there are fewer values in the array than variables in the assignment -- there will be no error, absent values are considered undefined:
+If there are fewer values in the array than variables in the assignment, there will be no error. Absent values are considered undefined:
 
 ```js run
 *!*
@@ -155,7 +153,7 @@ If we want a "default" value to replace the missing one, we can provide it using
 ```js run
 *!*
 // default values
-let [name="Guest", surname="Anonymous"] = ["Julius"];
+let [name = "Guest", surname = "Anonymous"] = ["Julius"];
 */!*
 
 alert(name);    // Julius (from array)
@@ -164,11 +162,11 @@ alert(surname); // Anonymous (default used)
 
 Default values can be more complex expressions or even function calls. They are evaluated only if the value is not provided.
 
-For instance, here we use `prompt` function for two defaults. But it will only run only for the missing one:
+For instance, here we use the `prompt` function for two defaults. But it will run only for the missing one:
 
 ```js run
 // runs only prompt for surname
-let [name=prompt('name?'), surname=prompt('surname?')] = ["Julius"];
+let [name = prompt('name?'), surname = prompt('surname?')] = ["Julius"];
 
 alert(name);    // Julius (from array)
 alert(surname); // whatever prompt gets
@@ -186,7 +184,7 @@ The basic syntax is:
 let {var1, var2} = {var1:…, var2…}
 ```
 
-We have an existing object at the right side, that we want to split into variables. To the left side contains a "pattern" for corresponding properties. In the simple case that's a list of variable names in `{...}`.
+We have an existing object at the right side, that we want to split into variables. The left side contains a "pattern" for corresponding properties. In the simple case, that's a list of variable names in `{...}`.
 
 For instance:
 
@@ -206,7 +204,7 @@ alert(width);  // 100
 alert(height); // 200
 ```
 
-Properties `options.title`, `options.width` and `options.height` are assigned to the corresponding variables. The order does not matter, that works too:
+Properties `options.title`, `options.width` and `options.height` are assigned to the corresponding variables. The order does not matter. This works too:
 
 ```js
 // changed the order of properties in let {...}
@@ -248,7 +246,7 @@ let options = {
 };
 
 *!*
-let {width=100, height=200, title} = options;
+let {width = 100, height = 200, title} = options;
 */!*
 
 alert(title);  // Menu
@@ -258,7 +256,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 about the title.
+The code below asks for width, but not the title.
 
 ```js run
 let options = {
@@ -266,7 +264,7 @@ let options = {
 };
 
 *!*
-let {width=prompt("width?"), title=prompt("title?")} = options;
+let {width = prompt("width?"), title = prompt("title?")} = options;
 */!*
 
 alert(title);  // Menu
@@ -281,7 +279,7 @@ let options = {
 };
 
 *!*
-let {width:w=100, height:h=200, title} = options;
+let {width: w = 100, height: h = 200, title} = options;
 */!*
 
 alert(title);  // Menu
@@ -308,7 +306,7 @@ let options = {
 let {title, ...rest} = options;
 */!*
 
-// now title="Menu", rest={height: 200, widht: 100}
+// now title="Menu", rest={height: 200, width: 100}
 alert(rest.height);  // 200
 alert(rest.width);   // 100
 ```
@@ -389,9 +387,9 @@ The whole `options` object except `extra` that was not mentioned, is assigned to
 
 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 may properties and want extract only what we need.
+That often happens with destructuring assignments. We have a complex object with many properties and want to extract only what we need.
 
-Even like this:
+Even here it happens:
 ```js
 // take size as a whole into a variable, ignore the rest
 let { size } = options;
@@ -409,7 +407,7 @@ function showMenu(title = "Untitled", width = 200, height = 100, items = []) {
 }
 ```
 
-The real-life problem is how to remember the order of arguments. Usually IDEs try to help us, especially if the code is well-documented, but still... Another problem is how to call a function when most parameters are ok by default.
+In real-life the problem is how to remember the order of arguments. Usually IDEs try to help us, especially if the code is well-documented, but still... Another problem is how to call a function when most parameters are ok by default.
 
 Like this?
 
@@ -434,7 +432,7 @@ let options = {
 function showMenu(*!*{title = "Untitled", width = 200, height = 100, items = []}*/!*) {
   // title, items – taken from options,
   // width, height – defaults used
-  alert( title + ' ' + width + ' ' + height ); // My Menu 100 200
+  alert( `${title} ${width} ${height}` ); // My Menu 200 100
   alert( items ); // Item1, Item2
 }
 
@@ -452,12 +450,12 @@ let options = {
 *!*
 function showMenu({
   title = "Untitled",
-  width:w = 100,  // width goes to w
-  height:h = 200, // height goes to h
+  width: w = 100,  // width goes to w
+  height: h = 200, // height goes to h
   items: [item1, item2] // items first element goes to item1, second to item2
 }) {
 */!*
-  alert( title + ' ' + w + ' ' + h ); // My Menu 100 200
+  alert( `${title} ${w} ${h}` ); // My Menu 100 200
   alert( item1 ); // Item1
   alert( item2 ); // Item2
 }
@@ -478,8 +476,8 @@ Please note that such destructuring assumes that `showMenu()` does have an argum
 ```js
 showMenu({});
 
-// that would give an error
-showMenu();
+
+showMenu(); // this would give an error
 ```
 
 We can fix this by making `{}` the default value for the whole destructuring thing:
@@ -487,8 +485,8 @@ We can fix this by making `{}` the default value for the whole destructuring thi
 
 ```js run
 // simplified parameters a bit for clarity
-function showMenu(*!*{ title="Menu", width=100, height=200 } = {}*/!*) {
-  alert( title + ' ' + width + ' ' + height );
+function showMenu(*!*{ title = "Menu", width = 100, height = 200 } = {}*/!*) {
+  alert( `${title} ${width} ${height}` );
 }
 
 showMenu(); // Menu 100 200
@@ -498,7 +496,7 @@ In the code above, the whole arguments object is `{}` by default, so there's alw
 
 ## Summary
 
-- Destructuring assignment allows to instantly map an object or array into many variables.
+- Destructuring assignment allows for instantly mapping an object or array onto many variables.
 - The object syntax:
     ```js
     let {prop : varName = default, ...} = object
diff --git a/1-js/05-data-types/10-date/3-weekday/task.md b/1-js/05-data-types/10-date/3-weekday/task.md
index c2ae2168..ba62790c 100644
--- a/1-js/05-data-types/10-date/3-weekday/task.md
+++ b/1-js/05-data-types/10-date/3-weekday/task.md
@@ -4,7 +4,7 @@ importance: 5
 
 # European weekday
 
-European countries have days of week starting with monday (number 1), then tuesday (number 2) and till sunday (number 7). Write a function `getLocalDay(date)` that returns the "european" day of week for `date`.
+European countries have days of week starting with Monday (number 1), then Tuesday (number 2) and till Sunday (number 7). Write a function `getLocalDay(date)` that returns the "European" day of week for `date`.
 
 ```js no-beautify
 let date = new Date(2012, 0, 3);  // 3 Jan 2012
diff --git a/1-js/05-data-types/10-date/7-get-seconds-to-tomorrow/solution.md b/1-js/05-data-types/10-date/7-get-seconds-to-tomorrow/solution.md
index a89c8b3e..c337d119 100644
--- a/1-js/05-data-types/10-date/7-get-seconds-to-tomorrow/solution.md
+++ b/1-js/05-data-types/10-date/7-get-seconds-to-tomorrow/solution.md
@@ -13,3 +13,20 @@ function getSecondsToTomorrow() {
   return Math.round(diff / 1000); // convert to seconds
 }
 ```
+
+Alternative solution:
+
+```js run
+function getSecondsToTomorrow() {
+  let now = new Date();
+  let hour = now.getHours();
+  let minutes = now.getMinutes();
+  let seconds = now.getSeconds();
+  let totalSecondsToday = (hour * 60 + minutes) * 60 + seconds;
+  let totalSecondsInADay = 86400;
+
+  return totalSecondsInADay - totalSecondsToday;
+}
+```
+
+Please note that many countries have Daylight Savings Time (DST), so there may be days with 23 or 25 hours. We may want to treat such days separately.
diff --git a/1-js/05-data-types/10-date/8-format-date-relative/solution.md b/1-js/05-data-types/10-date/8-format-date-relative/solution.md
index 87864be7..24fec997 100644
--- a/1-js/05-data-types/10-date/8-format-date-relative/solution.md
+++ b/1-js/05-data-types/10-date/8-format-date-relative/solution.md
@@ -43,3 +43,34 @@ alert( formatDate(new Date(new Date - 5 * 60 * 1000)) ); // "5 min. ago"
 // yesterday's date like 31.12.2016, 20:00
 alert( formatDate(new Date(new Date - 86400 * 1000)) );
 ```
+
+Alternative solution:
+
+```js run
+function formatDate(date) {
+  let dayOfMonth = date.getDate();
+  let month = date.getMonth() + 1;
+  let year = date.getFullYear();
+  let hour = date.getHours();
+  let minutes = date.getMinutes();
+  let diffMs = new Date() - date;
+  let diffSec = Math.round(diffMs / 1000);
+  let diffMin = diffSec / 60;
+  let diffHour = diffMin / 60;
+      
+  // formatting
+  year = year.toString().slice(-2);
+  month = month < 10 ? '0' + month : month;
+  dayOfMonth = dayOfMonth < 10 ? '0' + dayOfMonth : dayOfMonth;
+      
+  if (diffSec < 1) {
+    return 'right now';  
+  } else if (diffMin < 1) {
+    return `${diffSec} sec. ago`
+  } else if (diffHour < 1) {
+    return `${diffMin} min. ago`
+  } else {
+    return `${dayOfMonth}.${month}.${year} ${hour}:${minutes}`
+  }
+}
+```
diff --git a/1-js/05-data-types/10-date/article.md b/1-js/05-data-types/10-date/article.md
index c025aaa4..00390812 100644
--- a/1-js/05-data-types/10-date/article.md
+++ b/1-js/05-data-types/10-date/article.md
@@ -4,8 +4,6 @@ Let's meet a new built-in object: [Date](mdn:js/Date). It stores the date, time
 
 For instance, we can use it to store creation/modification times, or to measure time, or just to print out the current date.
 
-[cut]
-
 ## Creation
 
 To create a new `Date` object call `new Date()` with one of the following arguments:
@@ -100,7 +98,7 @@ There are also their UTC-counterparts, that return day, month, year and so on fo
 If your local time zone is shifted relative to UTC, then the code below shows different hours:
 
 ```js run
-// currend date
+// current date
 let date = new Date();
 
 // the hour in your current time zone
@@ -208,7 +206,7 @@ let date = new Date();
 alert(+date); // the number of milliseconds, same as date.getTime()
 ```
 
-The important side effect: dates can be substracted, the result is their difference in ms.
+The important side effect: dates can be subtracted, the result is their difference in ms.
 
 That can be used for time measurements:
 
@@ -251,7 +249,7 @@ for (let i = 0; i < 100000; i++) {
 let end = Date.now(); // done
 */!*
 
-alert( `The loop took ${end - start} ms` ); // substract numbers, not dates
+alert( `The loop took ${end - start} ms` ); // subtract numbers, not dates
 ```
 
 ## Benchmarking
@@ -262,7 +260,7 @@ For instance, let's measure two functions that calculate the difference between
 
 ```js
 // we have date1 and date2, which function faster returns their difference in ms?
-function diffSubstract(date1, date2) {
+function diffSubtract(date1, date2) {
   return date2 - date1;
 }
 
@@ -281,7 +279,7 @@ The first idea may be to run them many times in a row and measure the time diffe
 Let's measure:
 
 ```js run
-function diffSubstract(date1, date2) {
+function diffSubtract(date1, date2) {
   return date2 - date1;
 }
 
@@ -298,7 +296,7 @@ function bench(f) {
   return Date.now() - start;
 }
 
-alert( 'Time of diffSubstract: ' + bench(diffSubstract) + 'ms' );
+alert( 'Time of diffSubtract: ' + bench(diffSubtract) + 'ms' );
 alert( 'Time of diffGetTime: ' + bench(diffGetTime) + 'ms' );
 ```
 
@@ -306,7 +304,7 @@ Wow! Using `getTime()` is so much faster! That's because there's no type convers
 
 Okay, we have something. But that's not a good benchmark yet.
 
-Imagine that at the time of running `bench(diffSubstract)` CPU was doing something in parallel, and it was taking resources. And by the time of running `bench(diffGetTime)` the work has finished.
+Imagine that at the time of running `bench(diffSubtract)` CPU was doing something in parallel, and it was taking resources. And by the time of running `bench(diffGetTime)` the work has finished.
 
 A pretty real scenario for a modern multi-process OS.
 
@@ -317,7 +315,7 @@ As a result, the first benchmark will have less CPU resources than the second. T
 Here's the code example:
 
 ```js run
-function diffSubstract(date1, date2) {
+function diffSubtract(date1, date2) {
   return date2 - date1;
 }
 
@@ -340,12 +338,12 @@ let time2 = 0;
 *!*
 // run bench(upperSlice) and bench(upperLoop) each 10 times alternating
 for (let i = 0; i < 10; i++) {
-  time1 += bench(diffSubstract);
+  time1 += bench(diffSubtract);
   time2 += bench(diffGetTime);
 }
 */!*
 
-alert( 'Total time for diffSubstract: ' + time1 );
+alert( 'Total time for diffSubtract: ' + time1 );
 alert( 'Total time for diffGetTime: ' + time2 );
 ```
 
@@ -353,12 +351,12 @@ Modern JavaScript engines start applying advanced optimizations only to "hot cod
 
 ```js
 // added for "heating up" prior to the main loop
-bench(diffSubstract);
+bench(diffSubtract);
 bench(diffGetTime);
 
 // now benchmark
 for (let i = 0; i < 10; i++) {
-  time1 += bench(diffSubstract);
+  time1 += bench(diffSubtract);
   time2 += bench(diffGetTime);
 }
 ```
@@ -405,8 +403,8 @@ alert(date);
 - Date and time in JavaScript are represented with the [Date](mdn:js/Date) object. We can't create "only date" or "only time": `Date` objects always carry both.
 - Months are counted from zero (yes, January is a zero month).
 - Days of week in `getDay()` are also counted from zero (that's Sunday).
-- `Date` auto-corrects itself when out-of-range components are set. Good for adding/substracting days/months/hours.
-- Dates can be substracted, giving their difference in milliseconds. That's because a `Date` becomes the timestamp if converted to a number.
+- `Date` auto-corrects itself when out-of-range components are set. Good for adding/subtracting days/months/hours.
+- Dates can be subtracted, giving their difference in milliseconds. That's because a `Date` becomes the timestamp when converted to a number.
 - Use `Date.now()` to get the current timestamp fast.
 
 Note that unlike many other systems, timestamps in JavaScript are in milliseconds, not in seconds.
@@ -417,7 +415,7 @@ Also, sometimes we need more precise time measurements. JavaScript itself does n
 alert(`Loading started ${performance.now()}ms ago`);
 // Something like: "Loading started 34731.26000000001ms ago"
 // .26 is microseconds (260 microseconds)
-// more than 3 digits after the decimal point are precision errors, but only 3 first are correct
+// more than 3 digits after the decimal point are precision errors, but only the first 3 are correct
 ```
 
 Node.JS has `microtime` module and other ways. Technically, any device and environment allows to get more precision, it's just not in `Date`.
diff --git a/1-js/05-data-types/11-json/1-serialize-object/task.md b/1-js/05-data-types/11-json/1-serialize-object/task.md
index cbb04609..53343e4c 100644
--- a/1-js/05-data-types/11-json/1-serialize-object/task.md
+++ b/1-js/05-data-types/11-json/1-serialize-object/task.md
@@ -4,7 +4,7 @@ importance: 5
 
 # Turn the object into JSON and back
 
-Turn the `leader` into JSON and then read it back into another variable.
+Turn the `user` into JSON and then read it back into another variable.
 
 ```js
 let user = {
diff --git a/1-js/05-data-types/11-json/article.md b/1-js/05-data-types/11-json/article.md
index 4081949e..174b2b7f 100644
--- a/1-js/05-data-types/11-json/article.md
+++ b/1-js/05-data-types/11-json/article.md
@@ -25,8 +25,6 @@ alert(user); // {name: "John", age: 30}
 
 Luckily, there's no need to write the code to handle all this. The task has been solved already.
 
-[cut]
-
 ## JSON.stringify
 
 The [JSON](http://en.wikipedia.org/wiki/JSON) (JavaScript Object Notation) is a general format to represent values and objects. It is described as in [RFC 4627](http://tools.ietf.org/html/rfc4627) standard. Initially it was made for JavaScript, but many other languages have libraries to handle it as well.  So it's easy to use JSON for data exchange when the client uses JavaScript and the server is written on Ruby/PHP/Java/Whatever.
@@ -36,7 +34,7 @@ JavaScript provides methods:
 - `JSON.stringify` to convert objects into JSON.
 - `JSON.parse` to convert JSON back into an object.
 
-For instance, here's we `JSON.stringify` a student:
+For instance, here we `JSON.stringify` a student:
 ```js run
 let student = {
   name: 'John',
@@ -133,7 +131,7 @@ let meetup = {
   title: "Conference",
 *!*
   room: {
-    number: 123,
+    number: 23,
     participants: ["john", "ann"]
   }
 */!*
diff --git a/1-js/06-advanced-functions/01-recursion/article.md b/1-js/06-advanced-functions/01-recursion/article.md
index 6995cdc4..036ae7f5 100644
--- a/1-js/06-advanced-functions/01-recursion/article.md
+++ b/1-js/06-advanced-functions/01-recursion/article.md
@@ -10,8 +10,6 @@ Recursion is a programming pattern that is useful in situations when a task can
 
 When a function solves a task, in the process it can call many other functions. A partial case of this is when a function calls *itself*. That's called *recursion*.
 
-[cut]
-
 ## Two ways of thinking
 
 For something simple to start with -- let's write a function `pow(x, n)` that raises `x` to a natural power of `n`. In other words, multiplies `x` by itself `n` times.
@@ -31,7 +29,7 @@ There are two ways to implement it.
       let result = 1;
 
       // multiply result by x n times in the loop
-      for(let i = 0; i < n; i++) {
+      for (let i = 0; i < n; i++) {
         result *= x;
       }
 
@@ -67,8 +65,8 @@ pow(x, n) =
               else     = x * pow(x, n - 1)
 ```
 
-1. If `n==1`, then everything is trivial. It is called *the base* of recursion, because it immediately produces the obvious result: `pow(x, 1)` equals `x`.
-2. Otherwise, we can represent `pow(x, n)` as `x * pow(x, n-1)`. In maths, one would write <code>x<sup>n</sup> = x * x<sup>n-1</sup></code>. This is called *a recursive step*: we transform the task into a simpler action (multiplication by `x`) and a simpler call of the same task (`pow` with lower `n`). Next steps simplify it further and further untill `n` reaches `1`.
+1. If `n == 1`, then everything is trivial. It is called *the base* of recursion, because it immediately produces the obvious result: `pow(x, 1)` equals `x`.
+2. Otherwise, we can represent `pow(x, n)` as `x * pow(x, n - 1)`. In maths, one would write <code>x<sup>n</sup> = x * x<sup>n-1</sup></code>. This is called *a recursive step*: we transform the task into a simpler action (multiplication by `x`) and a simpler call of the same task (`pow` with lower `n`). Next steps simplify it further and further until `n` reaches `1`.
 
 We can also say that `pow` *recursively calls itself* till `n == 1`.
 
@@ -91,7 +89,7 @@ Here we can rewrite the same using the ternary `?` operator instead of `if` to m
 
 ```js run
 function pow(x, n) {
-  return (n == 1) ? x : (x * pow(x, n-1));
+  return (n == 1) ? x : (x * pow(x, n - 1));
 }
 ```
 ````
@@ -134,7 +132,7 @@ We can sketch it as:
   </li>
 </ul>
 
-That's when the function starts to execute. The condition `n == 1` is falsy, so the flow continues into the second branch of `if`:
+That's when the function starts to execute. The condition `n == 1` is false, so the flow continues into the second branch of `if`:
 
 ```js run
 function pow(x, n) {
@@ -160,7 +158,7 @@ The variables are same, but the line changes, so the context is now:
   </li>
 </ul>
 
-To calculate `x*pow(x, n-1)`, we need to make a subcall of `pow` with new arguments `pow(2, 2)`.
+To calculate `x * pow(x, n - 1)`, we need to make a subcall of `pow` with new arguments `pow(2, 2)`.
 
 ### pow(2, 2)
 
@@ -230,7 +228,7 @@ function pow(x, n) {
 
 There are no more nested calls, so the function finishes, returning `2`.
 
-As the function finishes, its execution context is not needed any more, so it's removed from the memory. The previous one is restored off the top of the stack:
+As the function finishes, its execution context is not needed anymore, so it's removed from the memory. The previous one is restored off the top of the stack:
 
 
 <ul class="function-execution-context-list">
@@ -244,7 +242,7 @@ As the function finishes, its execution context is not needed any more, so it's
   </li>
 </ul>
 
-The execution of `pow(2, 2)` is resumed. It has the result of the subcall `pow(2, 1)`, so it also can finish the evaluation of `x * pow(x, n-1)`, returning `4`.
+The execution of `pow(2, 2)` is resumed. It has the result of the subcall `pow(2, 1)`, so it also can finish the evaluation of `x * pow(x, n - 1)`, returning `4`.
 
 Then the previous context is restored:
 
@@ -269,7 +267,7 @@ A loop-based algorithm is more memory-saving:
 function pow(x, n) {
   let result = 1;
 
-  for(let i = 0; i < n; i++) {
+  for (let i = 0; i < n; i++) {
     result *= x;
   }
 
@@ -289,7 +287,7 @@ Recursion can give a shorter code, easier to understand and support. Optimizatio
 
 Another great application of the recursion is a recursive traversal.
 
-Imagine, we have an company. The staff structure can be presented as an object:
+Imagine, we have a company. The staff structure can be presented as an object:
 
 ```js
 let company = {
@@ -360,7 +358,7 @@ function sumSalaries(department) {
     return department.reduce((prev, current) => prev + current.salary, 0); // sum the array
   } else { // case (2)
     let sum = 0;
-    for(let subdep of Object.values(department)) {
+    for (let subdep of Object.values(department)) {
       sum += sumSalaries(subdep); // recursively call for subdepartments, sum the results
     }
     return sum;
@@ -395,7 +393,7 @@ A company *department* is:
 - Either an array of people.
 - Or an object with *departments*.
 
-For web-developers there are much better known examples: HTML and XML documents.
+For web-developers there are much better-known examples: HTML and XML documents.
 
 In the HTML document, an *HTML-tag* may contain a list of:
 - Text pieces.
diff --git a/1-js/06-advanced-functions/02-rest-parameters-spread-operator/article.md b/1-js/06-advanced-functions/02-rest-parameters-spread-operator/article.md
index eaa42ab9..c2ca8168 100644
--- a/1-js/06-advanced-functions/02-rest-parameters-spread-operator/article.md
+++ b/1-js/06-advanced-functions/02-rest-parameters-spread-operator/article.md
@@ -1,6 +1,6 @@
 # Rest parameters and spread operator
 
-Many JavaScript built-in functions support on arbitrary number of arguments.
+Many JavaScript built-in functions support an arbitrary number of arguments.
 
 For instance:
 
@@ -8,9 +8,7 @@ For instance:
 - `Object.assign(dest, src1, ..., srcN)` -- copies properties from `src1..N` into `dest`.
 - ...and so on.
 
-In this chapter we'll see how to do the same. And, more important, how to feel comfortable working with such functions and arrays.
-
-[cut]
+In this chapter we'll learn how to do the same. And, more importantly, how to feel comfortable working with such functions and arrays.
 
 ## Rest parameters `...`
 
@@ -27,7 +25,7 @@ alert( sum(1, 2, 3, 4, 5) );
 
 There will be no error because of "excessive" arguments. But of course in the result only the first two will be counted.
 
-The rest parameters can be mentioned in a function definition with three dots `...`. They literally mean: "gather the remaining parameters into an array".
+The rest parameters can be mentioned in a function definition with three dots `...`. They literally mean "gather the remaining parameters into an array".
 
 For instance, to gather all arguments into array `args`:
 
@@ -35,7 +33,7 @@ For instance, to gather all arguments into array `args`:
 function sumAll(...args) { // args is the name for the array
   let sum = 0;
 
-  for(let arg of args) sum += arg;
+  for (let arg of args) sum += arg;
 
   return sum;
 }
@@ -45,9 +43,9 @@ alert( sumAll(1, 2) ); // 3
 alert( sumAll(1, 2, 3) ); // 6
 ```
 
-We can choose to get first parameters as variables, and gather only the rest.
+We can choose to get the first parameters as variables, and gather only the rest.
 
-Here the first two arguments go into variables and the rest goes to `titles` array:
+Here the first two arguments go into variables and the rest go into `titles` array:
 
 ```js run
 function showName(firstName, lastName, ...titles) {
@@ -72,7 +70,7 @@ function f(arg1, ...rest, arg2) { // arg2 after ...rest ?!
 }
 ```
 
-The `...rest` must always be the last.
+The `...rest` must always be last.
 ````
 
 ## The "arguments" variable
@@ -98,13 +96,13 @@ showName("Julius", "Caesar");
 showName("Ilya");
 ```
 
-In old times, rest parameters did not exist in the language, and `arguments` was the only way to get all arguments of the function no matter of their total number.
+In old times, rest parameters did not exist in the language, and using `arguments` was the only way to get all arguments of the function, no matter their total number.
 
-And it still works, we can use it.
+And it still works, we can use it today.
 
-But the downside is that although `arguments` is both array-like and iterable, it's not an array. It does not support array methods, so we can't say call `arguments.map(...)`.
+But the downside is that although `arguments` is both array-like and iterable, it's not an array. It does not support array methods, so we can't call `arguments.map(...)` for example.
 
-Also, it always has all arguments in it, we can't capture them partially, like we did with rest parameters.
+Also, it always contains all arguments. We can't capture them partially, like we did with rest parameters.
 
 So when we need these features, then rest parameters are preferred.
 
@@ -123,23 +121,21 @@ f(1); // 1
 ```
 As we remember, arrow functions don't have their own `this`. Now we know they don't have the special `arguments` object either.
 
-````
-
 ## Spread operator [#spread-operator]
 
 We've just seen how to get an array from the list of parameters.
 
 But sometimes we need to do exactly the reverse.
 
-For instance, there's a built-in function [Math.max](mdn:js/Math/max) that returns the greatest number from the list:
+For instance, there's a built-in function [Math.max](mdn:js/Math/max) that returns the greatest number from a list:
 
 ```js run
 alert( Math.max(3, 5, 1) ); // 5
 ```
 
-Now let's say we have an array `[3, 5, 1]`. How to call `Math.max` with it?
+Now let's say we have an array `[3, 5, 1]`. How do we call `Math.max` with it?
 
-Passing it "as it" won't work, because `Math.max` expects a list of numeric arguments, not a single array:
+Passing it "as is" won't work, because `Math.max` expects a list of numeric arguments, not a single array:
 
 ```js run
 let arr = [3, 5, 1];
@@ -149,9 +145,9 @@ alert( Math.max(arr) ); // NaN
 */!*
 ```
 
-...And surely we can't manually list items in the code `Math.max(arg[0], arg[1], arg[2])`, because we may be unsure how much are there. As our script executes, there might be many, or there might be none. Also that would be ugly.
+And surely we can't manually list items in the code `Math.max(arr[0], arr[1], arr[2])`, because we may be unsure how many there are. As our script executes, there could be a lot, or there could be none. And that would get ugly.
 
-*Spread operator* to the rescue. It looks similar to rest parameters, also using `...`, but does quite the opposite.
+*Spread operator* to the rescue! It looks similar to rest parameters, also using `...`, but does quite the opposite.
 
 When `...arr` is used in the function call, it "expands" an iterable object `arr` into the list of arguments.
 
@@ -172,7 +168,7 @@ let arr2 = [8, 3, -8, 1];
 alert( Math.max(...arr1, ...arr2) ); // 8
 ```
 
-...And even combine the spread operator with normal values:
+We can even combine the spread operator with normal values:
 
 
 ```js run
@@ -182,7 +178,7 @@ let arr2 = [8, 3, -8, 1];
 alert( Math.max(1, ...arr1, 2, ...arr2, 25) ); // 25
 ```
 
-Also spread operator can be used to merge arrays:
+Also, the spread operator can be used to merge arrays:
 
 ```js run
 let arr = [3, 5, 1];
@@ -197,7 +193,7 @@ alert(merged); // 0,3,5,1,2,8,9,15 (0, then arr, then 2, then arr2)
 
 In the examples above we used an array to demonstrate the spread operator, but any iterable will do.
 
-For instance, here we use spread operator to turn the string into array of characters:
+For instance, here we use the spread operator to turn the string into array of characters:
 
 ```js run
 let str = "Hello";
@@ -207,7 +203,7 @@ alert( [...str] ); // H,e,l,l,o
 
 The spread operator internally uses iterators to gather elements, the same way as `for..of` does.
 
-So, for a string, `for..of` returns characters and `...str` becomes `"h","e","l","l","o"`. The list of characters is passed to array initializer `[...str]`.
+So, for a string, `for..of` returns characters and `...str` becomes `"H","e","l","l","o"`. The list of characters is passed to array initializer `[...str]`.
 
 For this particular task we could also use `Array.from`, because it converts an iterable (like a string) into an array:
 
@@ -225,7 +221,7 @@ But there's a subtle difference between `Array.from(obj)` and `[...obj]`:
 - `Array.from` operates on both array-likes and iterables.
 - The spread operator operates only on iterables.
 
-So, for the task of turning something into an array, `Array.from` appears more universal.
+So, for the task of turning something into an array, `Array.from` tends to be more universal.
 
 
 ## Summary
@@ -234,8 +230,8 @@ When we see `"..."` in the code, it is either rest parameters or the spread oper
 
 There's an easy way to distinguish between them:
 
-- When `...` is at the end of function parameters, it's "rest parameters" and gathers the rest of the list into the array.
-- When `...` occurs in a function call or alike, it's called a "spread operator" and expands an array into the list.
+- When `...` is at the end of function parameters, it's "rest parameters" and gathers the rest of the list of arguments into an array.
+- When `...` occurs in a function call or alike, it's called a "spread operator" and expands an array into a list.
 
 Use patterns:
 
diff --git a/1-js/06-advanced-functions/03-closure/1-counter-independent/solution.md b/1-js/06-advanced-functions/03-closure/1-counter-independent/solution.md
index cff69a25..25ecbea4 100644
--- a/1-js/06-advanced-functions/03-closure/1-counter-independent/solution.md
+++ b/1-js/06-advanced-functions/03-closure/1-counter-independent/solution.md
@@ -2,4 +2,4 @@ The answer: **0,1.**
 
 Functions `counter` and `counter2` are created by different invocations of `makeCounter`.
 
-So they have independent outer Lexical Environments, each one has it's own `count`.
+So they have independent outer Lexical Environments, each one has its own `count`.
diff --git a/1-js/06-advanced-functions/03-closure/article.md b/1-js/06-advanced-functions/03-closure/article.md
index 015f3032..3babdad4 100644
--- a/1-js/06-advanced-functions/03-closure/article.md
+++ b/1-js/06-advanced-functions/03-closure/article.md
@@ -1,23 +1,21 @@
 
 # Closure
 
-JavaScript is a very function-oriented language. It gives a lot of freedom. A function can be created at one moment, then copied to another variable or passed as an argument to another function and called from a totally different place later.
+JavaScript is a very function-oriented language. It gives us a lot of freedom. A function can be created at one moment, then copied to another variable or passed as an argument to another function and called from a totally different place later.
 
-We know that a function can access variables outside of it. And this feature is used quite often.
+We know that a function can access variables outside of it; this feature is used quite often.
 
-But what happens when an outer variables changes? Does a function get a most recent value or the one that existed when the function was created?
+But what happens when an outer variable changes? Does a function get the most recent value or the one that existed when the function was created?
 
-Also, what happens when a function travels to another place of the code and is called from there -- does it get access to outer variables in the new place?
+Also, what happens when a function travels to another place in the code and is called from there -- does it get access to the outer variables of the new place?
 
-Different languages behave differently here, in this chapter we cover JavaScript.
-
-[cut]
+Different languages behave differently here, and in this chapter we cover the behaviour of JavaScript.
 
 ## A couple of questions
 
-Let's formulate two questions for the seed, and then study the internal mechanics piece-by-piece, so that you'll be able to answer these questions and more complex ones in the future.
+Let's consider two situations to begin with, and then study the internal mechanics piece-by-piece, so that you'll be able to answer the following questions and more complex ones in the future.
 
-1. The function `sayHi` uses an external variable `name`. When the function runs, which value of these two it's going to use?
+1. The function `sayHi` uses an external variable `name`. When the function runs, which value is it going to use?
 
     ```js
     let name = "John";
@@ -33,12 +31,12 @@ Let's formulate two questions for the seed, and then study the internal mechanic
     */!*
     ```
 
-    Such situations are common in both browser and server-side development. A function may be scheduled to execute later than it is created, for instance after a user action or a network request.
+    Such situations are common both in browser and server-side development. A function may be scheduled to execute later than it is created, for instance after a user action or a network request.
 
-    So, the question is: does it pick up latest changes?
+    So, the question is: does it pick up the latest changes?
 
 
-2. The function `makeWorker` makes another function and returns it. That new function can be called from somewhere else. Will it have access to outer variables from its creation place or the invocation place or maybe both?
+2. The function `makeWorker` makes another function and returns it. That new function can be called from somewhere else. Will it have access to the outer variables from its creation place, or the invocation place, or both?
 
     ```js
     function makeWorker() {
@@ -63,16 +61,16 @@ Let's formulate two questions for the seed, and then study the internal mechanic
 
 ## Lexical Environment
 
-To understand what's going on, let's first discuss what a "variable" technically is.
+To understand what's going on, let's first discuss what a "variable" actually is.
 
-In JavaScript, every running function, code block and the script as a whole have an associated object named *Lexical Environment*.
+In JavaScript, every running function, code block, and the script as a whole have an associated object known as the *Lexical Environment*.
 
 The Lexical Environment object consists of two parts:
 
 1. *Environment Record* -- an object that has all local variables as its properties (and some other information like the value of `this`).
-2. A reference to the *outer lexical environment*, usually the one associated with the code lexically right outside of it (outside of the current figure brackets).
+2. A reference to the *outer lexical environment*, usually the one associated with the code lexically right outside of it (outside of the current curly brackets).
 
-So, a "variable" is just a property of the special internal object, Environment Record. "To get or change a variable" means "to get or change the property of that object".
+So, a "variable" is just a property of the special internal object, Environment Record. "To get or change a variable" means "to get or change a property of the Lexical Environment".
 
 For instance, in this simple code, there is only one Lexical Environment:
 
@@ -80,7 +78,7 @@ For instance, in this simple code, there is only one Lexical Environment:
 
 This is a so-called global Lexical Environment, associated with the whole script. For browsers, all `<script>` tags share the same global environment.
 
-On the picture above, the rectangle means Environment Record (variable store) and the arrow means the outer reference. The global Lexical Environment has no outer one, so that's `null`.
+On the picture above, the rectangle means Environment Record (variable store) and the arrow means the outer reference. The global Lexical Environment has no outer reference, so it points to `null`.
 
 Here's the bigger picture of how `let` variables work:
 
@@ -89,8 +87,8 @@ Here's the bigger picture of how `let` variables work:
 Rectangles on the right-hand side demonstrate how the global Lexical Environment changes during the execution:
 
 1. When the script starts, the Lexical Environment is empty.
-2. The `let phrase` definition appears. Now it initially has no value, so `undefined` is stored.
-3. `phrase` is assigned.
+2. The `let phrase` definition appears. It has been assigned no value, so `undefined` is stored.
+3. `phrase` is assigned a value.
 4. `phrase` refers to a new value.
 
 Everything looks simple for now, right?
@@ -104,7 +102,7 @@ To summarize:
 
 Function Declarations are special. Unlike `let` variables, they are processed not when the execution reaches them, but when a Lexical Environment is created. For the global Lexical Environment, it means the moment when the script is started.
 
-...And that is why we can call a function declaration before it is defined.
+That is why we can call a function declaration before it is defined.
 
 The code below demonstrates that the Lexical Environment is non-empty from the beginning. It has `say`, because that's a Function Declaration. And later it gets `phrase`, declared with `let`:
 
@@ -113,21 +111,20 @@ The code below demonstrates that the Lexical Environment is non-empty from the b
 
 ### Inner and outer Lexical Environment
 
-During the call `say()` uses an outer variable, so let's see the details of what's going on.
+During the call, `say()` uses an outer variable, so let's look at the details of what's going on.
 
 First, when a function runs, a new function Lexical Environment is created automatically. That's a general rule for all functions. That Lexical Environment is used to store local variables and parameters of the call.
 
 <!--
-```js
-let phrase = "Hello";
-
-function say(name) {
-  alert( `${phrase}, ${name}` );
-}
-
-say("John"); // Hello, John
-```
--->
+    ```js
+    let phrase = "Hello";
+    
+    function say(name) {
+     alert( `${phrase}, ${name}` );
+    }
+    
+    say("John"); // Hello, John
+    ```-->
 
 Here's the picture of Lexical Environments when the execution is inside `say("John")`, at the line labelled with an arrow:
 
@@ -140,7 +137,7 @@ During the function call we have two Lexical Environments: the inner one (for th
 
 The inner Lexical Environment has the `outer` reference to the outer one.
 
-**When a code wants to access a variable -- it is first searched in the inner Lexical Environment, then in the outer one, then the more outer one and so on until the end of the chain.**
+**When code wants to access a variable -- it is first searched for in the inner Lexical Environment, then in the outer one, then the more outer one and so on until the end of the chain.**
 
 If a variable is not found anywhere, that's an error in strict mode. Without `use strict`, an assignment to an undefined variable creates a new global variable, for backwards compatibility.
 
@@ -151,9 +148,9 @@ Let's see how the search proceeds in our example:
 
 ![lexical environment lookup](lexical-environment-simple-lookup.png)
 
-Now we can give the answer to the first seed question from the beginning of the chapter.
+Now we can give the answer to the first question from the beginning of the chapter.
 
-**A function gets outer variables as they are now, the most recent values.**
+**A function gets outer variables as they are now; it uses the most recent values.**
 
 That's because of the described mechanism. Old variable values are not saved anywhere. When a function wants them, it takes the current values from its own or an outer Lexical Environment.
 
@@ -196,9 +193,9 @@ And if a function is called multiple times, then each invocation will have its o
 
 A function is called "nested" when it is created inside another function.
 
-Technically, that is easily possible.
+It is easily possible to do this with JavaScript.
 
-We can use it to organize the code, like this:
+We can use it to organize our code, like this:
 
 ```js
 function sayHiBye(firstName, lastName) {
@@ -216,7 +213,7 @@ function sayHiBye(firstName, lastName) {
 
 Here the *nested* function `getFullName()` is made for convenience. It can access the outer variables and so can return the full name.
 
-What's more interesting, a nested function can be returned: as a property of a new object (if the outer function creates an object with methods) or as a result by itself. And then used somewhere else. No matter where, it still keeps the access to the same outer variables.
+What's more interesting, a nested function can be returned: either as a property of a new object (if the outer function creates an object with methods) or as a result by itself. It can then be used somewhere else. No matter where, it still has access to the same outer variables.
 
 An example with the constructor function (see the chapter <info:constructor-new>):
 
@@ -252,7 +249,7 @@ alert( counter() ); // 1
 alert( counter() ); // 2
 ```
 
-Let's go on with the `makeCounter` example. It creates the "counter" function that returns the next number on each invocation. Despite being simple, slightly modified variants of that code have practical uses, for instance, as a [pseudorandom number generator](https://en.wikipedia.org/wiki/Pseudorandom_number_generator), and more. So the example is not quite artificial.
+Let's go on with the `makeCounter` example. It creates the "counter" function that returns the next number on each invocation. Despite being simple, slightly modified variants of that code have practical uses, for instance, as a [pseudorandom number generator](https://en.wikipedia.org/wiki/Pseudorandom_number_generator), and more. So the example is not as artificial as it may appear.
 
 How does the counter work internally?
 
@@ -260,22 +257,24 @@ When the inner function runs, the variable in `count++` is searched from inside
 
 ![](lexical-search-order.png)
 
-1. The locals of the nested function.
-2. The variables of the outer function.
-3. ...And further until it reaches globals.
+1. The locals of the nested function...
+2. The variables of the outer function...
+3. And so on until it reaches global variables.
 
-In that example `count` is found on the step `2`. When an outer variable is modified, it's changed where it's found. So `count++` finds the outer variable and increases it in the Lexical Environment where it belongs. Like if we had `let count = 1`.
+In this example `count` is found on  step `2`. When an outer variable is modified, it's changed where it's found. So `count++` finds the outer variable and increases it in the Lexical Environment where it belongs. Like if we had `let count = 1`.
 
-Here are two questions for you:
+Here are two questions to consider:
 
 1. Can we somehow reset the `counter` from the code that doesn't belong to `makeCounter`? E.g. after `alert` calls in the example above.
 2. If we call `makeCounter()` multiple times -- it returns many `counter` functions. Are they independent or do they share the same `count`?
 
-Try to answer them before going on reading.
+Try to answer them before you continue reading.
 
-...Are you done?
+...
 
-Okay, here we go with the answers.
+All done?
+
+Okay, let's go over the answers.
 
 1. There is no way. The `counter` is a local function variable, we can't access it from the outside.
 2. For every call to `makeCounter()` a new function Lexical Environment is created, with its own `counter`. So the resulting `counter` functions are independent.
@@ -296,15 +295,15 @@ let counter2 = makeCounter();
 alert( counter1() ); // 0
 alert( counter1() ); // 1
 
-alert( counter2() ); // 0 (independant)
+alert( counter2() ); // 0 (independent)
 ```
 
 
-Probably, the situation with outer variables is quite clear for you as of now. But in more complex situations a deeper understanding of internals may be required. So let's go ahead.
+Hopefully, the situation with outer variables is quite clear for you now. But in more complex situations a deeper understanding of internals may be required. So let's dive deeper.
 
 ## Environments in detail
 
-Now as you understand how closures work generally, we may finally descend to the very nuts and bolts.
+Now that you understand how closures work generally, we can descend to the very nuts and bolts.
 
 Here's what's going on in the `makeCounter` example step-by-step, follow it to make sure that you understand everything. Please note the additional `[[Environment]]` property that we didn't cover yet.
 
@@ -314,27 +313,27 @@ Here's what's going on in the `makeCounter` example step-by-step, follow it to m
 
     At that starting moment there is only `makeCounter` function, because it's a Function Declaration. It did not run yet.
 
-    All functions "on birth" receive a hidden property `[[Environment]]` with the reference to the Lexical Environment of their creation. We didn't talk about it yet, but technically that's a way how the function knows where it was made.
+    All functions "on birth" receive a hidden property `[[Environment]]` with a reference to the Lexical Environment of their creation. We didn't talk about it yet, but that's how the function knows where it was made.
 
-    Here, `makeCounter` is created in the global Lexical Environment, so `[[Environment]]` keeps the reference to it.
+    Here, `makeCounter` is created in the global Lexical Environment, so `[[Environment]]` keeps a reference to it.
 
     In other words, a function is "imprinted" with a reference to the Lexical Environment where it was born. And `[[Environment]]` is the hidden function property that has that reference.
 
-2. Then the code runs on, and the call to `makeCounter()` is performed. Here's the picture for the moment when the execution is on the first line inside `makeCounter()`:
+2. The code runs on, and the call to `makeCounter()` is performed. Here's a snapshot of the moment when the execution is on the first line inside `makeCounter()`:
 
     ![](lexenv-nested-makecounter-2.png)
 
     At the moment of the call of `makeCounter()`, the Lexical Environment is created, to hold its variables and arguments.
 
     As all Lexical Environments, it stores two things:
-    1. An Environment Record with local variables. In our case `count` is the only local variable (appears in it when the line with `let count` is executed).
+    1. An Environment Record with local variables. In our case `count` is the only local variable (appearing when the line with `let count` is executed).
     2. The outer lexical reference, which is set to `[[Environment]]` of the function. Here `[[Environment]]` of `makeCounter` references the global Lexical Environment.
 
     So, now we have two Lexical Environments: the first one is global, the second one is for the current `makeCounter` call, with the outer reference to global.
 
 3. During the execution of `makeCounter()`, a tiny nested function is created.
 
-    It doesn't matter whether the function is created using Function Declaration or Function Expression. All functions get the `[[Environment]]` property that references the Lexical Environment where they were made. So that new tiny nested function gets it as well.
+    It doesn't matter whether the function is created using Function Declaration or Function Expression. All functions get the `[[Environment]]` property that references the Lexical Environment in which they were made. So our new tiny nested function gets it as well.
 
     For our new nested function the value of `[[Environment]]` is the current Lexical Environment of `makeCounter()` (where it was born):
 
@@ -348,7 +347,7 @@ Here's what's going on in the `makeCounter` example step-by-step, follow it to m
 
     That function has only one line: `return count++`, that will be executed when we run it.
 
-5. When the `counter()` is called, an "empty" Lexical Environment is created for it. It has no local variables by itself. But the `[[Environment]]` of `counter` is used as the outer reference for it, so it has access to the variables of the former `makeCounter()` call, where it was created:
+5. When the `counter()` is called, an "empty" Lexical Environment is created for it. It has no local variables by itself. But the `[[Environment]]` of `counter` is used as the outer reference for it, so it has access to the variables of the former `makeCounter()` call where it was created:
 
     ![](lexenv-nested-makecounter-5.png)
 
@@ -356,9 +355,9 @@ Here's what's going on in the `makeCounter` example step-by-step, follow it to m
 
     When it looks for `count`, it finds it among the variables `makeCounter`, in the nearest outer Lexical Environment.
 
-    Please note how memory management works here. When `makeCounter()` call finished some time ago, its Lexical Environment was retained in memory, because there's a nested function with `[[Environment]]` referencing it.
+    Please note how memory management works here. Although `makeCounter()` call finished some time ago, its Lexical Environment was retained in memory, because there's a nested function with `[[Environment]]` referencing it.
 
-    Generally, a Lexical Environment object lives until there is a function which may use it. And when there are none, it is cleared.
+    Generally, a Lexical Environment object lives as long as there is a function which may use it. And only when there are none remaining, it is cleared.
 
 6. The call to `counter()` not only returns the value of `count`, but also increases it. Note that the modification is done "in place". The value of `count` is modified exactly in the environment where it was found.
 
@@ -368,7 +367,7 @@ Here's what's going on in the `makeCounter` example step-by-step, follow it to m
 
 7. Next `counter()` invocations do the same.
 
-The answer to the second seed question from the beginning of the chapter should now be obvious.
+The answer to the second question from the beginning of the chapter should now be obvious.
 
 The `work()` function in the code below uses the `name` from the place of its origin through the outer lexical environment reference:
 
@@ -376,41 +375,40 @@ The `work()` function in the code below uses the `name` from the place of its or
 
 So, the result is `"Pete"` here.
 
-...But if there were no `let name` in `makeWorker()`, then the search would go outside and take the global variable as we can see from the chain above. In that case it would be `"John"`.
+But if there were no `let name` in `makeWorker()`, then the search would go outside and take the global variable as we can see from the chain above. In that case it would be `"John"`.
 
 ```smart header="Closures"
 There is a general programming term "closure", that developers generally should know.
 
 A [closure](https://en.wikipedia.org/wiki/Closure_(computer_programming)) is a function that remembers its outer variables and can access them. In some languages, that's not possible, or a function should be written in a special way to make it happen. But as explained above, in JavaScript all functions are naturally closures (there is only one exclusion, to be covered in <info:new-function>).
 
-That is: they automatically remember where they are created using a hidden `[[Environment]]` property, and all of them can access outer variables.
+That is: they automatically remember where they were created using a hidden `[[Environment]]` property, and all of them can access outer variables.
 
-When on an interview a frontend developer gets a question about "what's a closure?", a valid answer would be a definition of the closure and an explanation that all functions in JavaScript are closures, and maybe few more words about technical details: the `[[Environment]]` property and how Lexical Environments work.
+When on an interview, a frontend developer gets a question about "what's a closure?", a valid answer would be a definition of the closure and an explanation that all functions in JavaScript are closures, and maybe few more words about technical details: the `[[Environment]]` property and how Lexical Environments work.
 ```
 
 ## Code blocks and loops, IIFE
 
 The examples above concentrated on functions. But Lexical Environments also exist for code blocks `{...}`.
 
-They are created when a code block runs and contain block-local variables. Here's a couple of examples.
+They are created when a code block runs and contain block-local variables. Here are a couple of examples.
 
 ## If
 
 In the example below, when the execution goes into `if` block, the new "if-only" Lexical Environment is created for it:
 
 <!--
-```js run
-let phrase = "Hello";
+    ```js run
+    let phrase = "Hello";
+    
+    if (true) {
+        let user = "John";
 
-if (true) {
-  let user = "John";
+        alert(`${phrase}, ${user}`); // Hello, John
+    }
 
-  alert(`${phrase}, ${user}`); // Hello, John
-}
-
-alert(user); // Error, can't see such variable!
-```
--->
+    alert(user); // Error, can't see such variable!
+    ```-->
 
 ![](lexenv-if.png)
 
@@ -420,10 +418,10 @@ For instance, after `if` finishes, the `alert` below won't see the `user`, hence
 
 ## For, while
 
-For a loop, every run has a separate Lexical Environment. If the variable is declared in `for`, then it's also local to that Lexical Environment:
+For a loop, every iteration has a separate Lexical Environment. If a variable is declared in `for`, then it's also local to that Lexical Environment:
 
 ```js run
-for(let i = 0; i < 10; i++) {
+for (let i = 0; i < 10; i++) {
   // Each loop has its own Lexical Environment
   // {i: value}
 }
@@ -443,7 +441,7 @@ For instance, in a web browser all scripts share the same global area. So if we
 
 That may happen if the variable name is a widespread word, and script authors are unaware of each other.
 
-If we'd like to evade that, we can use a code block to isolate the whole script or an area in it:
+If we'd like to avoid that, we can use a code block to isolate the whole script or a part of it:
 
 ```js run
 {
@@ -457,7 +455,7 @@ If we'd like to evade that, we can use a code block to isolate the whole script
 alert(message); // Error: message is not defined
 ```
 
-The code outside of the block (or inside another script) doesn't see variables in it, because a code block has its own Lexical Environment.
+The code outside of the block (or inside another script) doesn't see variables inside the block, because the block has its own Lexical Environment.
 
 ### IIFE
 
@@ -475,9 +473,9 @@ They look like this:
 })();
 ```
 
-Here a Function Expression is created and immediately called. So the code executes right now and has its own private variables.
+Here a Function Expression is created and immediately called. So the code executes right away and has its own private variables.
 
-The Function Expression is wrapped with brackets `(function {...})`, because when JavaScript meets `"function"` in the main code flow, it understands it as a start of Function Declaration. But a Function Declaration must have a name, so there will be an error:
+The Function Expression is wrapped with brackets `(function {...})`, because when JavaScript meets `"function"` in the main code flow, it understands it as the start of a Function Declaration. But a Function Declaration must have a name, so there will be an error:
 
 ```js run
 // Error: Unexpected token (
@@ -490,7 +488,7 @@ function() { // <-- JavaScript cannot find function name, meets ( and gives erro
 }();
 ```
 
-We can say "okay, let it be Function Declaration, let's add a name", but it won't work. JavaScript does not allow Function Declarations to be called immediately:
+We can say "okay, let it be so Function Declaration, let's add a name", but it won't work. JavaScript does not allow Function Declarations to be called immediately:
 
 ```js run
 // syntax error because of brackets below
@@ -499,7 +497,7 @@ function go() {
 }(); // <-- can't call Function Declaration immediately
 ```
 
-...So the brackets are needed to show JavaScript that the function is created in the context of another expression, and hence it's a Function Expression. Needs no name and can be called immediately.
+So, round brackets are needed to show JavaScript that the function is created in the context of another expression, and hence it's a Function Expression. It needs no name and can be called immediately.
 
 There are other ways to tell JavaScript that we mean Function Expression:
 
@@ -523,11 +521,11 @@ There are other ways to tell JavaScript that we mean Function Expression:
 }();
 ```
 
-In all cases above we declare a Function Expression and run it immediately.
+In all the above cases we declare a Function Expression and run it immediately.
 
 ## Garbage collection
 
-Lexical Environment objects that we've been talking about are subjects to same memory management rules as regular values.
+Lexical Environment objects that we've been talking about are subject to the same memory management rules as regular values.
 
 - Usually, Lexical Environment is cleaned up after the function run. For instance:
 
@@ -567,13 +565,13 @@ Lexical Environment objects that we've been talking about are subjects to same m
       return function() { alert(value); };
     }
 
-    // 3 functions in array, every of them links to Lexical Environment
+    // 3 functions in array, every one of them links to Lexical Environment
     // from the corresponding f() run
     //         LE   LE   LE
     let arr = [f(), f(), f()];
     ```
 
-- A Lexical Environment object dies when it becomes unreachable. That is: when no nested functions remain that reference it. In the code below, after `g` becomes unreachable, the `value` is also cleaned from the memory;
+- A Lexical Environment object dies when it becomes unreachable: when no nested functions remain that reference it. In the code below, after `g` becomes unreachable, the `value` is also cleaned from memory;
 
     ```js
     function f() {
@@ -598,9 +596,9 @@ But in practice, JavaScript engines try to optimize that. They analyze variable
 
 **An important side effect in V8 (Chrome, Opera) is that such variable will become unavailable in debugging.**
 
-Try running the example below with the open Developer Tools in Chrome.
+Try running the example below in Chrome with the Developer Tools open.
 
-When it pauses, in console type `alert(value)`.
+When it pauses, in the console type `alert(value)`.
 
 ```js run
 function f() {
@@ -641,6 +639,6 @@ g();
 ```warn header="See ya!"
 This feature of V8 is good to know. If you are debugging with Chrome/Opera, sooner or later you will meet it.
 
-That is not a bug of debugger, but a special feature of V8. Maybe it will be changed some time.
-You always can check for it by running examples on this page.
+That is not a bug in the debugger, but rather a special feature of V8. Perhaps it will be changed sometime.
+You always can check for it by running the examples on this page.
 ```
diff --git a/1-js/06-advanced-functions/03-closure/lexical-environment-global-3.png b/1-js/06-advanced-functions/03-closure/lexical-environment-global-3.png
index 9d2284ac..b375e33d 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexical-environment-global-3.png and b/1-js/06-advanced-functions/03-closure/lexical-environment-global-3.png differ
diff --git a/1-js/06-advanced-functions/03-closure/lexical-environment-global-3@2x.png b/1-js/06-advanced-functions/03-closure/lexical-environment-global-3@2x.png
index 808b2f44..cd22d06f 100644
Binary files a/1-js/06-advanced-functions/03-closure/lexical-environment-global-3@2x.png and b/1-js/06-advanced-functions/03-closure/lexical-environment-global-3@2x.png differ
diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index 9a089b5f..8262a93d 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -13,8 +13,6 @@ But `var` is a very different beast, that originates from very old times. It's g
 
 If you don't plan meeting such scripts you may even skip this chapter or postpone it, but then there's a chance that it bites you later.
 
-[cut]
-
 From the first sight, `var` behaves similar to `let`. That is, declares a variable:
 
 ```js run
@@ -52,7 +50,7 @@ If we used `let test` on the 2nd line, then it wouldn't be visible to `alert`. B
 The same thing for loops: `var` cannot be block- or loop-local:
 
 ```js
-for(var i = 0; i < 10; i++) {
+for (var i = 0; i < 10; i++) {
   // ...
 }
 
@@ -61,7 +59,7 @@ alert(i); // 10, "i" is visible after loop, it's a global variable
 */!*
 ```
 
-If a code block in inside a function, then `var` becomes a function-level variable:
+If a code block is inside a function, then `var` becomes a function-level variable:
 
 ```js
 function sayHi() {
@@ -76,7 +74,7 @@ sayHi();
 alert(phrase); // Error: phrase is not defined
 ```
 
-As we can see, `var` pierces through `if`, `for` or other code blocks. That's because long time ago in JavaScript blocks had no Lexical Environments. And `var` is a reminiscence of that.
+As we can see, `var` pierces through `if`, `for` or other code blocks. That's because a long time ago in JavaScript blocks had no Lexical Environments. And `var` is a reminiscence of that.
 
 ## "var" are processed at the function start
 
@@ -184,4 +182,4 @@ There are two main differences of `var`:
 
 There's one more minor difference related to the global object, we'll cover that in the next chapter.
 
-These differences are actually a bad thing most of time. First, we can't create block-local variables. And hoisting just creates more space for errors. So, for new scripts `var` is used exceptionally rarely.
+These differences are actually a bad thing most of the time. First, we can't create block-local variables. And hoisting just creates more space for errors. So, for new scripts `var` is used exceptionally rarely.
diff --git a/1-js/06-advanced-functions/06-function-object/article.md b/1-js/06-advanced-functions/06-function-object/article.md
index fb9a5798..f6234a6d 100644
--- a/1-js/06-advanced-functions/06-function-object/article.md
+++ b/1-js/06-advanced-functions/06-function-object/article.md
@@ -3,18 +3,18 @@
 
 As we already know, functions in JavaScript are values.
 
-Every value in JavaScript has the type. What type of value is a function?
+Every value in JavaScript has a type. What type is a function?
 
-In JavaScript, a function is an object.
+In JavaScript, functions are objects.
 
 A good way to imagine functions is as callable "action objects". We can not only call them, but also treat them as objects: add/remove properties, pass by reference etc.
 
 
 ## The "name" property
 
-Function objects contain few sometimes-useable properties.
+Function objects contain a few useable properties.
 
-For instance, a function name is accessible as the "name" property:
+For instance, a function's name is accessible as the "name" property:
 
 ```js run
 function sayHi() {
@@ -24,7 +24,7 @@ function sayHi() {
 alert(sayHi.name); // sayHi
 ```
 
-What's more funny, the name-assigning logic is smart. It also sticks the right name to function that are used in assignments:
+What's more funny, the name-assigning logic is smart. It also assigns the correct name to functions that are used in assignments:
 
 ```js run
 let sayHi = function() {
@@ -34,7 +34,7 @@ let sayHi = function() {
 alert(sayHi.name); // sayHi (works!)
 ```
 
-Also works if the assignment is done via a default value:
+It also works if the assignment is done via a default value:
 
 ```js run
 function f(sayHi = function() {}) {
@@ -65,9 +65,7 @@ alert(user.sayHi.name); // sayHi
 alert(user.sayBye.name); // sayBye
 ```
 
-There's no magic though. There are cases when there's no way to figure out the right name.
-
-Then it's empty, like here:
+There's no magic though. There are cases when there's no way to figure out the right name. In that case, the name property empty, like here:
 
 ```js
 // function created inside array
@@ -77,7 +75,7 @@ alert( arr[0].name ); // <empty string>
 // the engine has no way to set up the right name, so there is none
 ```
 
-In practice, most functions do have a name.
+In practice, however, most functions do have a name.
 
 ## The "length" property
 
@@ -97,14 +95,14 @@ Here we can see that rest parameters are not counted.
 
 The `length` property is sometimes used for introspection in functions that operate on other functions.
 
-For instance, in the code below `ask` function accepts a `question` to ask and an arbitrary number of `handler` functions to call.
+For instance, in the code below the `ask` function accepts a `question` to ask and an arbitrary number of `handler` functions to call.
 
-When a user answers, it calls the handlers. We can pass two kinds of handlers:
+Once a user provides their answer, the function calls the handlers. We can pass two kinds of handlers:
 
-- A zero-argument function, then it is only called for a positive answer.
-- A function with arguments, then it is called in any case and gets the answer.
+- A zero-argument function, which is only called when the user gives a positive answer.
+- A function with arguments, which is called in either case and returns an answer.
 
-The idea is that we have a simple no-arguments handler syntax for positive cases (most frequent variant), but allow to provide universal handlers as well.
+The idea is that we have a simple, no-arguments handler syntax for positive cases (most frequent variant), but are able to provide universal handlers as well.
 
 To call `handlers` the right way, we examine the `length` property:
 
@@ -158,7 +156,7 @@ A property assigned to a function like `sayHi.counter = 0` does *not* define a l
 We can treat a function as an object, store properties in it, but that has no effect on its execution. Variables never use function properties and vice versa. These are just parallel words.
 ```
 
-Function properties can replace the closure sometimes. For instance, we can rewrite the counter example from the chapter <info:closure> to use a function property:
+Function properties can replace closures sometimes. For instance, we can rewrite the counter function example from the chapter <info:closure> to use a function property:
 
 ```js run
 function makeCounter() {
@@ -181,9 +179,9 @@ alert( counter() ); // 1
 
 The `count` is now stored in the function directly, not in its outer Lexical Environment.
 
-Is it worse or better than using the closure?
+Is it better or worse than using a closure?
 
-The main difference is that if the value of `count` lives in an outer variable, then an external code is unable to access it. Only nested functions may modify it. And if it's bound to function, then such thing is possible:
+The main difference is that if the value of `count` lives in an outer variable, then external code is unable to access it. Only nested functions may modify it. And if it's bound to a function, then such a thing is possible:
 
 ```js run
 function makeCounter() {
@@ -205,11 +203,11 @@ alert( counter() ); // 10
 */!*
 ```
 
-So it depends on our aims which variant to choose.
+So the choice of implementation depends on our aims.
 
 ## Named Function Expression
 
-Named Function Expression or, shortly, NFE, is a term for Function Expressions that have a name.
+Named Function Expression, or NFE, is a term for Function Expressions that have a name.
 
 For instance, let's take an ordinary Function Expression:
 
@@ -219,7 +217,7 @@ let sayHi = function(who) {
 };
 ```
 
-...And add a name to it:
+And add a name to it:
 
 ```js
 let sayHi = function *!*func*/!*(who) {
@@ -227,7 +225,7 @@ let sayHi = function *!*func*/!*(who) {
 };
 ```
 
-Did we do anything sane here? What's the role of that additional `"func"` name?
+Did we achieve anything here? What's the purpose of that additional `"func"` name?
 
 First let's note, that we still have a Function Expression. Adding the name `"func"` after `function` did not make it a Function Declaration, because it is still created as a part of an assignment expression.
 
@@ -245,10 +243,10 @@ sayHi("John"); // Hello, John
 
 There are two special things about the name `func`:
 
-1. It allows to reference the function from inside itself.
+1. It allows the function to reference itself internally.
 2. It is not visible outside of the function.
 
-For instance, the function `sayHi` below re-calls itself with `"Guest"` if no `who` is provided:
+For instance, the function `sayHi` below calls itself again with `"Guest"` if no `who` is provided:
 
 ```js run
 let sayHi = function *!*func*/!*(who) {
@@ -305,9 +303,9 @@ welcome(); // Error, the nested sayHi call doesn't work any more!
 
 That happens because the function takes `sayHi` from its outer lexical environment. There's no local `sayHi`, so the outer variable is used. And at the moment of the call that outer `sayHi` is `null`.
 
-The optional name which we can put into the Function Expression is exactly meant to solve this kind of problems.
+The optional name which we can put into the Function Expression is meant to solve exactly these kinds of problems.
 
-Let's use it to fix the code:
+Let's use it to fix our code:
 
 ```js run
 let sayHi = function *!*func*/!*(who) {
@@ -326,9 +324,9 @@ sayHi = null;
 welcome(); // Hello, Guest (nested call works)
 ```
 
-Now it works, because the name `"func"` is function-local. It is not taken from outside (and not visible there). The specification guarantees that it always references the current function.
+Now it works, because the name `"func"` is function-local. It is not taken from outside (and not visible there). The specification guarantees that it will always reference the current function.
 
-The outer code still has it's variable `sayHi` or `welcome` later. And `func` is an "internal function name", how it calls itself privately.
+The outer code still has it's variable `sayHi` or `welcome`. And `func` is an "internal function name", how the function can call itself internally.
 
 ```smart header="There's no such thing for Function Declaration"
 The "internal name" feature described here is only available for Function Expressions, not to Function Declarations. For Function Declarations, there's just no syntax possibility to add a one more "internal" name.
@@ -345,10 +343,10 @@ Here we covered their properties:
 - `name` -- the function name. Exists not only when given in the function definition, but also for assignments and object properties.
 - `length` -- the number of arguments in the function definition. Rest parameters are not counted.
 
-If the function is declared as a Function Expression (not in the main code flow), and it carries the name, then it is called Named Function Expression. The name can be used inside to reference itself, for recursive calls or such.
+If the function is declared as a Function Expression (not in the main code flow), and it carries the name, then it is called a Named Function Expression. The name can be used inside to reference itself, for recursive calls or such.
 
-Also, functions may carry additional properties. Many well-known JavaScript libraries make a great use of this feature.
+Also, functions may carry additional properties. Many well-known JavaScript libraries make great use of this feature.
 
-They create a "main" function and attach many other "helper" functions to it. For instance, the [jquery](https://jquery.com) library creates a function named `$`. The [lodash](https://lodash.com) library creates a function `_`. And then adds `_.clone`, `_.keyBy` and other properties to (see the [docs](https://lodash.com/docs) when you want learn more about them). Actually, they do it to less pollute the global space, so that a single library gives only one global variable. That lowers the chance of possible naming conflicts.
+They create a "main" function and attach many other "helper" functions to it. For instance, the [jquery](https://jquery.com) library creates a function named `$`. The [lodash](https://lodash.com) library creates a function `_`. And then adds `_.clone`, `_.keyBy` and other properties to (see the [docs](https://lodash.com/docs) when you want learn more about them). Actually, they do it to lessen their pollution of the global space, so that a single library gives only one global variable. That reduces the possibility of naming conflicts.
 
 So, a function can do a useful job by itself and also carry a bunch of other functionality in properties.
diff --git a/1-js/06-advanced-functions/07-new-function/article.md b/1-js/06-advanced-functions/07-new-function/article.md
index b44da634..e0750e32 100644
--- a/1-js/06-advanced-functions/07-new-function/article.md
+++ b/1-js/06-advanced-functions/07-new-function/article.md
@@ -3,27 +3,25 @@
 
 There's one more way to create a function. It's rarely used, but sometimes there's no alternative.
 
-[cut]
-
-## The syntax
+## Syntax
 
 The syntax for creating a function:
 
 ```js
-let func = new Function('a', 'b', 'return a + b');
+let func = new Function ([arg1[, arg2[, ...argN]],] functionBody)
 ```
 
-All arguments of `new Function` are strings. Parameters go first, and the body is the last.
+In other words, function parameters (or, more precisely, names for them) go first, and the body is last. All arguments are strings.
 
-For instance:
+It's easier to understand by looking at an example. Here's a function with two arguments:
 
 ```js run
-let sum = new Function('arg1', 'arg2', 'return arg1 + arg2');
+let sum = new Function('a', 'b', 'return a + b'); 
 
 alert( sum(1, 2) ); // 3
 ```
 
-If there are no arguments, then there will be only body:
+If there are no arguments, then there's only a single argument, the function body:
 
 ```js run
 let sayHi = new Function('alert("Hello")');
@@ -31,22 +29,22 @@ let sayHi = new Function('alert("Hello")');
 sayHi(); // Hello
 ```
 
-The major difference from other ways we've seen -- the function is created literally from a string, that is passed at run time. 
+The major difference from other ways we've seen is that the function is created literally from a string, that is passed at run time. 
 
 All previous declarations required us, programmers, to write the function code in the script.
 
-But `new Function` allows to turn any string into a function, for example we can receive a new function from the server and then execute it:
+But `new Function` allows to turn any string into a function. For example, we can receive a new function from a server and then execute it:
 
 ```js
-let str = ... receive the code from the server dynamically ...
+let str = ... receive the code from a server dynamically ...
 
 let func = new Function(str);
 func();
 ```
 
-It is used in very specific cases, like when we receive the code from the server, or to dynamically compile a function from a template. The need for that usually arises at advanced stages of development.
+It is used in very specific cases, like when we receive code from a server, or to dynamically compile a function from a template. The need for that usually arises at advanced stages of development.
 
-## The closure
+## Closure
 
 Usually, a function remembers where it was born in the special property `[[Environment]]`. It references the Lexical Environment from where it's created.
 
@@ -85,29 +83,29 @@ getFunc()(); // *!*"test"*/!*, from the Lexical Environment of getFunc
 
 This special feature of `new Function` looks strange, but appears very useful in practice.
 
-Imagine that we really have to create a function from the string. The code of that function is not known at the time of writing the script (that's why we don't use regular functions), but will be known in the process of execution. We may receive it from the server or from another source.
+Imagine that we must create a function from a string. The code of that function is not known at the time of writing the script (that's why we don't use regular functions), but will be known in the process of execution. We may receive it from the server or from another source.
 
 Our new function needs to interact with the main script.
 
-Maybe we want it to be able to access outer local variables?
+Perhaps we want it to be able to access outer local variables?
 
-But the problem is that before JavaScript is published to production, it's compressed using a *minifier* -- a special program that shrinks code by removing extra comments, spaces and -- what's important, renames local variables into shorter ones.
+The problem is that before JavaScript is published to production, it's compressed using a *minifier* -- a special program that shrinks code by removing extra comments, spaces and -- what's important, renames local variables into shorter ones.
 
-For instance, if a function has `let userName`, minifier replaces it `let a` (or another letter if this one is occupied), and does it everywhere. That's usually a safe thing to do, because the variable is local, nothing outside the function can access it. And inside the function minifier replaces every mention of it. Minifiers are smart, they analyze the code structure, not just find-and-replace, so that's ok.
+For instance, if a function has `let userName`, minifier replaces it `let a` (or another letter if this one is occupied), and does it everywhere. That's usually a safe thing to do, because the variable is local, nothing outside the function can access it. And inside the function, minifier replaces every mention of it. Minifiers are smart, they analyze the code structure, so they don't break anything. They're not just a dumb find-and-replace.
 
-...But if `new Function` could access outer variables, then it would be unable to find `userName`.
+But, if `new Function` could access outer variables, then it would be unable to find `userName`, since this is passed in as a string *after* the code is minified.
 
 **Even if we could access outer lexical environment in `new Function`, we would have problems with minifiers.**
 
 The "special feature" of `new Function` saves us from mistakes.
 
-And it enforces better code. If we need to pass something to a function, created by `new Function`, we should pass it explicitly as arguments.
+And it enforces better code. If we need to pass something to a function created by `new Function`, we should pass it explicitly as an argument.
 
-The "sum" function actually does that right:
+Our "sum" function actually does that right:
 
 ```js run 
 *!*
-let sum = new Function('a', 'b', ' return a + b; ');
+let sum = new Function('a', 'b', 'return a + b');
 */!*
 
 let a = 1, b = 2;
@@ -131,9 +129,9 @@ For historical reasons, arguments can also be given as a comma-separated list.
 These three mean the same:
 
 ```js 
-new Function('a', 'b', ' return a + b; '); // basic syntax
-new Function('a,b', ' return a + b; '); // comma-separated
-new Function('a , b', ' return a + b; '); // comma-separated with spaces
+new Function('a', 'b', 'return a + b'); // basic syntax
+new Function('a,b', 'return a + b'); // comma-separated
+new Function('a , b', 'return a + b'); // comma-separated with spaces
 ```
 
-Functions created with `new Function`, have `[[Environment]]` referencing the global Lexical Environment, not the outer one. Hence, they can not use outer variables. But that's actually good, because it saves us from errors. Explicit parameters passing is a much better thing architecturally and has no problems with minifiers.
\ No newline at end of file
+Functions created with `new Function`, have `[[Environment]]` referencing the global Lexical Environment, not the outer one. Hence, they cannot use outer variables. But that's actually good, because it saves us from errors. Passing parameters explicitly is a much better method architecturally and causes no problems with minifiers.
diff --git a/1-js/06-advanced-functions/08-settimeout-setinterval/3-rewrite-settimeout/solution.md b/1-js/06-advanced-functions/08-settimeout-setinterval/3-rewrite-settimeout/solution.md
index 42a6a004..0183a479 100644
--- a/1-js/06-advanced-functions/08-settimeout-setinterval/3-rewrite-settimeout/solution.md
+++ b/1-js/06-advanced-functions/08-settimeout-setinterval/3-rewrite-settimeout/solution.md
@@ -15,7 +15,7 @@ function count() {
 
   if (i == 1000000000) {
     alert("Done in " + (Date.now() - start) + 'ms');
-    cancelInterval(timer);
+    clearInterval(timer);
   }
 
 }
diff --git a/1-js/06-advanced-functions/08-settimeout-setinterval/4-settimeout-result/task.md b/1-js/06-advanced-functions/08-settimeout-setinterval/4-settimeout-result/task.md
index faca4600..667c8ffa 100644
--- a/1-js/06-advanced-functions/08-settimeout-setinterval/4-settimeout-result/task.md
+++ b/1-js/06-advanced-functions/08-settimeout-setinterval/4-settimeout-result/task.md
@@ -6,14 +6,14 @@ importance: 5
 
 In the code below there's a `setTimeout` call scheduled, then a heavy calculation is run, that takes more than 100ms to finish.
 
-When the scheduled function will run?
+When will the scheduled function run?
 
 1. After the loop.
 2. Before the loop.
 3. In the beginning of the loop.
 
 
-What `alert` is going to show?
+What is `alert` going to show?
 
 ```js
 let i = 0;
diff --git a/1-js/06-advanced-functions/08-settimeout-setinterval/article.md b/1-js/06-advanced-functions/08-settimeout-setinterval/article.md
index ec645913..412e2e3e 100644
--- a/1-js/06-advanced-functions/08-settimeout-setinterval/article.md
+++ b/1-js/06-advanced-functions/08-settimeout-setinterval/article.md
@@ -10,8 +10,6 @@ There are two methods for it:
 These methods are not a part of JavaScript specification. But most environments have the internal scheduler and provide these methods. In particular, they are supported in all browsers and Node.JS.
 
 
-[cut]
-
 ## setTimeout
 
 The syntax:
@@ -91,7 +89,7 @@ let timerId = setTimeout(...);
 clearTimeout(timerId);
 ```
 
-In the code below we schedule the function and then cancel it (changed our mind). As a result, nothing happens:
+In the code below, we schedule the function and then cancel it (changed our mind). As a result, nothing happens:
 
 ```js run no-beautify
 let timerId = setTimeout(() => alert("never happens"), 1000);
@@ -101,7 +99,7 @@ clearTimeout(timerId);
 alert(timerId); // same identifier (doesn't become null after canceling)
 ```
 
-As we can see from `alert` output, in a browser the timer identifier is a number. In other environments, that can be something else. For instance, Node.JS returns a timer object with additional methods.
+As we can see from `alert` output, in a browser the timer identifier is a number. In other environments, this can be something else. For instance, Node.JS returns a timer object with additional methods.
 
 Again, there is no universal specification for these methods, so that's fine.
 
@@ -109,7 +107,7 @@ For browsers, timers are described in the [timers section](https://www.w3.org/TR
 
 ## setInterval
 
-Method `setInterval` has the same syntax as `setTimeout`:
+The `setInterval` method has the same syntax as `setTimeout`:
 
 ```js
 let timerId = setInterval(func|code, delay[, arg1, arg2...])
@@ -154,11 +152,11 @@ let timerId = setTimeout(function tick() {
 }, 2000);
 ```
 
-The `setTimeout` above schedules next call right at the end of the current one `(*)`.
+The `setTimeout` above schedules the next call right at the end of the current one `(*)`.
 
-Recursive `setTimeout` is more flexible method than `setInterval`. This way the next call may be scheduled differently, depending on the results of the current one.
+The recursive `setTimeout` is a more flexible method than `setInterval`. This way the next call may be scheduled differently, depending on the results of the current one.
 
-For instance, we need to write a service that each 5 seconds sends a request to server asking for data, but in case the server is overloaded, it should increase the interval to 10, 20, 40 seconds...
+For instance, we need to write a service that sends a request to the server every 5 seconds asking for data, but in case the server is overloaded, it should increase the interval to 10, 20, 40 seconds...
 
 Here's the pseudocode:
 ```js
@@ -178,7 +176,7 @@ let timerId = setTimeout(function request() {
 ```
 
 
-And if we regulary have CPU-hungry tasks, then we can measure the time taken by the execution and plan the next call sooner or later.
+And if we regularly have CPU-hungry tasks, then we can measure the time taken by the execution and plan the next call sooner or later.
 
 **Recursive `setTimeout` guarantees a delay between the executions, `setInterval` -- does not.**
 
@@ -205,23 +203,23 @@ For `setInterval` the internal scheduler will run `func(i)` every 100ms:
 
 ![](setinterval-interval.png)
 
-Did you notice?...
+Did you notice?
 
 **The real delay between `func` calls for `setInterval` is less than in the code!**
 
-That's natural, because the time taken by `func` execution "consumes" a part of the interval.
+That's normal, because the time taken by `func`'s execution "consumes" a part of the interval.
 
-It is possible that `func` execution turns out to be longer than we expected and takes more than 100ms.
+It is possible that `func`'s execution turns out to be longer than we expected and takes more than 100ms.
 
-In this case the engine waits for `func` to complete, then checks the scheduler and if the time is up, then runs it again *immediately*.
+In this case the engine waits for `func` to complete, then checks the scheduler and if the time is up, runs it again *immediately*.
 
-In the edge case, if the function always executes longer than `delay` ms, then the calls will happen without pause at all.
+In the edge case, if the function always executes longer than `delay` ms, then the calls will happen without a pause at all.
 
-And here is the picture for recursive `setTimeout`:
+And here is the picture for the recursive `setTimeout`:
 
 ![](settimeout-interval.png)
 
-**Recursive `setTimeout` guarantees the fixed delay (here 100ms).**
+**The recursive `setTimeout` guarantees the fixed delay (here 100ms).**
 
 That's because a new call is planned at the end of the previous one.
 
@@ -233,9 +231,9 @@ When a function is passed in `setInterval/setTimeout`, an internal reference is
 setTimeout(function() {...}, 100);
 ```
 
-For `setInterval` the function stays in memory until `cancelInterval` is called.
+For `setInterval` the function stays in memory until `clearInterval` is called.
 
-There's a side-effect. A function references the outer lexical environment, so, while it lives, outer variables live too. They may take much more memory than the function itself. So when we don't need the scheduled function any more, it's better to cancel it, even if it's very small.
+There's a side-effect. A function references the outer lexical environment, so, while it lives, outer variables live too. They may take much more memory than the function itself. So when we don't need the scheduled function anymore, it's better to cancel it, even if it's very small.
 ````
 
 ## setTimeout(...,0)
@@ -258,11 +256,11 @@ The first line "puts the call into calendar after 0ms". But the scheduler will o
 
 ### Splitting CPU-hungry tasks
 
-There's a trick to split CPU-hungry task using `setTimeout`.
+There's a trick to split CPU-hungry tasks using `setTimeout`.
 
-For instance, syntax highlighting script (used to colorize code examples on this page) is quite CPU-heavy. To hightlight the code, it performs the analysis, creates many colored elements, adds them to the document -- for a big text that takes a lot. It may even cause the browser to "hang", that's unacceptable.
+For instance, a syntax-highlighting script (used to colorize code examples on this page) is quite CPU-heavy. To highlight the code, it performs the analysis, creates many colored elements, adds them to the document -- for a big text that takes a lot. It may even cause the browser to "hang", which is unacceptable.
 
-So we can split the long text to pieces. First 100 lines, then plan another 100 lines using `setTimeout(...,0)`, and so on.
+So we can split the long text into pieces. First 100 lines, then plan another 100 lines using `setTimeout(...,0)`, and so on.
 
 For clarity, let's take a simpler example for consideration. We have a function to count from `1` to `1000000000`.
 
@@ -276,7 +274,7 @@ let start = Date.now();
 function count() {
 
   // do a heavy job
-  for(let j = 0; j < 1e9; j++) {
+  for (let j = 0; j < 1e9; j++) {
     i++;
   }
 
@@ -286,7 +284,7 @@ function count() {
 count();
 ```
 
-The browser may even show "the script takes too long" warning (but hopefully won't, the number is not very big).
+The browser may even show "the script takes too long" warning (but hopefully it won't, because the number is not very big).
 
 Let's split the job using the nested `setTimeout`:
 
@@ -319,15 +317,15 @@ We do a part of the job `(*)`:
 
 1. First run: `i=1...1000000`.
 2. Second run: `i=1000001..2000000`.
-3. ...and so on, the `while` checks if `i` is evenly divided by `100000`.
+3. ...and so on, the `while` checks if `i` is evenly divided by `1000000`.
 
 Then the next call is scheduled in `(*)` if we're not done yet.
 
-Pauses between `count` executions provide just enough "breath" for the JavaScript engine to do something else, to react on other user actions.
+Pauses between `count` executions provide just enough "breath" for the JavaScript engine to do something else, to react to other user actions.
 
-The notable thing is that both variants: with and without splitting the job by `setInterval` -- are comparable in speed. There's no much difference in the overall counting time.
+The notable thing is that both variants -- with and without splitting the job by `setTimeout` -- are comparable in speed. There's no much difference in the overall counting time.
 
-To make them closer let's make an improvement.
+To make them closer, let's make an improvement.
 
 We'll move the scheduling in the beginning of the `count()`:
 
@@ -356,14 +354,14 @@ function count() {
 count();
 ```
 
-Now when we start to `count()` and know that we'll need to `count()` more -- we schedule that immediately, before doing the job.
+Now when we start to `count()` and know that we'll need to `count()` more, we schedule that immediately, before doing the job.
 
-If you run it, easy to notice that it takes significantly less time.
+If you run it, it's easy to notice that it takes significantly less time.
 
 ````smart header="Minimal delay of nested timers in-browser"
-In the browser, there's a limitation of how often nested timers can run. The [HTML5 standard](https://www.w3.org/TR/html5/webappapis.html#timers) says: "after five nested timers..., the interval is forced to be at least four milliseconds.".
+In the browser, there's a limitation of how often nested timers can run. The [HTML5 standard](https://www.w3.org/TR/html5/webappapis.html#timers) says: "after five nested timers, the interval is forced to be at least four milliseconds.".
 
-Let's demonstrate what it means by the example below. The `setTimeout` call in it re-schedules itself after `0ms`. Each call remembers the real time from the previous one in the `times` array. What the real delays look like? Let's see:
+Let's demonstrate what it means with the example below. The `setTimeout` call in it re-schedules itself after `0ms`. Each call remembers the real time from the previous one in the `times` array. What do the real delays look like? Let's see:
 
 ```js run
 let start = Date.now();
@@ -401,7 +399,7 @@ Here's the demo:
   let i = 0;
 
   function count() {
-    for(let j = 0; j < 1e6; j++) {
+    for (let j = 0; j < 1e6; j++) {
       i++;
       // put the current i into the <div>
       // (we'll talk more about innerHTML in the specific chapter, should be obvious here)
@@ -461,4 +459,4 @@ For example, the in-browser timer may slow down for a lot of reasons:
 - The browser tab is in the background mode.
 - The laptop is on battery.
 
-All that may decrease the minimal timer resolution (the minimal delay) to 300ms or even 1000ms depending on the browser and settings.
+All that may increase the minimal timer resolution (the minimal delay) to 300ms or even 1000ms depending on the browser and settings.
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/_js.view/test.js b/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/_js.view/test.js
index 7e84f3c9..5adfcb97 100644
--- a/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/_js.view/test.js
+++ b/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/_js.view/test.js
@@ -24,7 +24,7 @@ describe("spy", function() {
     let wrappedSum = spy(sum);
 
     assert.equal(wrappedSum(1, 2), 3);
-    assert(spy.calledWith(1, 2));
+    assert(sum.calledWith(1, 2));
   });
 
 
@@ -36,9 +36,9 @@ describe("spy", function() {
 
     calc.wrappedSum = spy(calc.sum);
 
-    assert.equal(calculator.wrappedSum(1, 2), 3);
-    assert(spy.calledWith(1, 2));
-    assert(spy.calledOn(calculator));
+    assert.equal(calc.wrappedSum(1, 2), 3);
+    assert(calc.sum.calledWith(1, 2));
+    assert(calc.sum.calledOn(calc));
   });
 
-});
\ No newline at end of file
+});
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/solution.md b/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/solution.md
index 4a79d3e1..19a07201 100644
--- a/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/solution.md
+++ b/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/solution.md
@@ -1 +1 @@
-Here we can use `log.push(args)` to store all arguments in the log and `f.apply(this, args)` to forward the call.
+Here we can use `calls.push(args)` to store all arguments in the log and `f.apply(this, args)` to forward the call.
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/task.md b/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/task.md
index e4a30cb8..9ebb7abf 100644
--- a/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/task.md
+++ b/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/task.md
@@ -22,7 +22,7 @@ work = spy(work);
 work(1, 2); // 3
 work(4, 5); // 9
 
-for(let args of work.calls) {
+for (let args of work.calls) {
   alert( 'call:' + args.join() ); // "call:1,2", "call:4,5"
 }
 ```
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/article.md b/1-js/06-advanced-functions/09-call-apply-decorators/article.md
index 707bbf58..3f86b0d3 100644
--- a/1-js/06-advanced-functions/09-call-apply-decorators/article.md
+++ b/1-js/06-advanced-functions/09-call-apply-decorators/article.md
@@ -2,8 +2,6 @@
 
 JavaScript gives exceptional flexibility when dealing with functions. They can be passed around, used as objects, and now we'll see how to *forward* calls between them and *decorate* them.
 
-[cut]
-
 ## Transparent caching
 
 Let's say we have a function `slow(x)` which is CPU-heavy, but its results are stable. In other words, for the same `x` it always returns the same result.
@@ -70,7 +68,7 @@ To summarize, there are several benefits of using a separate `cachingDecorator`
 
 The caching decorator mentioned above is not suited to work with object methods.
 
-For instance, in the code below `user.format()` stops working after the decoration:
+For instance, in the code below `worker.slow()` stops working after the decoration:
 
 ```js run
 // we'll make worker.slow caching
@@ -135,7 +133,7 @@ func.call(context, arg1, arg2, ...)
 
 It runs `func` providing the first argument as `this`, and the next as the arguments.
 
-To put it simple, these two calls do almost the same:
+To put it simply, these two calls do almost the same:
 ```js
 func(1, 2, 3);
 func.call(obj, 1, 2, 3)
@@ -154,8 +152,8 @@ let user = { name: "John" };
 let admin = { name: "Admin" };
 
 // use call to pass different objects as "this"
-sayHi.call( user ); // John
-sayHi.call( admin ); // Admin
+sayHi.call( user ); // this = John
+sayHi.call( admin ); // this = Admin
 ```
 
 And here we use `call` to call `say` with the given context and phrase:
@@ -241,7 +239,7 @@ There are many solutions possible:
 
 1. Implement a new (or use a third-party) map-like data structure that is more versatile and allows multi-keys.
 2. Use nested maps: `cache.set(min)` will be a `Map` that stores the pair `(max, result)`. So we can get `result` as `cache.get(min).get(max)`.
-3. Join two values into one. In our particular case we can just use a string `"min,max"` as the `Map` key. For flexibility, we can allow to provide a *hashing function* for the decorator, that knows how to make a one value from many.
+3. Join two values into one. In our particular case we can just use a string `"min,max"` as the `Map` key. For flexibility, we can allow to provide a *hashing function* for the decorator, that knows how to make one value from many.
 
 
 For many practical applications, the 3rd variant is good enough, so we'll stick to it.
@@ -319,7 +317,7 @@ let wrapper = function() {
 
 That's called *call forwarding*. The `wrapper` passes everything it gets: the context `this` and arguments to `anotherFunction` and returns back its result.
 
-When an external code calls such `wrapper`, it is undistinguishable from the call of the original function.
+When an external code calls such `wrapper`, it is indistinguishable from the call of the original function.
 
 Now let's bake it all into the more powerful `cachingDecorator`:
 
@@ -438,7 +436,7 @@ So, technically it takes `this` and joins `this[0]`, `this[1]` ...etc together.
 
 *Decorator* is a wrapper around a function that alters its behavior. The main job is still carried out by the function.
 
-It is generally safe to replace a function or a method with a decorated one, except for one little thing. If the original function had properties on it, like `func.calledCount` or whatever, then the decorated one will not provide them. Because that is a wrapper. So one need to be careful if one uses them. Some decorators provide their own properties.
+It is generally safe to replace a function or a method with a decorated one, except for one little thing. If the original function had properties on it, like `func.calledCount` or whatever, then the decorated one will not provide them. Because that is a wrapper. So one needs to be careful if one uses them. Some decorators provide their own properties.
 
 Decorators can be seen as "features" or "aspects" that can be added to a function. We can add one or add many. And all this without changing its code!
 
diff --git a/1-js/06-advanced-functions/10-bind/article.md b/1-js/06-advanced-functions/10-bind/article.md
index 87637929..f9369096 100644
--- a/1-js/06-advanced-functions/10-bind/article.md
+++ b/1-js/06-advanced-functions/10-bind/article.md
@@ -9,8 +9,6 @@ When using `setTimeout` with object methods or passing object methods along, the
 
 Suddenly, `this` just stops working right. The situation is typical for novice developers, but happens with experienced ones as well.
 
-[cut]
-
 ## 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.
@@ -72,7 +70,7 @@ setTimeout(() => user.sayHi(), 1000); // Hello, John!
 
 Looks fine, but a slight vulnerability appears in our code structure.
 
-What if before `setTimeout` triggers (there's one second delay!) `user` changes value? Then, suddenly, the it will call the wrong object!
+What if before `setTimeout` triggers (there's one second delay!) `user` changes value? Then, suddenly, it will call the wrong object!
 
 
 ```js run
diff --git a/1-js/06-advanced-functions/11-currying-partials/1-ask-currying/task.md b/1-js/06-advanced-functions/11-currying-partials/1-ask-currying/task.md
index 915d8aee..f8b83d7a 100644
--- a/1-js/06-advanced-functions/11-currying-partials/1-ask-currying/task.md
+++ b/1-js/06-advanced-functions/11-currying-partials/1-ask-currying/task.md
@@ -8,7 +8,7 @@ The task is a little more complex variant of <info:task/question-use-bind>.
 
 The `user` object was modified. Now instead of two functions `loginOk/loginFail`, it has a single function `user.login(true/false)`.
 
-What to pass `askPassword` in the code below, so that it calls `user.login(true)` as `ok` and `user.login(fail)` as `fail`?
+What to pass `askPassword` in the code below, so that it calls `user.login(true)` as `ok` and `user.login(false)` as `fail`?
 
 ```js
 function askPassword(ok, fail) {
diff --git a/1-js/06-advanced-functions/11-currying-partials/article.md b/1-js/06-advanced-functions/11-currying-partials/article.md
index 6e7b78e8..e866f38a 100644
--- a/1-js/06-advanced-functions/11-currying-partials/article.md
+++ b/1-js/06-advanced-functions/11-currying-partials/article.md
@@ -5,12 +5,10 @@ libs:
 
 # Currying and partials
 
-Till now we were only talking about binding `this`. Now let's make a step further.
+Until now we have only been talking about binding `this`. Let's take it a step further.
 
 We can bind not only `this`, but also arguments. That's rarely done, but sometimes can be handy.
 
-[cut]
-
 The full syntax of `bind`:
 
 ```js
@@ -97,7 +95,7 @@ user.sayNow = partial(user.say, new Date().getHours() + ':' + new Date().getMinu
 
 user.sayNow("Hello");
 // Something like:
-// [10:00] Hello, John!
+// [10:00] John: Hello!
 ```
 
 The result of `partial(func[, arg1, arg2...])` call is a wrapper `(*)` that calls `func` with:
@@ -148,7 +146,7 @@ More advanced implementations of currying like [_.curry](https://lodash.com/docs
 
 ```js
 function curry(f) {
-  return function(..args) {
+  return function(...args) {
     // if args.length == f.length (as many arguments as f has),
     //   then pass the call to f
     // otherwise return a partial function that fixes args as first arguments
diff --git a/1-js/06-advanced-functions/12-arrow-functions/article.md b/1-js/06-advanced-functions/12-arrow-functions/article.md
index dcae22a4..1ade1a41 100644
--- a/1-js/06-advanced-functions/12-arrow-functions/article.md
+++ b/1-js/06-advanced-functions/12-arrow-functions/article.md
@@ -2,8 +2,6 @@
 
 Let's revisit arrow functions.
 
-[cut]
-
 Arrow functions are not just a "shorthand" for writing small stuff.
 
 JavaScript is full of situations where we need to write a small function, that's executed somewhere else.
@@ -125,4 +123,4 @@ Arrow functions:
 - Can't be called with `new`.
 - (They also don't have `super`, but we didn't study it. Will be in the chapter <info:class-inheritance>).
 
-That's because they are meant for short pieces of code that does not have their own "context", but rather works in the current one. And they really shine in that use case.
+That's because they are meant for short pieces of code that do not have their own "context", but rather works in the current one. And they really shine in that use case.
diff --git a/1-js/07-object-oriented-programming/01-property-descriptors/article.md b/1-js/07-object-oriented-programming/01-property-descriptors/article.md
index e927d5d7..932a4f6f 100644
--- a/1-js/07-object-oriented-programming/01-property-descriptors/article.md
+++ b/1-js/07-object-oriented-programming/01-property-descriptors/article.md
@@ -3,9 +3,7 @@
 
 As we know, objects can store properties.
 
-Till now, a property was a simple "key-value" pair to us. But an object property is actually more complex and tunable thing.
-
-[cut]
+Till now, a property was a simple "key-value" pair to us. But an object property is actually a more complex and tunable thing.
 
 ## Property flags
 
@@ -15,7 +13,7 @@ Object properties, besides a **`value`**, have three special attributes (so-call
 - **`enumerable`** -- if `true`, then listed in loops, otherwise not listed.
 - **`configurable`** -- if `true`, the property can be deleted and these attributes can be modified, otherwise not.
 
-We didn't see them yet, because generally they do not show up. When we create a property "the usual way", all of them are `true`. But we also can change them any time.
+We didn't see them yet, because generally they do not show up. When we create a property "the usual way", all of them are `true`. But we also can change them anytime.
 
 First, let's see how to get those flags.
 
@@ -156,7 +154,7 @@ let user = {
 };
 
 // By default, both our properties are listed:
-for(let key in user) alert(key); // name, toString
+for (let key in user) alert(key); // name, toString
 ```
 
 If we don't like it, then we can set `enumerable:false`. Then it won't appear in `for..in` loop, just like the built-in one:
@@ -178,7 +176,7 @@ Object.defineProperty(user, "toString", {
 *!*
 // Now our toString disappears:
 */!*
-for(let key in user) alert(key); // name
+for (let key in user) alert(key); // name
 ```
 
 Non-enumerable properties are also excluded from `Object.keys`:
@@ -282,7 +280,7 @@ let clone = Object.defineProperties({}, Object.getOwnPropertyDescriptors(obj));
 Normally when we clone an object, we use an assignment to copy properties, like this:
 
 ```js
-for(let key in user) {
+for (let key in user) {
   clone[key] = user[key]
 }
 ```
diff --git a/1-js/07-object-oriented-programming/02-property-accessors/article.md b/1-js/07-object-oriented-programming/02-property-accessors/article.md
index 616348e7..fa4d2216 100644
--- a/1-js/07-object-oriented-programming/02-property-accessors/article.md
+++ b/1-js/07-object-oriented-programming/02-property-accessors/article.md
@@ -7,8 +7,6 @@ The first kind is *data properties*. We already know how to work with them. Actu
 
 The second type of properties is something new. It's *accessor properties*. They are essentially functions that work on getting and setting a value, but look like regular properties to an external code.
 
-[cut]
-
 ## Getters and setters
 
 Accessor properties are represented by "getter" and "setter" methods. In an object literal they are denoted by `get` and `set`:
@@ -130,7 +128,7 @@ Object.defineProperty(user, 'fullName', {
 
 alert(user.fullName); // John Smith
 
-for(let key in user) alert(key);
+for(let key in user) alert(key); // name, surname
 ```
 
 Please note once again that a property can be either an accessor or a data property, not both.
diff --git a/1-js/07-object-oriented-programming/03-prototype-inheritance/2-search-algorithm/task.md b/1-js/07-object-oriented-programming/03-prototype-inheritance/2-search-algorithm/task.md
index 70b8b288..002b24b8 100644
--- a/1-js/07-object-oriented-programming/03-prototype-inheritance/2-search-algorithm/task.md
+++ b/1-js/07-object-oriented-programming/03-prototype-inheritance/2-search-algorithm/task.md
@@ -28,4 +28,4 @@ let pockets = {
 ```
 
 1. Use `__proto__` to assign prototypes in a way that any property lookup will follow the path: `pockets` -> `bed` -> `table` -> `head`. For instance, `pockets.pen` should be `3` (found in `table`), and `bed.glasses` should be `1` (found in `head`).
-2. Answer the question: is it faster to get `glasses` as `pocket.glasses` or `head.glasses`? Benchmark if needed.
+2. Answer the question: is it faster to get `glasses` as `pockets.glasses` or `head.glasses`? Benchmark if needed.
diff --git a/1-js/07-object-oriented-programming/03-prototype-inheritance/article.md b/1-js/07-object-oriented-programming/03-prototype-inheritance/article.md
index 40dff06b..fa61cbc8 100644
--- a/1-js/07-object-oriented-programming/03-prototype-inheritance/article.md
+++ b/1-js/07-object-oriented-programming/03-prototype-inheritance/article.md
@@ -6,8 +6,6 @@ For instance, we have a `user` object with its properties and methods, and want
 
 *Prototypal inheritance* is a language feature that helps in that.
 
-[cut]
-
 ## [[Prototype]]
 
 In JavaScript, objects have a special hidden property `[[Prototype]]` (as named in the specification), that is either `null` or references another object. That object is called "a prototype":
diff --git a/1-js/07-object-oriented-programming/04-function-prototype/article.md b/1-js/07-object-oriented-programming/04-function-prototype/article.md
index e002014f..d4b45385 100644
--- a/1-js/07-object-oriented-programming/04-function-prototype/article.md
+++ b/1-js/07-object-oriented-programming/04-function-prototype/article.md
@@ -1,8 +1,6 @@
 # F.prototype
 
-In modern JavaScript we can set a prototype using `__proto__`. But it wasn't like that all the time.
-
-[cut]
+In modern JavaScript we can set a prototype using `__proto__`, as described in the previous article. But it wasn't like that all the time.
 
 JavaScript has had prototypal inheritance from the beginning. It was one of the core features of the language.
 
@@ -10,11 +8,11 @@ But in the old times, there was another (and the only) way to set it: to use a `
 
 ## The "prototype" property
 
-As we know already, `new F()` creates a new object. But what we didn't use yet `F.prototype` property.
+As we know already, `new F()` creates a new object.
 
-That property is used by the JavaScript itself to set `[[Prototype]]` for new objects.
+When a new object is created with `new F()`, the object's `[[Prototype]]` is set to `F.prototype`.
 
-**When a new object is created with `new F()`, the object's `[[Prototype]]` is set to `F.prototype`.**
+In other words, if `F` has a `prototype` property with a value of the object type, then `new` operator uses it to set `[[Prototype]]` for the new object.
 
 Please note that `F.prototype` here means a regular property named `"prototype"` on `F`. It sounds something similar to the term "prototype", but here we really mean a regular property with this name.
 
diff --git a/1-js/07-object-oriented-programming/06-prototype-methods/article.md b/1-js/07-object-oriented-programming/06-prototype-methods/article.md
index 1e423eeb..e253e8af 100644
--- a/1-js/07-object-oriented-programming/06-prototype-methods/article.md
+++ b/1-js/07-object-oriented-programming/06-prototype-methods/article.md
@@ -6,10 +6,8 @@ In this chapter we cover additional methods to work with a prototype.
 There are also other ways to get/set a prototype, besides those that we already know:
 
 - [Object.create(proto[, descriptors])](mdn:js/Object/create) -- creates an empty object with given `proto` as `[[Prototype]]` and optional property descriptors.
-- [Object.getPrototypeOf(obj)](mdn:js/Object.getPrototypeOf) -- returns the `[[Prototype]]` of `obj`.
-- [Object.setPrototypeOf(obj, proto)](mdn:js/Object.setPrototypeOf) -- sets the `[[Prototype]]` of `obj` to `proto`.
-
-[cut]
+- [Object.getPrototypeOf(obj)](mdn:js/Object/getPrototypeOf) -- returns the `[[Prototype]]` of `obj`.
+- [Object.setPrototypeOf(obj, proto)](mdn:js/Object/setPrototypeOf) -- sets the `[[Prototype]]` of `obj` to `proto`.
 
 For instance:
 
diff --git a/1-js/07-object-oriented-programming/08-class-patterns/article.md b/1-js/07-object-oriented-programming/08-class-patterns/article.md
index d548e20d..92b521c1 100644
--- a/1-js/07-object-oriented-programming/08-class-patterns/article.md
+++ b/1-js/07-object-oriented-programming/08-class-patterns/article.md
@@ -5,14 +5,12 @@
 In object-oriented programming, a *class* is an extensible program-code-template for creating objects, providing initial values for state (member variables) and implementations of behavior (member functions or methods).
 ```
 
-There's a special syntax construct and a keyword `class` in JavaScript. But before studying it, we should consider that the term "class" comes the theory of object-oriented programming. The definition is cited above, and it's language-independant.
+There's a special syntax construct and a keyword `class` in JavaScript. But before studying it, we should consider that the term "class" comes from the theory of object-oriented programming. The definition is cited above, and it's language-independent.
 
 In JavaScript there are several well-known programming patterns to make classes even without using the `class` keyword. And here we'll talk about them first.
 
 The `class` construct will be described in the next chapter, but in JavaScript it's a "syntax sugar" and an extension of one of the patterns that we'll study here.
 
-[cut]
-
 
 ## Functional class pattern
 
@@ -43,7 +41,6 @@ So we can easily add internal functions and variables, like `calcAge()` here:
 
 ```js run
 function User(name, birthday) {
-
 *!*
   // only visible from other methods inside User
   function calcAge() {
@@ -52,17 +49,17 @@ function User(name, birthday) {
 */!*
 
   this.sayHi = function() {
-    alert(name + ', age:' + calcAge());
+    alert(`${name}, age:${calcAge()}`);
   };
 }
 
-let user = new User("John", new Date(2000,0,1));
-user.sayHi(); // John
+let user = new User("John", new Date(2000, 0, 1));
+user.sayHi(); // John, age:17
 ```
 
 In this code variables `name`, `birthday` and the function `calcAge()` are internal, *private* to the object. They are only visible from inside of it.
 
-From the other hand, `sayHi` is the external, *public* method. The external code that creates `user` can access it.
+On the other hand, `sayHi` is the external, *public* method. The external code that creates `user` can access it.
 
 This way we can hide internal implementation details and helper methods from the outer code. Only what's assigned to `this` becomes visible outside.
 
@@ -81,22 +78,22 @@ function User(name, birthday) {
 
   return {
     sayHi() {
-      alert(name + ', age:' + calcAge());
+      alert(`${name}, age:${calcAge()}`);
     }
   };
 }
 
 *!*
-let user = User("John", new Date(2000,0,1));
+let user = User("John", new Date(2000, 0, 1));
 */!*
-user.sayHi(); // John
+user.sayHi(); // John, age:17
 ```
 
 As we can see, the function `User` returns an object with public properties and methods. The only benefit of this method is that we can omit `new`: write `let user = User(...)` instead of `let user = new User(...)`. In other aspects it's almost the same as the functional pattern.
 
 ## Prototype-based classes
 
-Prototype-based classes is the most important and generally the best. Functional and factory class patterns are rarely used in practice.
+Prototype-based classes are the most important and generally the best. Functional and factory class patterns are rarely used in practice.
 
 Soon you'll see why.
 
@@ -117,11 +114,11 @@ User.prototype._calcAge = function() {
 };
 
 User.prototype.sayHi = function() {
-  alert(this._name + ', age:' + this._calcAge());
+  alert(`${this._name}, age:${this._calcAge()}`);
 };
 
-let user = new User("John", new Date(2000,0,1));
-user.sayHi(); // John
+let user = new User("John", new Date(2000, 0, 1));
+user.sayHi(); // John, age:17
 ```
 
 The code structure:
@@ -154,7 +151,7 @@ function Rabbit(name) {
 }
 
 Rabbit.prototype.jump = function() {
-  alert(this.name + ' jumps!');
+  alert(`${this.name} jumps!`);
 };
 
 let rabbit = new Rabbit("My rabbit");
@@ -170,7 +167,7 @@ function Animal(name) {
 }
 
 Animal.prototype.eat = function() {
-  alert(this.name + ' eats.');
+  alert(`${this.name} eats.`);
 };
 
 let animal = new Animal("My animal");
@@ -202,7 +199,7 @@ function Animal(name) {
 
 // All animals can eat, right?
 Animal.prototype.eat = function() {
-  alert(this.name + ' eats.');
+  alert(`${this.name} eats.`);
 };
 
 // Same Rabbit as before
@@ -211,7 +208,7 @@ function Rabbit(name) {
 }
 
 Rabbit.prototype.jump = function() {
-  alert(this.name + ' jumps!');
+  alert(`${this.name} jumps!`);
 };
 
 *!*
diff --git a/1-js/07-object-oriented-programming/08-class-patterns/rabbit-animal-independent-1.png b/1-js/07-object-oriented-programming/08-class-patterns/rabbit-animal-independent-1.png
index 8df10f5d..e63d7d78 100644
Binary files a/1-js/07-object-oriented-programming/08-class-patterns/rabbit-animal-independent-1.png and b/1-js/07-object-oriented-programming/08-class-patterns/rabbit-animal-independent-1.png differ
diff --git a/1-js/07-object-oriented-programming/08-class-patterns/rabbit-animal-independent-1@2x.png b/1-js/07-object-oriented-programming/08-class-patterns/rabbit-animal-independent-1@2x.png
index b61ddfbd..3d1be9cc 100644
Binary files a/1-js/07-object-oriented-programming/08-class-patterns/rabbit-animal-independent-1@2x.png and b/1-js/07-object-oriented-programming/08-class-patterns/rabbit-animal-independent-1@2x.png differ
diff --git a/1-js/07-object-oriented-programming/09-class/article.md b/1-js/07-object-oriented-programming/09-class/article.md
index 717376e8..71878ae3 100644
--- a/1-js/07-object-oriented-programming/09-class/article.md
+++ b/1-js/07-object-oriented-programming/09-class/article.md
@@ -3,11 +3,9 @@
 
 The "class" construct allows to define prototype-based classes with a clean, nice-looking syntax.
 
-[cut]
-
 ## The "class" syntax
 
-The `class` syntax is versatile, we'll start from a simple example first.
+The `class` syntax is versatile, we'll start with a simple example first.
 
 Here's a prototype-based class `User`:
 
@@ -43,27 +41,27 @@ let user = new User("John");
 user.sayHi();
 ```
 
-It's easy to see that the two examples are alike. Just please note that methods in a class do not have a comma between them. Notice developers sometimes forget it and put a comma between class methods, and things don't work. That's not a literal object, but a class syntax.
+It's easy to see that the two examples are alike. Just please note that methods in a class do not have a comma between them. Novice developers sometimes forget it and put a comma between class methods, and things don't work. That's not a literal object, but a class syntax.
 
 So, what exactly does `class` do? We may think that it defines a new language-level entity, but that would be wrong.
 
 The `class User {...}` here actually does two things:
 
 1. Declares a variable `User` that references the function named `"constructor"`.
-2. Puts into `User.prototype` methods listed in the definition. Here it includes `sayHi` and the `constructor`.
+2. Puts methods listed in the definition into `User.prototype`. Here, it includes `sayHi` and the `constructor`.
 
 Here's the code to dig into the class and see that:
 
 ```js run
 class User {
   constructor(name) { this.name = name; }
-  sayHi() { alert(this.name);  }
+  sayHi() { alert(this.name); }
 }
 
 *!*
 // proof: User is the "constructor" function
 */!*
-alert(User == User.prototype.constructor); // true
+alert(User === User.prototype.constructor); // true
 
 *!*
 // proof: there are two methods in its "prototype"
@@ -129,7 +127,7 @@ class User {
   set name(value) {
 */!*
     if (value.length < 4) {
-      alert("Name too short.");
+      alert("Name is too short.");
       return;
     }
     this._name = value;
@@ -146,7 +144,7 @@ user = new User(""); // Name too short.
 Internally, getters and setters are also created on the `User` prototype, like this:
 
 ```js
-Object.defineProperty(User.prototype, {
+Object.defineProperties(User.prototype, {
   name: {
     get() {
       return this._name
@@ -239,7 +237,7 @@ class User {
 *!*
   static staticMethod() {
 */!*
-    alert(this == User);
+    alert(this === User);
   }
 }
 
@@ -252,7 +250,7 @@ That actually does the same as assigning it as a function property:
 function User() { }
 
 User.staticMethod = function() {
-  alert(this == User);
+  alert(this === User);
 };
 ```
 
@@ -312,7 +310,7 @@ class Article {
 *!*
   static createTodays() {
     // remember, this = Article
-    return new this("Todays digest", new Date());
+    return new this("Today's digest", new Date());
   }
 */!*
 }
@@ -322,7 +320,7 @@ let article = Article.createTodays();
 alert( article.title ); // Todays digest
 ```
 
-Now every time we need to create a todays digest, we can call `Article.createTodays()`. Once again, that's not a method of an article, but a method of the whole class.
+Now every time we need to create a today's digest, we can call `Article.createTodays()`. Once again, that's not a method of an article, but a method of the whole class.
 
 Static methods are also used in database-related classes to search/save/remove entries from the database, like this:
 
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/3-class-extend-object/solution.md b/1-js/07-object-oriented-programming/10-class-inheritance/3-class-extend-object/solution.md
index 16a20f2a..c1483aa3 100644
--- a/1-js/07-object-oriented-programming/10-class-inheritance/3-class-extend-object/solution.md
+++ b/1-js/07-object-oriented-programming/10-class-inheritance/3-class-extend-object/solution.md
@@ -1,6 +1,6 @@
-The answer has two parts.
+First, let's see why the latter code doesn't work.
 
-The first, an easy one is that the inheriting class needs to call `super()` in the constructor. Otherwise `"this"` won't be "defined".
+The reason becomes obvious if we try to run it. An inheriting class constructor must call `super()`. Otherwise `"this"` won't be "defined".
 
 So here's the fix:
 
@@ -37,7 +37,7 @@ alert( Rabbit.prototype.__proto__ === Object.prototype ); // (1) true
 alert( Rabbit.__proto__ === Object ); // (2) true
 ```
 
-So we can access static methods of `Object` via `Rabbit`, like this:
+So `Rabbit` now provides access to static methods of `Object` via `Rabbit`, like this:
 
 ```js run
 class Rabbit extends Object {}
@@ -48,15 +48,16 @@ alert ( Rabbit.getOwnPropertyNames({a: 1, b: 2})); // a,b
 */!*
 ```
 
-And if we don't use `extends`, then `class Rabbit` does not get the second reference.
+But if we don't have `extends Object`, then `Rabbit.__proto__` is not set to `Object`.
 
-Please compare with it:
+Here's the demo:
 
 ```js run
 class Rabbit {}
 
 alert( Rabbit.prototype.__proto__ === Object.prototype ); // (1) true
 alert( Rabbit.__proto__ === Object ); // (2) false (!)
+alert( Rabbit.__proto__ === Function.prototype ); // as any function by default
 
 *!*
 // error, no such function in Rabbit
@@ -64,14 +65,7 @@ alert ( Rabbit.getOwnPropertyNames({a: 1, b: 2})); // Error
 */!*
 ```
 
-For the simple `class Rabbit`, the `Rabbit` function has the same prototype
-
-```js run
-class Rabbit {}
-
-// instead of (2) that's correct for Rabbit (just like any function):
-alert( Rabbit.__proto__ === Function.prototype );
-```
+So `Rabbit` doesn't provide access to static methods of `Object` in that case.
 
 By the way, `Function.prototype` has "generic" function methods, like `call`, `bind` etc. They are ultimately available in both cases, because for the built-in `Object` constructor, `Object.__proto__ === Function.prototype`.
 
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/3-class-extend-object/task.md b/1-js/07-object-oriented-programming/10-class-inheritance/3-class-extend-object/task.md
index d59de085..ca6628ed 100644
--- a/1-js/07-object-oriented-programming/10-class-inheritance/3-class-extend-object/task.md
+++ b/1-js/07-object-oriented-programming/10-class-inheritance/3-class-extend-object/task.md
@@ -4,9 +4,9 @@ importance: 5
 
 # Class extends Object?
 
-As we know, all objects normally inherit from `Object.prototype` and get access to "generic" object methods.
+As we know, all objects normally inherit from `Object.prototype` and get access to "generic" object methods like `hasOwnProperty` etc.
 
-Like demonstrated here:
+For instance:
 
 ```js run
 class Rabbit {
@@ -24,9 +24,11 @@ alert( rabbit.hasOwnProperty('name') ); // true
 */!*
 ```
 
-So, is it correct to say that `"class Rabbit extends Object"` does exactly the same as `"class Rabbit"`, or not?
+But if we spell it out explicitly like `"class Rabbit extends Object"`, then the result would be different from a simple `"class Rabbit"`?
 
-Will it work?
+What's the difference?
+
+Here's an example of such code (it doesn't work -- why? fix it?):
 
 ```js
 class Rabbit extends Object {
@@ -39,5 +41,3 @@ let rabbit = new Rabbit("Rab");
 
 alert( rabbit.hasOwnProperty('name') ); // true
 ```
-
-If it won't please fix the code. 
diff --git a/1-js/07-object-oriented-programming/10-class-inheritance/article.md b/1-js/07-object-oriented-programming/10-class-inheritance/article.md
index 803971e3..2c44e5ea 100644
--- a/1-js/07-object-oriented-programming/10-class-inheritance/article.md
+++ b/1-js/07-object-oriented-programming/10-class-inheritance/article.md
@@ -5,8 +5,6 @@ Classes can extend one another. There's a nice syntax, technically based on the
 
 To inherit from another class, we should specify `"extends"` and the parent class before the brackets `{..}`.
 
-[cut]
-
 Here `Rabbit` inherits from `Animal`:
 
 ```js run
@@ -161,7 +159,7 @@ setTimeout(function() { super.stop() }, 1000);
 
 ## Overriding constructor
 
-With constructors, things are is a little bit tricky.
+With constructors it gets a little bit tricky.
 
 Till now, `Rabbit` did not have its own `constructor`.
 
@@ -279,7 +277,7 @@ Here, `rabbit.eat()` should call `animal.eat()` method of the parent object:
 let animal = {
   name: "Animal",
   eat() {
-    alert(this.name + " eats.");
+    alert(`${this.name} eats.`);
   }
 };
 
@@ -307,7 +305,7 @@ Now let's add one more object to the chain. We'll see how things break:
 let animal = {
   name: "Animal",
   eat() {
-    alert(this.name + " eats.");
+    alert(`${this.name} eats.`);
   }
 };
 
@@ -332,7 +330,7 @@ longEar.eat(); // Error: Maximum call stack size exceeded
 */!*
 ```
 
-The code doesn't work any more! We can see the error trying to call `longEar.eat()`.
+The code doesn't work anymore! We can see the error trying to call `longEar.eat()`.
 
 It may be not that obvious, but if we trace `longEar.eat()` call, then we can see why. In both lines `(*)` and `(**)` the value of `this` is the current object (`longEar`). That's essential: all object methods get the current object as `this`, not a prototype or something.
 
@@ -382,7 +380,7 @@ Let's see how it works for `super` -- again, using plain objects:
 let animal = {
   name: "Animal",
   eat() {         // [[HomeObject]] == animal
-    alert(this.name + " eats.");
+    alert(`${this.name} eats.`);
   }
 };
 
@@ -490,10 +488,10 @@ class Animal {}
 class Rabbit extends Animal {}
 
 // for static propertites and methods
-alert(Rabbit.__proto__ == Animal); // true
+alert(Rabbit.__proto__ === Animal); // true
 
 // and the next step is Function.prototype
-alert(Animal.__proto__ == Function.prototype); // true
+alert(Animal.__proto__ === Function.prototype); // true
 
 // that's in addition to the "normal" prototype chain for object methods
 alert(Rabbit.prototype.__proto__ === Animal.prototype);
@@ -523,7 +521,7 @@ For instance, here `PowerArray` inherits from the native `Array`:
 // add one more method to it (can do more)
 class PowerArray extends Array {
   isEmpty() {
-    return this.length == 0;
+    return this.length === 0;
   }
 }
 
@@ -551,7 +549,7 @@ For example, here due to `Symbol.species` built-in methods like `map`, `filter`
 ```js run
 class PowerArray extends Array {
   isEmpty() {
-    return this.length == 0;
+    return this.length === 0;
   }
 
 *!*
diff --git a/1-js/07-object-oriented-programming/11-instanceof/article.md b/1-js/07-object-oriented-programming/11-instanceof/article.md
index 1d725eea..702c9e6b 100644
--- a/1-js/07-object-oriented-programming/11-instanceof/article.md
+++ b/1-js/07-object-oriented-programming/11-instanceof/article.md
@@ -4,8 +4,6 @@ The `instanceof` operator allows to check whether an object belongs to a certain
 
 Such a check may be necessary in many cases, here we'll use it for building a *polymorphic* function, the one that treats arguments differently depending on their type.
 
-[cut]
-
 ## The instanceof operator [#ref-instanceof]
 
 The syntax is:
@@ -70,13 +68,13 @@ The algorithm of `obj instanceof Class` works roughly as follows:
 
     In other words, compare:
     ```js
-    obj.__proto__ == Class.prototype
-    obj.__proto__.__proto__ == Class.prototype
-    obj.__proto__.__proto__.__proto__ == Class.prototype
+    obj.__proto__ === Class.prototype
+    obj.__proto__.__proto__ === Class.prototype
+    obj.__proto__.__proto__.__proto__ === Class.prototype
     ...
     ```
 
-    In the example above `Rabbit.prototype == rabbit.__proto__`, so that gives the answer immediately.
+    In the example above `Rabbit.prototype === rabbit.__proto__`, so that gives the answer immediately.
 
     In the case of an inheritance, `rabbit` is an instance of the parent class as well:
 
@@ -88,8 +86,8 @@ The algorithm of `obj instanceof Class` works roughly as follows:
     *!*
     alert(rabbit instanceof Animal); // true
     */!*
-    // rabbit.__proto__ == Rabbit.prototype
-    // rabbit.__proto__.__proto__ == Animal.prototype (match!)
+    // rabbit.__proto__ === Rabbit.prototype
+    // rabbit.__proto__.__proto__ === Animal.prototype (match!)
     ```
 
 Here's the illustration of what `rabbit instanceof Animal` compares with `Animal.prototype`:
@@ -117,7 +115,7 @@ alert( rabbit instanceof Rabbit ); // false
 */!*
 ```
 
-That's one of reasons to avoid changing `prototype`. Just to keep safe.
+That's one of the reasons to avoid changing `prototype`. Just to keep safe.
 
 ## Bonus: Object toString for the type
 
@@ -130,9 +128,9 @@ alert(obj); // [object Object]
 alert(obj.toString()); // the same
 ```
 
-That's their implementation of `toString`. But there's a hidden feature thank makes `toString` actually much more powerful than that. We can use it as an extended `typeof` and an alternative for `instanceof`.
+That's their implementation of `toString`. But there's a hidden feature that makes `toString` actually much more powerful than that. We can use it as an extended `typeof` and an alternative for `instanceof`.
 
-Sounds strange? Indeed. Let's demistify.
+Sounds strange? Indeed. Let's demystify.
 
 By [specification](https://tc39.github.io/ecma262/#sec-object.prototype.tostring), the built-in `toString` can be extracted from the object and executed in the context of any other value. And its result depends on that value.
 
@@ -175,7 +173,7 @@ For instance:
 
 ```js run
 let user = {
-  [Symbol.toStringTag]: 'User'
+  [Symbol.toStringTag]: "User"
 };
 
 alert( {}.toString.call(user) ); // [object User]
diff --git a/1-js/07-object-oriented-programming/13-mixins/article.md b/1-js/07-object-oriented-programming/13-mixins/article.md
index 002168a8..bb51395e 100644
--- a/1-js/07-object-oriented-programming/13-mixins/article.md
+++ b/1-js/07-object-oriented-programming/13-mixins/article.md
@@ -2,7 +2,7 @@
 
 In JavaScript we can only inherit from a single object. There can be only one `[[Prototype]]` for an object. And a class may extend only one other class.
 
-But sometimes that feels limiting. For instance, I have a class `StreetSweeper` and a class `Bycicle`, and want to make a `StreetSweepingBycicle`.
+But sometimes that feels limiting. For instance, I have a class `StreetSweeper` and a class `Bicycle`, and want to make a `StreetSweepingBicycle`.
 
 Or, talking about programming, we have a class `Renderer` that implements templating and a class `EventEmitter` that implements event handling, and want to merge these functionalities together with a class `Page`, to make a page that can use templates and emit events.
 
@@ -24,10 +24,10 @@ For instance here the mixin `sayHiMixin` is used to add some "speech" for `User`
 */!*
 let sayHiMixin = {
   sayHi() {
-    alert("Hello " + this.name);
+    alert(`Hello ${this.name}`);
   },
   sayBye() {
-    alert("Bye " + this.name);
+    alert(`Bye ${this.name}`);
   }
 };
 
@@ -44,7 +44,7 @@ class User {
 Object.assign(User.prototype, sayHiMixin);
 
 // now User can say hi
-new User("Dude").sayHi(); // Hi Dude!
+new User("Dude").sayHi(); // Hello Dude!
 ```
 
 There's no inheritance, but a simple method copying. So `User` may extend some other class and also include the mixin to "mix-in" the additional methods, like this:
@@ -75,10 +75,10 @@ let sayHiMixin = {
     *!*
     // call parent method
     */!*
-    super.say("Hello " + this.name);
+    super.say(`Hello ${this.name}`);
   },
   sayBye() {
-    super.say("Bye " + this.name);
+    super.say(`Bye ${this.name}`);
   }
 };
 
@@ -138,8 +138,8 @@ let eventMixin = {
   off(eventName, handler) {
     let handlers = this._eventHandlers && this._eventHandlers[eventName];
     if (!handlers) return;
-    for(let i = 0; i < handlers.length; i++) {
-      if (handlers[i] == handler) {
+    for (let i = 0; i < handlers.length; i++) {
+      if (handlers[i] === handler) {
         handlers.splice(i--, 1);
       }
     }
@@ -183,7 +183,7 @@ let menu = new Menu();
 
 // call the handler on selection:
 *!*
-menu.on("select", value => alert("Value selected: " + value));
+menu.on("select", value => alert(`Value selected: ${value}`));
 */!*
 
 // triggers the event => shows Value selected: 123
diff --git a/1-js/08-error-handling/1-try-catch/article.md b/1-js/08-error-handling/1-try-catch/article.md
index bc3b509b..689fc51e 100644
--- a/1-js/08-error-handling/1-try-catch/article.md
+++ b/1-js/08-error-handling/1-try-catch/article.md
@@ -6,8 +6,6 @@ Usually, a script "dies" (immediately stops) in case of an error, printing it to
 
 But there's a syntax construct `try..catch` that allows to "catch" errors and, instead of dying, do something more reasonable.
 
-[cut]
-
 ## The "try..catch" syntax
 
 The `try..catch` construct has two main blocks: `try`, and then `catch`:
@@ -81,7 +79,7 @@ Let's see more examples.
 ````warn header="`try..catch` only works for runtime errors"
 For `try..catch` to work, the code must be runnable. In other words, it should be valid JavaScript.
 
-It won't work if the code is syntactically wrong, for instance it has unmatched figure brackets:
+It won't work if the code is syntactically wrong, for instance it has unmatched curly braces:
 
 ```js run
 try {
@@ -98,7 +96,7 @@ So, `try..catch` can only handle errors that occur in the valid code. Such error
 
 
 ````warn header="`try..catch` works synchronously"
-If an exception happens in a "scheduled" code, like in `setTimeout`, then `try..catch` won't catch it:
+If an exception happens in "scheduled" code, like in `setTimeout`, then `try..catch` won't catch it:
 
 ```js run
 try {
@@ -110,7 +108,7 @@ try {
 }
 ```
 
-That's because `try..catch` actually wraps the `setTimeout` call that schedules the function. But the function itself is executed later, when the engine has already have left the `try..catch` construct.
+That's because `try..catch` actually wraps the `setTimeout` call that schedules the function. But the function itself is executed later, when the engine has already left the `try..catch` construct.
 
 To catch an exception inside a scheduled function, `try..catch` must be inside that function:
 ```js run
@@ -172,9 +170,9 @@ try {
 
 Let's explore a real-life use case of `try..catch`.
 
-As we already know, JavaScript supports method [JSON.parse(str)](mdn:js/JSON/parse) to read JSON-encoded values.
+As we already know, JavaScript supports the [JSON.parse(str)](mdn:js/JSON/parse) method to read JSON-encoded values.
 
-Usually it's used to decode the data received over the network, from the server or another source.
+Usually it's used to decode data received over the network, from the server or another source.
 
 We receive it and call `JSON.parse`, like this:
 
@@ -190,13 +188,13 @@ alert( user.name ); // John
 alert( user.age );  // 30
 ```
 
-More detailed information about JSON you can find in the chapter <info:json>.
+You can find more detailed information about JSON in the <info:json> chapter.
 
 **If `json` is malformed, `JSON.parse` generates an error, so the script "dies".**
 
 Should we be satisfied with that? Of course, not!
 
-This way if something's wrong with the data, the visitor will never know that (unless he opens developer console). And people really really don't like when something "just dies" without any error message.
+This way, if something's wrong with the data, the visitor will never know that (unless he opens developer console). And people really don't like when something "just dies" without any error message.
 
 Let's use `try..catch` to handle the error:
 
@@ -220,11 +218,11 @@ try {
 }
 ```
 
-Here we use `catch` block only to show the message, but we can do much more: a new network request, suggest an alternative to the visitor, send the information about the error to a logging facility... All much better than just dying.
+Here we use the `catch` block only to show the message, but we can do much more: send a new network request, suggest an alternative to the visitor, send information about the error to a logging facility, ... . All much better than just dying.
 
 ## Throwing our own errors
 
-What if `json` is syntactically correct... But doesn't have a required `"name"` property?
+What if `json` is syntactically correct, but doesn't have a required `name` property?
 
 Like this:
 
@@ -243,7 +241,7 @@ try {
 }
 ```
 
-Here `JSON.parse` runs normally, but the absence of `"name"` is actually an error for us.
+Here `JSON.parse` runs normally, but the absence of `name` is actually an error for us.
 
 To unify error handling, we'll use the `throw` operator.
 
@@ -297,7 +295,7 @@ try {
 
 As we can see, that's a `SyntaxError`.
 
-...And in our case, the absense of `name` could be treated as a syntax error also, assuming that users must have a `"name"`.
+And in our case, the absence of `name` could be treated as a syntax error also, assuming that users must have a `name`.
 
 So let's throw it:
 
@@ -321,7 +319,7 @@ try {
 }
 ```
 
-In the line `(*)` the `throw` operator generates `SyntaxError` with the given `message`, the same way as JavaScript would generate itself. The execution of `try` immediately stops and the control flow jumps into `catch`.
+In the line `(*)`, the `throw` operator generates a `SyntaxError` with the given `message`, the same way as JavaScript would generate it itself. The execution of `try` immediately stops and the control flow jumps into `catch`.
 
 Now `catch` became a single place for all error handling: both for `JSON.parse` and other cases.
 
@@ -340,7 +338,7 @@ try {
   // ...
 } catch(err) {
   alert("JSON Error: " + err); // JSON Error: ReferenceError: user is not defined
-  // (not JSON Error actually)
+  // (no JSON Error actually)
 }
 ```
 
@@ -480,7 +478,7 @@ The code has two ways of execution:
 
 The `finally` clause is often used when we start doing something before `try..catch` and want to finalize it in any case of outcome.
 
-For instance, we want to measure time that a Fibonacci numbers function `fib(n)` takes. Naturally, we can start measuring before it runs and finish afterwards. But what if there's an error during the function call? In particular, the implementation of `fib(n)` in the code below returns an error for negative or non-integer numbers.
+For instance, we want to measure the time that a Fibonacci numbers function `fib(n)` takes. Naturally, we can start measuring before it runs and finish afterwards. But what if there's an error during the function call? In particular, the implementation of `fib(n)` in the code below returns an error for negative or non-integer numbers.
 
 The `finally` clause is a great place to finish the measurements no matter what.
 
@@ -527,7 +525,7 @@ Otherwise, if `let` were made inside the `{...}` block, it would only be visible
 ```
 
 ````smart header="`finally` and `return`"
-Finally clause works for *any* exit from `try..catch`. That includes an explicit `return`.
+The `finally` clause works for *any* exit from `try..catch`. That includes an explicit `return`.
 
 In the example below, there's a `return` in `try`. In this case, `finally` is executed just before the control returns to the outer code.
 
diff --git a/1-js/08-error-handling/2-custom-errors/article.md b/1-js/08-error-handling/2-custom-errors/article.md
index d7a780f6..d7d61166 100644
--- a/1-js/08-error-handling/2-custom-errors/article.md
+++ b/1-js/08-error-handling/2-custom-errors/article.md
@@ -224,7 +224,7 @@ The code which calls `readUser` should handle these errors. Right now it uses mu
 
 Often the answer is "No": the outer code wants to be "one level above all that". It wants to have some kind of "data reading error". Why exactly it happened -- is often irrelevant (the error message describes it). Or, even better if there is a way to get error details, but only if we need to.
 
-So let's make a new class `ReadError` to represent such errors. If an error occurs inside `readUser`, we'll catch it there and generate `ReadError`. We'll also keep the reference to the original error in the `cause` property. Then the outer code will only have to check for `ReadError`.
+So let's make a new class `ReadError` to represent such errors. If an error occurs inside `readUser`, we'll catch it there and generate `ReadError`. We'll also keep the reference to the original error in its `cause` property. Then the outer code will only have to check for `ReadError`.
 
 Here's the code that defines `ReadError` and demonstrates its use in `readUser` and `try..catch`:
 
diff --git a/2-ui/1-document/01-browser-environment/article.md b/2-ui/1-document/01-browser-environment/article.md
index ffbc5bc1..2266a2de 100644
--- a/2-ui/1-document/01-browser-environment/article.md
+++ b/2-ui/1-document/01-browser-environment/article.md
@@ -1,14 +1,12 @@
 # Browser environment, specs
 
-The JavaScript language was initially created for web browsers. Since then, it evolved and became a language with many uses and platforms.
+The JavaScript language was initially created for web browsers. Since then, it has evolved and become a language with many uses and platforms.
 
-A platform may be either a browser or a web-server or a washing machine or another *host*. Each of them provides platform-specific functionality. The JavaScript specification calls that a *host environment*.
+A platform may be a browser, or a web-server, or a washing machine, or another *host*. Each of them provides platform-specific functionality. The JavaScript specification calls that a *host environment*.
 
-A host environment provides platform-specific objects and functions additionally to the language core. Web browsers give means to control web pages. Node.JS provides server-side features, and so on.
+A host environment provides platform-specific objects and functions additional to the language core. Web browsers give a means to control web pages. Node.JS provides server-side features, and so on.
 
-[cut]
-
-Here's a bird-eye view of what we have when JavaScript runs in a web-browser:
+Here's a bird's-eye view of what we have when JavaScript runs in a web-browser:
 
 ![](windowObjects.png)
 
@@ -43,35 +41,35 @@ The `document` object gives access to the page content. We can change or create
 For instance:
 ```js run
 // change the background color to red
-document.body.style.background = 'red';
+document.body.style.background = "red";
 
 // change it back after 1 second
-setTimeout(() => document.body.style.background = '', 1000);
+setTimeout(() => document.body.style.background = "", 1000);
 ```
 
-Here we used `document.body.style`, but there's much, much more. Properties and methods are described in the specification. By chance, there are two working groups who develop it:
+Here we used `document.body.style`, but there's much, much more. Properties and methods are described in the specification. There happen to be two working groups who develop it:
 
 1. [W3C](https://en.wikipedia.org/wiki/World_Wide_Web_Consortium) -- the documentation is at <https://www.w3.org/TR/dom>.
 2. [WhatWG](https://en.wikipedia.org/wiki/WHATWG), publishing at <https://dom.spec.whatwg.org>.
 
-As it happens, the two groups don't always agree, so we have like 2 sets of standards. But they are in the tight contact and eventually things merge. So the documentation that you can find on the given resources is very similar, there's like 99% match. There are very minor differences, you probably won't notice them.
+As it happens, the two groups don't always agree, so it's like we have two sets of standards. But they are very similar and eventually things merge. The documentation that you can find on the given resources is very similar, with about a 99% match. There are very minor differences that you probably won't notice.
 
 Personally, I find <https://dom.spec.whatwg.org> more pleasant to use.
 
-In the ancient past, there was no standard at all -- each browser implemented whatever it wanted. So different browsers had different sets methods and properties for the same thing, and developers had to write different code for each of them. Dark, messy times.
+In the ancient past, there was no standard at all -- each browser implemented however it wanted. Different browsers had different sets, methods, and properties for the same thing, and developers had to write different code for each of them. Dark, messy times.
 
-Even now we can sometimes meet old code that uses browser-specific properties and works around incompatibilities. But in this tutorial we'll use modern stuff: there's no need to learn old things until you really need those (chances are high you won't).
+Even now we can sometimes meet old code that uses browser-specific properties and works around incompatibilities. But, in this tutorial we'll use modern stuff: there's no need to learn old things until you really need to (chances are high that you won't).
 
-Then the DOM standard appeared, in an attempt to bring everyone to an agreement. The first version was "DOM Level 1", then it was extended by DOM Level 2, then DOM Level 3, and now it's DOM Level 4. People from WhatWG group got tired of version and are calling that just "DOM", without a number. So will do we.
+Then the DOM standard appeared, in an attempt to bring everyone to an agreement. The first version was "DOM Level 1", then it was extended by DOM Level 2, then DOM Level 3, and now it's reached DOM Level 4. People from WhatWG group got tired of version numbers and are calling it just "DOM", without a number. So we'll do the same.
 
 ```smart header="DOM is not only for browsers"
 The DOM specification explains the structure of a document and provides objects to manipulate it. There are non-browser instruments that use it too.
 
-For instance, server-side tools that download HTML pages and process them. They may support only a part of the DOM specification though.
+For instance, server-side tools that download HTML pages and process them use the DOM. They may support only a part of the specification though.
 ```
 
 ```smart header="CSSOM for styling"
-CSS rules and stylesheets are structured not like HTML. So there's a separate specification [CSSOM](https://www.w3.org/TR/cssom-1/) that explains how they are represented as objects, how to read and write them.
+CSS rules and stylesheets are not structured like HTML. There's a separate specification [CSSOM](https://www.w3.org/TR/cssom-1/) that explains how they are represented as objects, and how to read and write them.
 
 CSSOM is used together with DOM when we modify style rules for the document. In practice though, CSSOM is rarely required, because usually CSS rules are static. We rarely need to add/remove CSS rules from JavaScript, so we won't cover it right now.
 ```
@@ -82,15 +80,15 @@ Browser Object Model (BOM) are additional objects provided by the browser (host
 
 For instance:
 
-- [navigator](mdn:api/Window/navigator) object provides background information about the browser and the operation system. There are many properties, but two most widely known are: `navigator.userAgent` -- about the current browser, and `navigator.platform` -- about the platform (can help to differ between Windows/Linux/Mac etc).
-- [location](mdn:api/Window/location) object allows to read the current URL and redirect the browser to a new one.
+- The [navigator](mdn:api/Window/navigator) object provides background information about the browser and the operating system. There are many properties, but the two most widely known are: `navigator.userAgent` -- about the current browser, and `navigator.platform` -- about the platform (can help to differ between Windows/Linux/Mac etc).
+- The [location](mdn:api/Window/location) object allows us to read the current URL and can redirect the browser to a new one.
 
 Here's how we can use the `location` object:
 
 ```js run
 alert(location.href); // shows current URL
 if (confirm("Go to wikipedia?")) {
-  location.href = 'https://wikipedia.org'; // redirect the browser to another URL
+  location.href = "https://wikipedia.org"; // redirect the browser to another URL
 }
 ```
 
@@ -114,10 +112,10 @@ CSSOM specification
 : Describes stylesheets and style rules, manipulations with them and their binding to documents, see <https://www.w3.org/TR/cssom-1/>.
 
 HTML specification
-: Describes HTML language (tags etc) and also BOM (browser object model) -- various browser functions: `setTimeout`, `alert`, `location` and so on, see <https://html.spec.whatwg.org>. It takes DOM specification and extends it with many additional properties and methods.
+: Describes the HTML language (e.g. tags) and also the BOM (browser object model) -- various browser functions: `setTimeout`, `alert`, `location` and so on, see <https://html.spec.whatwg.org>. It takes the DOM specification and extends it with many additional properties and methods.
 
-Now we'll get down to learning DOM, because the document plays the central role in the UI, and working with it is the most complex part.
+Now we'll get down to learning DOM, because the document plays the central role in the UI.
 
-Please note the links above, because there's so many stuff to learn, it's impossible to cover and remember everything.
+Please note the links above, as there's so much stuff to learn it's impossible to cover and remember everything.
 
-When you'd like to read about a property or a method -- the Mozilla manual at <https://developer.mozilla.org/en-US/search> is a nice one, but reading the corresponding spec may be better: more complex and longer to read, but will make your fundamental knowledge sound and complete.
+When you'd like to read about a property or a method, the Mozilla manual at <https://developer.mozilla.org/en-US/search> is a nice resource, but reading the corresponding spec may be better: it's more complex and longer to read, but will make your fundamental knowledge sound and complete.
diff --git a/2-ui/1-document/02-dom-nodes/article.md b/2-ui/1-document/02-dom-nodes/article.md
index 635986d1..04fd7a98 100644
--- a/2-ui/1-document/02-dom-nodes/article.md
+++ b/2-ui/1-document/02-dom-nodes/article.md
@@ -6,7 +6,7 @@ libs:
 
 # DOM tree
 
-The backbone of an HTML document is tags.
+The backbone of an HTML document are tags.
 
 According to Document Object Model (DOM), every HTML-tag is an object. Nested tags are called "children" of the enclosing one.
 
@@ -41,10 +41,10 @@ drawHtmlTree(node1, 'div.domtree', 690, 320);
 </script>
 
 ```online
-On the picture above element nodes you can click on element nodes. Their children will open/collapse.
+On the picture above, you can click on element nodes and their children will open/collapse.
 ```
 
-Tags are called *element nodes* (or just elements). Nested tags become children of the enclosing ones. As a result we have a tree of elements: `<html>` is at the root, then `<head>` and `<body>` are its children etc.
+Tags are called *element nodes* (or just elements). Nested tags become children of the enclosing ones. As a result we have a tree of elements: `<html>` is at the root, then `<head>` and `<body>` are its children, etc.
 
 The text inside elements forms *text nodes*, labelled as `#text`. A text node contains only a string. It may not have children and is always a leaf of the tree.
 
@@ -55,13 +55,13 @@ Please note the special characters in text nodes:
 - a newline: `↵` (in JavaScript known as `\n`)
 - a space: `␣`
 
-Spaces and newlines -- are totally valid characters, they form text nodes and become a part of the DOM. So, for instance, in the example above the `<head>` tag contains come spaces before `<title>`, and that text becomes a `#text` node (it contains a newline and some spaces only).
+Spaces and newlines -- are totally valid characters, they form text nodes and become a part of the DOM. So, for instance, in the example above the `<head>` tag contains some spaces before `<title>`, and that text becomes a `#text` node (it contains a newline and some spaces only).
 
 There are only two top-level exclusions:
 1. Spaces and newlines before `<head>` are ignored for historical reasons,
-2. If we put something after `</body>`, then that is automatically moved inside the `body`, at the end, as HTML spec requires that all content must be inside `<body>`. So there may be no spaces after `</body>`.
+2. If we put something after `</body>`, then that is automatically moved inside the `body`, at the end, as the HTML spec requires that all content must be inside `<body>`. So there may be no spaces after `</body>`.
 
-In other cases everything's honest -- if there are spaces (just like any character) in the document, then they text nodes in DOM, and if we remove them, then there won't be any.
+In other cases everything's straightforward -- if there are spaces (just like any character) in the document, then they become text nodes in DOM, and if we remove them, then there won't be any.
 
 Here are no space-only text nodes:
 
@@ -79,9 +79,9 @@ drawHtmlTree(node2, 'div.domtree', 690, 210);
 </script>
 
 ```smart header="Edge spaces and in-between empty text are usually hidden in tools"
-Browser tools (to be covered soon) that work with DOM usually do not show spaces at start/end of the text and empty text nodes (line-breaks) between tags. .
+Browser tools (to be covered soon) that work with DOM usually do not show spaces at the start/end of the text and empty text nodes (line-breaks) between tags.
 
-That's because they are mainly used to decorate HTML, and do not affect (in most cases) how it is shown.
+That's because they are mainly used to decorate HTML, and do not affect how it is shown (in most cases).
 
 On further DOM pictures we'll sometimes omit them where they are irrelevant, to keep things short.
 ```
@@ -91,7 +91,7 @@ On further DOM pictures we'll sometimes omit them where they are irrelevant, to
 
 If the browser encounters malformed HTML, it automatically corrects it when making DOM.
 
-For instance, the top tag is always `<html>`. Even if it doesn't exist in the document -- it will be in DOM, the browser will create it. The same about `<body>`.
+For instance, the top tag is always `<html>`. Even if it doesn't exist in the document -- it will exist in the DOM, the browser will create it. The same goes for `<body>`.
 
 As an example, if the HTML file is a single word `"Hello"`, the browser will wrap it into `<html>` and `<body>`, add the required `<head>`, and the DOM will be:
 
@@ -104,7 +104,7 @@ let node3 = {"name":"HTML","nodeType":1,"children":[{"name":"HEAD","nodeType":1,
 drawHtmlTree(node3, 'div.domtree', 690, 150);
 </script>
 
-While generating DOM, browser automatically processes errors in the document, closes tags and so on.
+While generating the DOM, browsers automatically process errors in the document, close tags and so on.
 
 Such an "invalid" document:
 
@@ -115,7 +115,7 @@ Such an "invalid" document:
 <li>Dad
 ```
 
-...Will become a normal DOM, as the browser read tags and restores the missing parts:
+...Will become a normal DOM, as the browser reads tags and restores the missing parts:
 
 <div class="domtree"></div>
 
@@ -143,7 +143,7 @@ let node5 = {"name":"TABLE","nodeType":1,"children":[{"name":"TBODY","nodeType":
 drawHtmlTree(node5,  'div.domtree', 600, 200);
 </script>
 
-You see? The `<tbody>` has appeared out of nowhere. Should keep in mind while working with tables to evade surprises.
+You see? The `<tbody>` appeared out of nowhere. You should keep this in mind while working with tables to avoid surprises.
 ````
 
 ## Other node types
@@ -178,7 +178,7 @@ Here we see a new tree node type -- *comment node*, labeled as `#comment`.
 
 We may think -- why a comment is added to the DOM? It doesn't affect the visual representation in any way. But there's a rule -- if something's in HTML, then it also must be in the DOM tree.
 
-**Everything in HTML, even comments, becomes a part of DOM.**
+**Everything in HTML, even comments, becomes a part of the DOM.**
 
 Even the `<!DOCTYPE...>` directive at the very beginning of HTML is also a DOM node. It's in the DOM tree right before `<html>`. We are not going to touch that node, we even don't draw it on diagrams for that reason, but it's there.
 
@@ -189,39 +189,39 @@ There are [12 node types](https://dom.spec.whatwg.org/#node). In practice we usu
 1. `document` -- the "entry point" into DOM.
 2. element nodes -- HTML-tags, the tree building blocks.
 3. text nodes -- contain text.
-4. comments -- sometimes we can put the information there, it won't be shown, but JS can read it from DOM.
+4. comments -- sometimes we can put the information there, it won't be shown, but JS can read it from the DOM.
 
-## See it yourself
+## See it for yourself
 
-To see the DOM structure in real-time, try [Live DOM Viewer](http://software.hixie.ch/utilities/js/live-dom-viewer/). Just type in the document, and it will show up DOM at instant.
+To see the DOM structure in real-time, try [Live DOM Viewer](http://software.hixie.ch/utilities/js/live-dom-viewer/). Just type in the document, and it will show up DOM at an instant.
 
 ## In the browser inspector
 
-Another way to explore DOM is to use browser developer tools. Actually, that's what we use when developing.
+Another way to explore the DOM is to use the browser developer tools. Actually, that's what we use when developing.
 
-To do so, open the web-page [elks.html](elks.html), turn on browser developer tools and switch to Elements tab.
+To do so, open the web-page [elks.html](elks.html), turn on the browser developer tools and switch to the Elements tab.
 
-Should look like this:
+It should look like this:
 
 ![](elks.png)
 
 You can see the DOM, click on elements, see their details and so on.
 
-Please note that the DOM structure in developer tools is simplified. Text nodes are shown just as text. And there are no "blank" (space only) text nodes at all. That's fine, because most of time we are interested in element nodes.
+Please note that the DOM structure in developer tools is simplified. Text nodes are shown just as text. And there are no "blank" (space only) text nodes at all. That's fine, because most of the time we are interested in element nodes.
 
-Clicking the <span class="devtools" style="background-position:-328px -124px"></span> button in the left-upper corner allows to choose a node from the webpage using a mouse (or other pointer device) and "inspect" it (scroll to it in the elements tab). Works great when we have a huge HTML page and would like to see the DOM of a particular place in it.
+Clicking the <span class="devtools" style="background-position:-328px -124px"></span> button in the left-upper corner allows to choose a node from the webpage using a mouse (or other pointer devices) and "inspect" it (scroll to it in the Elements tab). This works great when we have a huge HTML page (and corresponding huge DOM) and would like to see the place of a particual element in it.
 
 Another way to do it would be just right-clicking on a webpage and selecting "Inspect" in the context menu.
 
 ![](inspect.png)
 
-At the right part of the tools there are following subtabs:
-- Styles -- we can see CSS applied to the current element rule by rule, including built-in rules (gray). Almost everything can be edited at-place including the dimensions/margins/paddings of the box below.
-- Computed -- to see CSS applied to the element by property: for each property we can see a rule that gives it (including CSS inheritance and such).
-- Event Listeners -- to see event listeners attached to DOM elements (we'll cover them in the next part of the tutorial).
+At the right part of the tools there are the following subtabs:
+- **Styles** -- we can see CSS applied to the current element rule by rule, including built-in rules (gray). Almost everything can be edited in-place, including the dimensions/margins/paddings of the box below.
+- **Computed** -- to see CSS applied to the element by property: for each property we can see a rule that gives it (including CSS inheritance and such).
+- **Event Listeners** -- to see event listeners attached to DOM elements (we'll cover them in the next part of the tutorial).
 - ...and so on.
 
-The best way to study them is to click around. Most values are in-place editable.
+The best way to study them is to click around. Most values are editable in-place.
 
 ## Interaction with console
 
@@ -244,7 +244,7 @@ Or we can just output it in the console and explore "at-place", like `document.b
 
 That's for debugging purposes of course. From the next chapter on we'll access and modify DOM using JavaScript.
 
-The browser developer tools are a great help in development: we can explore DOM, try things and see what goes wrong.
+The browser developer tools are a great help in development: we can explore the DOM, try things and see what goes wrong.
 
 ## Summary
 
@@ -256,6 +256,6 @@ An HTML/XML document is represented inside the browser as the DOM tree.
 
 We can use developer tools to inspect DOM and modify it manually.
 
-Here we covered the basics, most used and important actions to start with. There's an extensive documentation about Chrome developer tools at <https://developers.google.com/web/tools/chrome-devtools>. The best way to learn the tools is to click here and there, read menus: most options are obvious. Later, when you know them in general, read the docs and pick up the rest.
+Here we covered the basics, the most used and important actions to start with. There's an extensive documentation about Chrome Developer Tools at <https://developers.google.com/web/tools/chrome-devtools>. The best way to learn the tools is to click here and there, read menus: most options are obvious. Later, when you know them in general, read the docs and pick up the rest.
 
 DOM nodes have properties and methods that allow to travel between them, modify, move around the page and more. We'll get down to them in the next chapters.
diff --git a/2-ui/1-document/03-dom-navigation/article.md b/2-ui/1-document/03-dom-navigation/article.md
index ab96e5f7..976e595a 100644
--- a/2-ui/1-document/03-dom-navigation/article.md
+++ b/2-ui/1-document/03-dom-navigation/article.md
@@ -7,11 +7,9 @@ libs:
 
 # Walking the DOM
 
-DOM allows to do anything with elements and their contents, but first we need to reach the corresponding DOM object, get it into a variable, and then we are able to modify it.
+The DOM allows to do anything with elements and their contents, but first we need to reach the corresponding DOM object, get it into a variable, and then we are able to modify it.
 
-All operations on DOM start with the `document` object. From it we can access any node.
-
-[cut]
+All operations on the DOM start with the `document` object. From it we can access any node.
 
 Here's a picture of links that allow to travel between DOM nodes:
 
@@ -88,7 +86,7 @@ For instance, here `<body>` has children `<div>` and `<ul>` (and few blank text
 </html>
 ```
 
-...And if we ask for all descendants of `<body>`, then we get direct children `<div>`, `<ul>` and also more nested elements like `<li>` (being a child of `<ul>`) and `<b>` (being a child of `<li>`) -- the whole subtree.
+...And if we ask for all descendants of `<body>`, then we get direct children `<div>`, `<ul>` and also more nested elements like `<li>` (being a child of `<ul>`) and `<b>` (being a child of `<li>`) -- the entire subtree.
 
 **The `childNodes` collection provides access to all child nodes, including text nodes.**
 
@@ -157,7 +155,7 @@ The first thing is nice. The second is tolerable, because we can use `Array.from
 ```warn header="DOM collections are read-only"
 DOM collections, and even more -- *all* navigation properties listed in this chapter are read-only.
 
-We can't replace an child by something else assigning `childNodes[i] = ...`.
+We can't replace a child by something else assigning `childNodes[i] = ...`.
 
 Changing DOM needs other methods, we'll see them in the next chapter.
 ```
@@ -177,7 +175,7 @@ Please, don't. The `for..in` loop iterates over all enumerable properties. And c
 <body>
 <script>
   // shows 0, 1, length, item, values and more.
-  for(let prop in document.body.childNodes) alert(prop);
+  for (let prop in document.body.childNodes) alert(prop);
 </script>
 </body>
 ````
@@ -242,7 +240,7 @@ In other words, the `documentElement` (`<html>`) is the root node. Formally, it
 Sometimes that matters when we're walking over the chain of parents and call a method on each of them, but `document` doesn't have it, so we exclude it.
 ````
 
-Let's modify one of examples above: replace `childNodes` with `children`. Now it shows only elements:
+Let's modify one of the examples above: replace `childNodes` with `children`. Now it shows only elements:
 
 ```html run
 <html>
@@ -275,7 +273,7 @@ Certain types of DOM elements may provide additional properties, specific to the
 
 Tables are a great example and important particular case of that.
 
-**`<table>`** element supports (in addition to the given above) these properties:
+**The `<table>`** element supports (in addition to the given above) these properties:
 - `table.rows` -- the collection of `<tr>` elements of the table.
 - `table.caption/tHead/tFoot` -- references to elements `<caption>`, `<thead>`, `<tfoot>`.
 - `table.tBodies` -- the collection of `<tbody>` elements (can be many according to the standard).
@@ -285,8 +283,8 @@ Tables are a great example and important particular case of that.
 
 **`<tr>`:**
 - `tr.cells` -- the collection of `<td>` and `<th>` cells inside the given `<tr>`.
-- `tr.sectionRowIndex` -- the number of the given `<tr>` inside the enclosing `<thead>/<tbody>`.
-- `tr.rowIndex` -- the number of the `<tr>` in the table.
+- `tr.sectionRowIndex` -- the position (index) of the given `<tr>` inside the enclosing `<thead>/<tbody>/<tfoot>`.
+- `tr.rowIndex` -- the number of the `<tr>` in the table as a whole (including all table rows).
 
 **`<td>` and `<th>`:**
 - `td.cellIndex` -- the number of the cell inside the enclosing `<tr>`.
diff --git a/2-ui/1-document/04-searching-elements-dom/1-find-elements/solution.md b/2-ui/1-document/04-searching-elements-dom/1-find-elements/solution.md
index 0ada42ac..c7080388 100644
--- a/2-ui/1-document/04-searching-elements-dom/1-find-elements/solution.md
+++ b/2-ui/1-document/04-searching-elements-dom/1-find-elements/solution.md
@@ -25,7 +25,7 @@ let form = document.getElementsByName('search')[0]
 document.querySelector('form[name="search"]')
 
 // 5. The first input in that form.
-form.getElementsByTagName('input')
+form.getElementsByTagName('input')[0]
 // or
 form.querySelector('input')
 
diff --git a/2-ui/1-document/04-searching-elements-dom/2-tree-info/solution.md b/2-ui/1-document/04-searching-elements-dom/2-tree-info/solution.md
index 5bb2effa..781b7a92 100644
--- a/2-ui/1-document/04-searching-elements-dom/2-tree-info/solution.md
+++ b/2-ui/1-document/04-searching-elements-dom/2-tree-info/solution.md
@@ -1,7 +1,7 @@
 Let's make a loop over `<li>`:
 
 ```js
-for (let li of document.querySelector('li')) {
+for (let li of document.querySelectorAll('li')) {
   ...
 }
 ```
@@ -9,7 +9,7 @@ for (let li of document.querySelector('li')) {
 In the loop we need to get the text inside every `li`. We can read it directly from the first child node, that is the text node:
 
 ```js
-for (let li of document.querySelector('li')) {
+for (let li of document.querySelectorAll('li')) {
   let title = li.firstChild.data;
 
   // title is the text in <li> before any other nodes
diff --git a/2-ui/1-document/04-searching-elements-dom/2-tree-info/solution.view/index.html b/2-ui/1-document/04-searching-elements-dom/2-tree-info/solution.view/index.html
index d712bb9d..5947ec09 100644
--- a/2-ui/1-document/04-searching-elements-dom/2-tree-info/solution.view/index.html
+++ b/2-ui/1-document/04-searching-elements-dom/2-tree-info/solution.view/index.html
@@ -40,7 +40,7 @@
   </ul>
 
   <script>
-    for (let li of document.querySelector('li')) {
+    for (let li of document.querySelectorAll('li')) {
       // get the title from the text node
       let title = li.firstChild.data;
 
diff --git a/2-ui/1-document/04-searching-elements-dom/article.md b/2-ui/1-document/04-searching-elements-dom/article.md
index 50674218..3a7a9aee 100644
--- a/2-ui/1-document/04-searching-elements-dom/article.md
+++ b/2-ui/1-document/04-searching-elements-dom/article.md
@@ -3,8 +3,6 @@
 DOM navigation properties are great when elements are close to each other. What if they are not? How to get an arbitrary element of the page?
 
 There are additional searching methods for that.
-[cut]
-
 ## document.getElementById or just id
 
 If an element has the `id` attribute, then there's a global variable by the name from that `id`.
@@ -84,7 +82,7 @@ let divs = document.getElementsByTagName('div');
 
 This method is callable in the context of any DOM element.
 
-Let's find all `input` inside the table:
+Let's find all `input` tags inside the table:
 
 ```html run height=50
 <table id="table">
@@ -123,16 +121,16 @@ The `"s"` letter is absent in `getElementById`, because it returns a single elem
 ```
 
 ````warn header="It returns a collection, not an element!"
-Another widespread novice mistake is to write like:
+Another widespread novice mistake is to write:
 
 ```js
 // doesn't work
 document.getElementsByTagName('input').value = 5;
 ```
 
-That won't work, because it takes a *collection* of inputs and assigns the value to it, rather to elements inside it.
+That won't work, because it takes a *collection* of inputs and assigns the value to it rather than to elements inside it.
 
-We should either iterate over the collection or get an element by the number, and then assign, like this:
+We should either iterate over the collection or get an element by its index, and then assign, like this:
 
 ```js
 // should work (if there's an input)
@@ -374,7 +372,7 @@ Other methods can be called on elements too. For instance `elem.querySelectorAll
 Besides that:
 
 - There is `elem.matches(css)` to check if `elem` matches the given CSS selector.
-- There is `elem.closest(css)` to look for a nearest ancestor that matches the given CSS-selector. The `elem` itself is also checked.
+- There is `elem.closest(css)` to look for the nearest ancestor that matches the given CSS-selector. The `elem` itself is also checked.
 
 And let's mention one more method here to check for the child-parent relationship:
 -  `elemA.contains(elemB)` returns true if `elemB` is inside `elemA` (a descendant of `elemA`) or when `elemA==elemB`.
diff --git a/2-ui/1-document/05-basic-dom-node-properties/2-lastchild-nodetype-inline/task.md b/2-ui/1-document/05-basic-dom-node-properties/2-lastchild-nodetype-inline/task.md
index 596192a1..0ed407ca 100644
--- a/2-ui/1-document/05-basic-dom-node-properties/2-lastchild-nodetype-inline/task.md
+++ b/2-ui/1-document/05-basic-dom-node-properties/2-lastchild-nodetype-inline/task.md
@@ -4,7 +4,7 @@ importance: 5
 
 # What's in the nodeType?
 
-What the script shows?
+What does the script show?
 
 ```html
 <html>
diff --git a/2-ui/1-document/05-basic-dom-node-properties/3-tag-in-comment/solution.md b/2-ui/1-document/05-basic-dom-node-properties/3-tag-in-comment/solution.md
index 89b76cfd..32900a78 100644
--- a/2-ui/1-document/05-basic-dom-node-properties/3-tag-in-comment/solution.md
+++ b/2-ui/1-document/05-basic-dom-node-properties/3-tag-in-comment/solution.md
@@ -12,6 +12,6 @@ The answer: **`BODY`**.
 
 What's going on step by step:
 
-1. The content of `<body>` is replaced with the comment. The comment is <code>&lt;!--BODY--&gt;</code>, because `body.tagName == "BODY"`. As we remember, `tagName` is always uppercase in HTML.
+1. The content of `<body>` is replaced with the comment. The comment is `<!--BODY-->`, because `body.tagName == "BODY"`. As we remember, `tagName` is always uppercase in HTML.
 2. The comment is now the only child node, so we get it in `body.firstChild`.
 3. The `data` property of the comment is its contents (inside `<!--...-->`): `"BODY"`.
diff --git a/2-ui/1-document/05-basic-dom-node-properties/3-tag-in-comment/task.md b/2-ui/1-document/05-basic-dom-node-properties/3-tag-in-comment/task.md
index 40bea8a0..efe50b48 100644
--- a/2-ui/1-document/05-basic-dom-node-properties/3-tag-in-comment/task.md
+++ b/2-ui/1-document/05-basic-dom-node-properties/3-tag-in-comment/task.md
@@ -4,7 +4,7 @@ importance: 3
 
 # Tag in comment
 
-What this code shows?
+What does this code show?
 
 ```html
 <script>
diff --git a/2-ui/1-document/05-basic-dom-node-properties/4-where-document-in-hierarchy/task.md b/2-ui/1-document/05-basic-dom-node-properties/4-where-document-in-hierarchy/task.md
index d83602dc..de266c6a 100644
--- a/2-ui/1-document/05-basic-dom-node-properties/4-where-document-in-hierarchy/task.md
+++ b/2-ui/1-document/05-basic-dom-node-properties/4-where-document-in-hierarchy/task.md
@@ -4,7 +4,7 @@ importance: 4
 
 # Where's the "document" in the hierarchy?
 
-Which class the `document` belongs to?
+Which class does the `document` belong to?
 
 What's its place in the DOM hierarchy?
 
diff --git a/2-ui/1-document/05-basic-dom-node-properties/article.md b/2-ui/1-document/05-basic-dom-node-properties/article.md
index 2783c3a8..85bca24b 100644
--- a/2-ui/1-document/05-basic-dom-node-properties/article.md
+++ b/2-ui/1-document/05-basic-dom-node-properties/article.md
@@ -4,8 +4,6 @@ Let's get a more in-depth look at DOM nodes.
 
 In this chapter we'll see more into what they are and their most used properties.
 
-[cut]
-
 ## DOM node classes
 
 DOM nodes have different properties depending on their class. For instance, an element node corresponding to tag `<a>` has link-related properties, and the one corresponding to `<input>` has input-related properties and so on. Text nodes are not the same as element nodes. But there are also common properties and methods between all of them, because all classes of DOM nodes form a single hierarchy.
@@ -78,7 +76,7 @@ Try it on `document.body`.
 ```
 
 ````smart header="IDL in the spec"
-In the specification classes are described using not JavaScript, but a special [Interface description language](https://en.wikipedia.org/wiki/Interface_description_language) (IDL), that is usually easy to understand.
+In the specification, classes are described not using JavaScript, but a special [Interface description language](https://en.wikipedia.org/wiki/Interface_description_language) (IDL), that is usually easy to understand.
 
 In IDL all properties are prepended with their types. For instance, `DOMString`, `boolean` and so on.
 
@@ -165,11 +163,11 @@ Sure, the difference is reflected in their names, but is indeed a bit subtle.
 - The `tagName` property exists only for `Element` nodes.
 - The `nodeName` is defined for any `Node`:
     - for elements it means the same as `tagName`.
-    - for other node types (text, comment etc) it has a string with the node type.
+    - for other node types (text, comment, etc.) it has a string with the node type.
 
 In other words, `tagName` is only supported by element nodes (as it originates from `Element` class), while `nodeName` can say something about other node types.
 
-For instance let's compare `tagName` and `nodeName` for the `document` and a comment node:
+For instance, let's compare `tagName` and `nodeName` for the `document` and a comment node:
 
 
 ```html run
@@ -177,7 +175,7 @@ For instance let's compare `tagName` and `nodeName` for the `document` and a com
 
   <script>
     // for comment
-    alert( document.body.firstChild.tagName ); // undefined (not element)
+    alert( document.body.firstChild.tagName ); // undefined (no element)
     alert( document.body.firstChild.nodeName ); // #comment
 
     // for document
@@ -220,7 +218,7 @@ The example shows the contents of `document.body` and then replaces it completel
 </body>
 ```
 
-We can try to insert an invalid HTML, the browser will fix our errors:
+We can try to insert invalid HTML, the browser will fix our errors:
 
 ```html run
 <body>
@@ -463,28 +461,28 @@ Most standard HTML attributes have the corresponding DOM property, and we can ac
 
 If we want to know the full list of supported properties for a given class, we can find them in the specification. For instance, HTMLInputElement is documented at <https://html.spec.whatwg.org/#htmlinputelement>.
 
-Or if we'd like to get them fast or interested in the concrete browser -- we can always output the element using `console.dir(elem)` and read the properties. Or explore "DOM properties" in Elements tab of the browser developer tools.
+Or if we'd like to get them fast or are interested in a concrete browser specification -- we can always output the element using `console.dir(elem)` and read the properties. Or explore "DOM properties" in the Elements tab of the browser developer tools.
 
 ## Summary
 
-Each DOM node belongs to a certain class. The classes form a hierarchy. The full set of properties and methods comes as the result of inheritance.
+Each DOM node belongs to a certain class. The classes form a hierarchy. The full set of properties and methods come as the result of inheritance.
 
 Main DOM node properties are:
 
 `nodeType`
-: Node type. We can get it from the DOM object class, but often we need just to see if it is a text or element node. The `nodeType` property is good for that. It has numeric values, most important are: `1` -- for elements,`3` -- for text nodes. Read-only.
+: We can get `nodeType` from the DOM object class, but often we need just to see if it is a text or element node. The `nodeType` property is good for that. It has numeric values, most important are: `1` -- for elements,`3` -- for text nodes. Read-only.
 
 `nodeName/tagName`
-: For elements, tag name (uppercased unless XML-mode). For non-element nodes `nodeName` describes what is it. Read-only.
+: For elements, tag name (uppercased unless XML-mode). For non-element nodes `nodeName` describes what it is. Read-only.
 
 `innerHTML`
-: The HTML content of the element. Can modify.
+: The HTML content of the element. Can be modified.
 
 `outerHTML`
 : The full HTML of the element. A write operation into `elem.outerHTML` does not touch `elem` itself. Instead it gets replaced with the new HTML in the outer context.
 
 `nodeValue/data`
-: The content of a non-element node (text, comment). These two are almost the same, usually we use `data`. Can modify.
+: The content of a non-element node (text, comment). These two are almost the same, usually we use `data`. Can be modified.
 
 `textContent`
 : The text inside the element, basically HTML minus all `<tags>`. Writing into it puts the text inside the element, with all special characters and tags treated exactly as text. Can safely insert user-generated text and protect from unwanted HTML insertions.
@@ -492,6 +490,6 @@ Main DOM node properties are:
 `hidden`
 : When set to `true`, does the same as CSS `display:none`.
 
-DOM nodes also have other properties depending on their class. For instance, `<input>` elements (`HTMLInputElement`) support `value`, `type`, while `<a>` elements (`HTMLAnchorElement`) support `href` etc. Most standard HTML attributes have the corresponding DOM property.
+DOM nodes also have other properties depending on their class. For instance, `<input>` elements (`HTMLInputElement`) support `value`, `type`, while `<a>` elements (`HTMLAnchorElement`) support `href` etc. Most standard HTML attributes have a corresponding DOM property.
 
 But HTML attributes and DOM properties are not always the same, as we'll see in the next chapter.
diff --git a/2-ui/1-document/06-dom-attributes-and-properties/1-get-user-attribute/solution.md b/2-ui/1-document/06-dom-attributes-and-properties/1-get-user-attribute/solution.md
index 5d3fe241..0507832f 100644
--- a/2-ui/1-document/06-dom-attributes-and-properties/1-get-user-attribute/solution.md
+++ b/2-ui/1-document/06-dom-attributes-and-properties/1-get-user-attribute/solution.md
@@ -1,6 +1,6 @@
 
 ```html run height=100
-<!DOCTYLE HTML>
+<!DOCTYPE html>
 <html>
 <body>
 
diff --git a/2-ui/1-document/06-dom-attributes-and-properties/1-get-user-attribute/task.md b/2-ui/1-document/06-dom-attributes-and-properties/1-get-user-attribute/task.md
index 0d11ff97..4cdf231b 100644
--- a/2-ui/1-document/06-dom-attributes-and-properties/1-get-user-attribute/task.md
+++ b/2-ui/1-document/06-dom-attributes-and-properties/1-get-user-attribute/task.md
@@ -7,7 +7,7 @@ importance: 5
 Write the code to select the element with `data-widget-name` attribute from the document and to read its value.
 
 ```html run
-<!DOCTYLE HTML>
+<!DOCTYPE html>
 <html>
 <body>
 
diff --git a/2-ui/1-document/06-dom-attributes-and-properties/article.md b/2-ui/1-document/06-dom-attributes-and-properties/article.md
index bdfb51f0..8c082cb6 100644
--- a/2-ui/1-document/06-dom-attributes-and-properties/article.md
+++ b/2-ui/1-document/06-dom-attributes-and-properties/article.md
@@ -4,9 +4,7 @@ When the browser loads the page, it "reads" (another word: "parses") HTML text a
 
 For instance, if the tag is `<body id="page">`, then the DOM object has `body.id="page"`.
 
-But the attribute-property mapping is not one-to-one! In this chapter we'll pay attention to separate these two notions, to see how to work with them, when they are same, and when they are different.
-
-[cut]
+But the attribute-property mapping is not one-to-one! In this chapter we'll pay attention to separate these two notions, to see how to work with them, when they are the same, and when they are different.
 
 ## DOM properties
 
@@ -28,11 +26,11 @@ alert(document.body.myData.title); // Imperator
 We can add a method as well:
 
 ```js run
-document.body.sayHi = function() {
+document.body.sayTagName = function() {
   alert(this.tagName);
 };
 
-document.body.sayHi(); // BODY (the value of "this" in the method is document.body)
+document.body.sayTagName(); // BODY (the value of "this" in the method is document.body)
 ```
 
 We can also modify built-in prototypes like `Element.prototype` and add new methods to all elements:
@@ -110,10 +108,10 @@ Here's a demo of reading a non-standard property:
 </body>
 ```
 
-HTML attributes have following features:
+HTML attributes have the following features:
 
-- Their name is case-insensitive (that's HTML: `id` is same as `ID`).
-- They are always strings.
+- Their name is case-insensitive (`id` is same as `ID`).
+- Their values are always strings.
 
 Here's an extended demo of working with attributes:
 
@@ -129,7 +127,7 @@ Here's an extended demo of working with attributes:
     alert( elem.outerHTML ); // (3), see it's there
 
     for (let attr of elem.attributes) { // (4) list all
-      alert( attr.name + " = " + attr.value );
+      alert( `${attr.name} = ${attr.value}` );
     }
   </script>
 </body>
@@ -138,15 +136,15 @@ Here's an extended demo of working with attributes:
 Please note:
 
 1. `getAttribute('About')` -- the first letter is uppercase here, and in HTML it's all lowercase. But that doesn't matter: attribute names are case-insensitive.
-2. We can assign anything to an attribute, but that becomes a string. So here we have `"123"` as the value.
+2. We can assign anything to an attribute, but it becomes a string. So here we have `"123"` as the value.
 3. All attributes including ones that we set are visible in `outerHTML`.
 4. The `attributes` collection is iterable and has all attributes with `name` and `value`.
 
 ## Property-attribute synchronization
 
-When a standard attribute changes, the corresponding property is auto-updated, and (with some exceptions) vise-versa.
+When a standard attribute changes, the corresponding property is auto-updated, and (with some exceptions) vice versa.
 
-In the example below `id` is modified as an attribute, and we can see the property change too. And then the same backwards:
+In the example below `id` is modified as an attribute, and we can see the property changed too. And then the same backwards:
 
 ```html run
 <input>
@@ -188,11 +186,11 @@ In the example above:
 - Changing the attribute `value` updates the property.
 - But the property change does not affect the attribute.
 
-That "feature" may actually can come in handy, because the user may modify `value`, and then after it, if we want to recover the "original" value from HTML, it's in the attribute.
+That "feature" may actually come in handy, because the user may modify `value`, and then after it, if we want to recover the "original" value from HTML, it's in the attribute.
 
 ## DOM properties are typed
 
-DOM properties are not always strings. For instance, `input.checked` property (for checkboxes) is boolean:
+DOM properties are not always strings. For instance, the `input.checked` property (for checkboxes) is a boolean:
 
 ```html run
 <input id="input" type="checkbox" checked> checkbox
@@ -203,7 +201,7 @@ DOM properties are not always strings. For instance, `input.checked` property (f
 </script>
 ```
 
-There are other examples. The `style` attribute is a string, but `style` property is an object:
+There are other examples. The `style` attribute is a string, but the `style` property is an object:
 
 ```html run
 <div id="div" style="color:red;font-size:120%">Hello</div>
@@ -311,9 +309,9 @@ div.setAttribute('order-state', 'canceled');
 
 But there may be a possible problem with custom attributes. What if we use a non-standard attribute for our purposes and later the standard introduces it and makes it do something? The HTML language is alive, it grows, more attributes appear to suit the needs of developers. There may be unexpected effects in such case.
 
-To evade conflicts, there exist [data-*](https://html.spec.whatwg.org/#embedding-custom-non-visible-data-with-the-data-*-attributes) attributes.
+To avoid conflicts, there exist [data-*](https://html.spec.whatwg.org/#embedding-custom-non-visible-data-with-the-data-*-attributes) attributes.
 
-**All attributes starting with "data-" are reserved for programmers' use. They are available in `dataset` property.**
+**All attributes starting with "data-" are reserved for programmers' use. They are available in the `dataset` property.**
 
 For instance, if an `elem` has an attribute named `"data-about"`, it's available as `elem.dataset.about`.
 
@@ -382,7 +380,7 @@ Methods to work with attributes are:
 - `elem.removeAttribute(name)` -- to remove the attribute.
 - `elem.attributes` is a collection of all attributes.
 
-For most needs DOM properties can serve us well. We should refer to attributes only when DOM properties do not suit us, when we need exactly attributes, for instance:
+For most needs, DOM properties can serve us well. We should refer to attributes only when DOM properties do not suit us, when we need exactly attributes, for instance:
 
 - We need a non-standard attribute. But if it starts with `data-`, then we should use `dataset`.
-- We want to read the value "as written" in HTML. The value of the DOM property may be different, for instance `href` property is always a full URL, and we may want to get the "original" value.
+- We want to read the value "as written" in HTML. The value of the DOM property may be different, for instance the `href` property is always a full URL, and we may want to get the "original" value.
diff --git a/2-ui/1-document/07-modifying-document/5-why-aaa/solution.md b/2-ui/1-document/07-modifying-document/5-why-aaa/solution.md
index 25c1e819..6b85168b 100644
--- a/2-ui/1-document/07-modifying-document/5-why-aaa/solution.md
+++ b/2-ui/1-document/07-modifying-document/5-why-aaa/solution.md
@@ -4,6 +4,6 @@ The browser has to fix it automatically. But there may be no text inside the `<t
 
 Now it's obvious that when we remove the table, it remains.
 
-The question can be easily answered by exploring DOM using the browser tools. They show `"aaa"` before the `<table>`.
+The question can be easily answered by exploring the DOM using the browser tools. It shows `"aaa"` before the `<table>`.
 
 The HTML standard specifies in detail how to process bad HTML, and such behavior of the browser is correct.
diff --git a/2-ui/1-document/07-modifying-document/5-why-aaa/task.md b/2-ui/1-document/07-modifying-document/5-why-aaa/task.md
index aedf8697..03064ed2 100644
--- a/2-ui/1-document/07-modifying-document/5-why-aaa/task.md
+++ b/2-ui/1-document/07-modifying-document/5-why-aaa/task.md
@@ -2,9 +2,9 @@ importance: 1
 
 ---
 
-# Why "aaa" remains?
+# Why does "aaa" remain?
 
-Run the example. Why `table.remove()` does not delete the text `"aaa"`?
+Run the example. Why does `table.remove()` not delete the text `"aaa"`?
 
 ```html height=100 run
 <table id="table">
diff --git a/2-ui/1-document/07-modifying-document/article.md b/2-ui/1-document/07-modifying-document/article.md
index adef6f9f..38e1199e 100644
--- a/2-ui/1-document/07-modifying-document/article.md
+++ b/2-ui/1-document/07-modifying-document/article.md
@@ -6,11 +6,9 @@ Here we'll see how to create new elements "on the fly" and modify the existing p
 
 First we'll see a simple example and then explain the methods.
 
-[cut]
-
 ## Example: show a message
 
-For the start, let's see how to add a message on the page that looks nicer than `alert`.
+For a start, let's see how to add a message on the page that looks nicer than `alert`.
 
 Here's how it will look:
 
@@ -32,7 +30,7 @@ Here's how it will look:
 */!*
 ```
 
-That was an HTML example. Now let's create the same `div` with JavaScript (assuming that the styles are still in the HTML or an external CSS).
+That was an HTML example. Now let's create the same `div` with JavaScript (assuming that the styles are still in the HTML or an external CSS file).
 
 ## Creating an element
 
@@ -63,7 +61,7 @@ div.className = "alert alert-success";
 div.innerHTML = "<strong>Hi there!</strong> You've read an important message.";
 ```
 
-After that, we have a ready DOM element. Right now it's in the variable, but can not be seen, because not inserted into the page yet.
+After that, we have a ready DOM element. Right now it's in the variable, but can not be seen, because it's not been inserted into the page yet.
 
 ## Insertion methods
 
@@ -137,9 +135,8 @@ Here's a brief list of methods to insert a node into a parent element (`parentEl
     */!*
     </script>
     ```
-
-    To insert as the first element, we can do like this:
-
+    To insert `newLi` as the first element, we can do it like this:
+    
     ```js
     list.insertBefore(newLi, list.firstChild);
     ```
@@ -153,7 +150,7 @@ These methods are "old school": they exist from the ancient times and we can mee
 
 For instance, how to insert *html* if we have it as a string? Or, given a node, how to insert another node *before* it? Of course, all that is doable, but not in an elegant way.
 
-So there exists two other sets of insertion methods to handle all cases easily.
+So there exist two other sets of insertion methods to handle all cases easily.
 
 ### prepend/append/before/after
 
@@ -206,7 +203,7 @@ before
 after
 ```
 
-These methods can insert multiple list of nodes and text pieces in a single call.
+These methods can insert multiple lists of nodes and text pieces in a single call.
 
 For instance, here a string and an element are inserted:
 
@@ -279,7 +276,7 @@ The method has two brothers:
 - `elem.insertAdjacentText(where, text)` -- the same syntax, but a string of `text` in inserted "as text" instead of HTML,
 - `elem.insertAdjacentElement(where, elem)` -- the same syntax, but inserts an element.
 
-They exist mainly to make the syntax "uniform". In practice, most of time only `insertAdjacentHTML` is used, because for elements and text we have methods `append/prepend/before/after` -- they are shorter to write and can insert nodes/text pieces.
+They exist mainly to make the syntax "uniform". In practice, most of the time only `insertAdjacentHTML` is used, because for elements and text we have methods `append/prepend/before/after` -- they are shorter to write and can insert nodes/text pieces.
 
 So here's an alternative variant of showing a message:
 
@@ -305,7 +302,7 @@ So here's an alternative variant of showing a message:
 
 How to insert one more similar message?
 
-We could do a function and put the code there. But the alternative way would be to *clone* the existing `div` and modify the text inside it (if needed).
+We could make a function and put the code there. But the alternative way would be to *clone* the existing `div` and modify the text inside it (if needed).
 
 Sometimes when we have a big element, that may be faster and simpler.
 
@@ -340,7 +337,7 @@ An example of copying the message:
 
 ## Removal methods
 
-To remove nodes, there are following methods:
+To remove nodes, there are the following methods:
 
 
 `parentElem.removeChild(node)`
@@ -414,7 +411,7 @@ The call to `document.write(html)` writes the `html` into page "right here and n
 
 The method comes from times when there were no DOM, no standards... Really old times. It still lives, because there are scripts using it.
 
-In modern scripts we can rarely see it, because of the important limitation.
+In modern scripts we can rarely see it, because of the following important limitation:
 
 **The call to `document.write` only works while the page is loading.**
 
@@ -482,4 +479,4 @@ Insertion and removal of nodes:
 - To append HTML to the page before it has finished loading:
   - `document.write(html)`
 
-  After the page is loaded such call erases the document. Mostly seen in old scripts.
+  After the page is loaded such a call erases the document. Mostly seen in old scripts.
diff --git a/2-ui/1-document/08-styles-and-classes/2-create-notification/solution.view/index.html b/2-ui/1-document/08-styles-and-classes/2-create-notification/solution.view/index.html
index 5b8a6336..dc4eeec9 100755
--- a/2-ui/1-document/08-styles-and-classes/2-create-notification/solution.view/index.html
+++ b/2-ui/1-document/08-styles-and-classes/2-create-notification/solution.view/index.html
@@ -26,7 +26,7 @@
       notification.style.top = top + 'px';
       notification.style.right = right + 'px';
 
-      notification.innerHTML = options.html;
+      notification.innerHTML = html;
       document.body.append(notification);
 
       setTimeout(() => notification.remove(), 1500);
diff --git a/2-ui/1-document/08-styles-and-classes/2-create-notification/task.md b/2-ui/1-document/08-styles-and-classes/2-create-notification/task.md
index 7df1986c..60930cb6 100644
--- a/2-ui/1-document/08-styles-and-classes/2-create-notification/task.md
+++ b/2-ui/1-document/08-styles-and-classes/2-create-notification/task.md
@@ -4,7 +4,7 @@ importance: 5
 
 # Create a notification
 
-Write a function `showNotification(options)` that a notification: `<div class="notification">` with the given content. The notification should automatically disappear after 1.5 seconds.
+Write a function `showNotification(options)` that creates a notification: `<div class="notification">` with the given content. The notification should automatically disappear after 1.5 seconds.
 
 The options are:
 
diff --git a/2-ui/1-document/08-styles-and-classes/article.md b/2-ui/1-document/08-styles-and-classes/article.md
index 1c5f0948..3227da15 100644
--- a/2-ui/1-document/08-styles-and-classes/article.md
+++ b/2-ui/1-document/08-styles-and-classes/article.md
@@ -7,8 +7,6 @@ There are generally two ways to style an element:
 1. Create a class in CSS and add it: `<div class="...">`
 2. Write properties directly into `style`: `<div style="...">`.
 
-[cut]
-
 CSS is always the preferred way -- not only for HTML, but in JavaScript as well.
 
 We should only manipulate the `style` property if classes "can't handle it".
@@ -26,7 +24,7 @@ For other cases, like making the text red, adding a background icon -- describe
 
 ## className and classList
 
-Changing a class is one of the most often actions in scripts.
+Changing a class is one of the most often used actions in scripts.
 
 In the ancient time, there was a limitation in JavaScript: a reserved word like `"class"` could not be an object property. That limitation does not exist now, but at that time it was impossible to have a `"class"` property, like `elem.class`.
 
@@ -76,7 +74,7 @@ Besides that, `classList` is iterable, so we can list all classes like this:
 ```html run
 <body class="main page">
   <script>
-    for(let name of document.body.classList) {
+    for (let name of document.body.classList) {
       alert(name); // main, and then page
     }
   </script>
@@ -209,7 +207,7 @@ For instance, here `style` doesn't see the margin:
 </body>
 ```
 
-...But what if we need, say, increase the margin by 20px? We want the current value for the start.
+...But what if we need, say, to increase the margin by 20px? We want the current value for the start.
 
 There's another method for that: `getComputedStyle`.
 
@@ -223,7 +221,7 @@ element
 : Element to read the value for.
 
 pseudo
-: A pseudo-element if required, for instance `::before`. An empty string or no argument mean the element itself.
+: A pseudo-element if required, for instance `::before`. An empty string or no argument means the element itself.
 
 The result is an object with style properties, like `elem.style`, but now with respect to all CSS classes.
 
@@ -250,10 +248,10 @@ For instance:
 ```smart header="Computed and resolved values"
 There are two concepts in [CSS](https://drafts.csswg.org/cssom/#resolved-values):
 
-1. A *computed* style value is the value after all CSS rules and CSS inheritance is applied, as the  result of the CSS cascade. If can look like `height:1em` or `font-size:125%`.
+1. A *computed* style value is the value after all CSS rules and CSS inheritance is applied, as the  result of the CSS cascade. It can look like `height:1em` or `font-size:125%`.
 2. A *resolved* style value is the one finally applied to the element. Values like `1em` or `125%` are relative. The browser takes the computed value and makes all units fixed and absolute, for instance: `height:20px` or `font-size:16px`. For geometry properties resolved values may have a floating point, like `width:50.5px`.
 
-Long time ago `getComputedStyle` was created to get computed values, but it turned out that resolved values are much more convenient, and the standard changed.
+A long time ago `getComputedStyle` was created to get computed values, but it turned out that resolved values are much more convenient, and the standard changed.
 
 So nowadays `getComputedStyle` actually returns the resolved value of the property.
 ```
@@ -283,7 +281,7 @@ Visited links may be colored using `:visited` CSS pseudoclass.
 
 But `getComputedStyle` does not give access to that color, because otherwise an arbitrary page could find out whether the user visited a link by creating it on the page and checking the styles.
 
-JavaScript we may not see the styles applied by `:visited`. And also, there's a limitation in CSS that forbids to apply geometry-changing styles in `:visited`. That's to guarantee that there's no side way for an evil page to test if a link was visited and hence to break the privacy.
+JavaScript we may not see the styles applied by `:visited`. And also, there's a limitation in CSS that forbids to apply geometry-changing styles in `:visited`. That's to guarantee that there's no sideway for an evil page to test if a link was visited and hence to break the privacy.
 ```
 
 ## Summary
diff --git a/2-ui/1-document/09-size-and-scroll/article.md b/2-ui/1-document/09-size-and-scroll/article.md
index 375cb4d9..4fadba81 100644
--- a/2-ui/1-document/09-size-and-scroll/article.md
+++ b/2-ui/1-document/09-size-and-scroll/article.md
@@ -1,11 +1,9 @@
 # Element size and scrolling
 
-There are many JavaScript properties that allow to read information about element width, height and other geometry features.
+There are many JavaScript properties that allow us to read information about element width, height and other geometry features.
 
 We often need them when moving or positioning elements in JavaScript, to correctly calculate coordinates.
 
-[cut]
-
 
 ## Sample element
 
@@ -37,7 +35,7 @@ You can [open the document in the sandbox](sandbox:metric).
 ```smart header="Mind the scrollbar"
 The picture above demonstrates the most complex case when the element has a scrollbar. Some browsers (not all) reserve the space for it by taking it from the content.
 
-So, without scrollbar the content width would be `300px`, but if the scrollbar is `16px` wide (the width may vary between devices and browsers) then only `300-16 = 284px` remains, and we should take it into account. That's why examples from this chapter assume that there's a scrollbar. If there's no scrollbar, then things are just a bit simpler.
+So, without scrollbar the content width would be `300px`, but if the scrollbar is `16px` wide (the width may vary between devices and browsers) then only `300 - 16 = 284px` remains, and we should take it into account. That's why examples from this chapter assume that there's a scrollbar. If there's no scrollbar, then things are just a bit simpler.
 ```
 
 ```smart header="The `padding-bottom` may be filled with text"
@@ -68,7 +66,7 @@ The `offsetParent` is the nearest ancestor that is:
 
 In most practical cases we can use `offsetParent` to get the nearest CSS-positioned ancestor. And `offsetLeft/offsetTop` provide x/y coordinates relative to it's left-upper corner.
 
-In the example below the inner `<div>` has `<main>` as `offsetParent` and `offsetLeft/offsetTop` are shifts from its left-upper corner (`180`):
+In the example below the inner `<div>` has `<main>` as `offsetParent` and `offsetLeft/offsetTop` shifts from its left-upper corner (`180`):
 
 ```html run height=10
 <main style="position: relative" id="main">
@@ -90,11 +88,11 @@ There are several occasions when `offsetParent` is `null`:
 
 1. For not shown elements (`display:none` or not in the document).
 2. For `<body>` and `<html>`.
-3. For elements with `position:fixed` on them.
+3. For elements with `position:fixed`.
 
 ## offsetWidth/Height
 
-Now let's move to the element itself.
+Now let's move on to the element itself.
 
 These two properties are the simplest ones. They provide the "outer" width/height of the element. Or, in other words, its full size including borders.
 
@@ -102,7 +100,7 @@ These two properties are the simplest ones. They provide the "outer" width/heigh
 
 For our sample element:
 
-- `offsetWidth = 390` -- the outer width, can be calculated as inner CSS-width (`300px`) plus paddings (`2*20px`) and borders (`2*25px`).
+- `offsetWidth = 390` -- the outer width, can be calculated as inner CSS-width (`300px`) plus paddings (`2 * 20px`) and borders (`2 * 25px`).
 - `offsetHeight = 290` -- the outer height.
 
 ````smart header="Geometry properties for not shown elements are zero/null"
@@ -140,9 +138,9 @@ In our example:
 
 What's the difference?
 
-It becomes visible when the document is right-to-left (the operation system is in arabic or hebrew languages). The scrollbar is then not on the right, but on the left, and then `clientLeft` also includes the scrollbar width.
+It becomes visible when the document is right-to-left (the operating system is in Arabic or Hebrew languages). The scrollbar is then not on the right, but on the left, and then `clientLeft` also includes the scrollbar width.
 
-In that case `clientLeft` in our example would be not `25`, but with the scrollbar width `25+16=41`:
+In that case, `clientLeft` would be not `25`, but with the scrollbar width `25 + 16 = 41`:
 
 ![](metric-client-left-top-rtl.png)
 
@@ -154,7 +152,7 @@ They include the content width together with paddings, but without the scrollbar
 
 ![](metric-client-width-height.png)
 
-On the picture above let's first consider `clientHeight`: it's easier to evaluate. There's no horizontal scrollbar, so it's exactly the sum of what's inside the borders: CSS-height `200px` plus top and bottom paddings (`2*20px`) total `240px`.
+On the picture above let's first consider `clientHeight`: it's easier to evaluate. There's no horizontal scrollbar, so it's exactly the sum of what's inside the borders: CSS-height `200px` plus top and bottom paddings (`2 * 20px`) total `240px`.
 
 Now `clientWidth` -- here the content width is not `300px`, but `284px`, because `16px` are occupied by the scrollbar. So the sum is `284px` plus left and right paddings, total `324px`.
 
@@ -167,13 +165,13 @@ So when there's no padding we can use `clientWidth/clientHeight` to get the cont
 ## scrollWidth/Height
 
 - Properties `clientWidth/clientHeight` only account for the visible part of the element.
-- Properties `scrollWidth/scrollHeight` also include the scrolled out (hidden) part:
+- Properties `scrollWidth/scrollHeight` also include the scrolled out (hidden) parts:
 
 ![](metric-scroll-width-height.png)
 
 On the picture above:
 
-- `scrollHeight = 723` -- is the full inner height of the content area including the scrolled out part.
+- `scrollHeight = 723` -- is the full inner height of the content area including the scrolled out parts.
 - `scrollWidth = 324` -- is the full inner width, here we have no horizontal scroll, so it equals `clientWidth`.
 
 We can use these properties to expand the element wide to its full width/height.
@@ -182,7 +180,7 @@ Like this:
 
 ```js
 // expand the element to the full content height
-element.style.height = element.scrollHeight + 'px';
+element.style.height = `${element.scrollHeight}px`;
 ```
 
 ```online
@@ -190,7 +188,7 @@ Click the button to expand the element:
 
 <div id="element" style="width:300px;height:200px; padding: 0;overflow: auto; border:1px solid black;">text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text</div>
 
-<button style="padding:0" onclick="element.style.height = element.scrollHeight + 'px'">element.style.height = element.scrollHeight + 'px'</button>
+<button style="padding:0" onclick="element.style.height = `${element.scrollHeight}px`">element.style.height = `${element.scrollHeight}px`</button>
 ```
 
 ## scrollLeft/scrollTop
@@ -207,7 +205,7 @@ In other words, `scrollTop` is "how much is scrolled up".
 Most geometry properties that are read-only, but `scrollLeft/scrollTop` can be changed, and the browser will scroll the element.
 
 ```online
-If you click the element below, the code `elem.scrollTop+=10` executes. That makes the element content scroll `10px` below.
+If you click the element below, the code `elem.scrollTop += 10` executes. That makes the element content scroll `10px` down.
 
 <div onclick="this.scrollTop+=10" style="cursor:pointer;border:1px solid black;width:100px;height:80px;overflow:auto">Click<br>Me<br>1<br>2<br>3<br>4<br>5<br>6<br>7<br>8<br>9</div>
 ```
@@ -229,7 +227,7 @@ let elem = document.body;
 alert( getComputedStyle(elem).width ); // show CSS width for elem
 ```
 
-Why we should use geometry properties instead? There are two reasons:
+Why should we use geometry properties instead? There are two reasons:
 
 1. First, CSS width/height depend on another property: `box-sizing` that defines "what is" CSS width and height. A change in `box-sizing` for CSS purposes may break such JavaScript.
 2. Second, CSS `width/height` may be `auto`, for instance for an inline element:
@@ -260,7 +258,7 @@ The element with text has CSS `width:300px`.
 On a Desktop Windows OS, Firefox, Chrome, Edge all reserve the space for the scrollbar. But  Firefox shows `300px`, while Chrome and Edge show less. That's because Firefox returns the CSS width and other browsers return the "real" width.
 ```
 
-Please note that the described difference are only about reading `getComputedStyle(...).width` from JavaScript, visually everything is correct.
+Please note that the described difference is only about reading `getComputedStyle(...).width` from JavaScript, visually everything is correct.
 
 ## Summary
 
@@ -271,7 +269,7 @@ Elements have the following geometry properties:
 - `offsetWidth/offsetHeight` -- "outer" width/height of an element including borders.
 - `clientLeft/clientTop` -- the distance from the left-upper outer corner to its left-upper inner corner. For left-to-right OS they are always the widths of left/top borders. For right-to-left OS the vertical scrollbar is on the left so `clientLeft` includes its width too.
 - `clientWidth/clientHeight` -- the width/height of the content including paddings, but without the scrollbar.
-- `scrollWidth/scrollHeight` -- the width/height of the content including the scrolled out part. Also includes paddings, but not the scrollbar.
+- `scrollWidth/scrollHeight` -- the width/height of the content including the scrolled out parts. Also includes paddings, but not the scrollbar.
 - `scrollLeft/scrollTop` -- width/height of the scrolled out part of the element, starting from its left-upper corner.
 
 All properties are read-only except `scrollLeft/scrollTop`. They make the browser scroll the element if changed.
diff --git a/2-ui/1-document/09-size-and-scroll/metric-offset-parent.png b/2-ui/1-document/09-size-and-scroll/metric-offset-parent.png
index 5f1e58f9..01d2d000 100644
Binary files a/2-ui/1-document/09-size-and-scroll/metric-offset-parent.png and b/2-ui/1-document/09-size-and-scroll/metric-offset-parent.png differ
diff --git a/2-ui/1-document/09-size-and-scroll/metric-offset-parent@2x.png b/2-ui/1-document/09-size-and-scroll/metric-offset-parent@2x.png
index af62ebdc..125a91e1 100644
Binary files a/2-ui/1-document/09-size-and-scroll/metric-offset-parent@2x.png and b/2-ui/1-document/09-size-and-scroll/metric-offset-parent@2x.png differ
diff --git a/2-ui/1-document/10-size-and-scroll-window/article.md b/2-ui/1-document/10-size-and-scroll-window/article.md
index 0825b752..4a62f56c 100644
--- a/2-ui/1-document/10-size-and-scroll-window/article.md
+++ b/2-ui/1-document/10-size-and-scroll-window/article.md
@@ -4,8 +4,6 @@ How to find out the width of the browser window? How to get the full height of t
 
 From the DOM point of view, the root document element is `document.documentElement`. That element corresponds to `<html>` and has geometry properties described in the [previous chapter](info:size-and-scroll). For some cases we can use it, but there are additional methods and peculiarities important enough to consider.
 
-[cut]
-
 ## Width/height of the window
 
 Properties `clientWidth/clientHeight` of `document.documentElement` is exactly what we want here:
@@ -55,7 +53,7 @@ let scrollHeight = Math.max(
   document.body.clientHeight, document.documentElement.clientHeight
 );
 
-alert('Full document width, with scrolled out part: ' + scrollHeight);
+alert('Full document height, with scrolled out part: ' + scrollHeight);
 ```
 
 Why so? Better don't ask. These inconsistencies come from ancient times, not a "smart" logic.
diff --git a/2-ui/1-document/11-coordinates/article.md b/2-ui/1-document/11-coordinates/article.md
index 98758249..35ba15e1 100644
--- a/2-ui/1-document/11-coordinates/article.md
+++ b/2-ui/1-document/11-coordinates/article.md
@@ -9,8 +9,6 @@ Most JavaScript methods deal with one of two coordinate systems:
 
 It's important to understand the difference and which type is where.
 
-[cut]
-
 ## Window coordinates: getBoundingClientRect
 
 Window coordinates start at the left-upper corner of the window.
@@ -57,7 +55,7 @@ If we compare window coordinates versus CSS positioning, then there are obvious
 
 But in CSS the `right` property means the distance from the right edge, and the `bottom` -- from the bottom edge.
 
-If we just look at the picture below, we can see that in JavaScript it is not so. All window coordinates are counted from the upper-left corner, including these ones.
+If we just look at the picture above, we can see that in JavaScript it is not so. All window coordinates are counted from the upper-left corner, including these ones.
 ```
 
 ## elementFromPoint(x, y) [#elementFromPoint]
diff --git a/2-ui/1-document/11-coordinates/head.html b/2-ui/1-document/11-coordinates/head.html
index efc6cd1c..0914f7f8 100644
--- a/2-ui/1-document/11-coordinates/head.html
+++ b/2-ui/1-document/11-coordinates/head.html
@@ -1,7 +1,11 @@
 <script>
 document.addEventListener('DOMContentLoaded', function() {
 
-  document.getElementById('coords-show-mark').onclick = function() {
+let elem = document.getElementById('coords-show-mark');
+
+// no elem in ebook mode
+if (elem) {
+  elem.onclick = function() {
     let elem = document.getElementById("coords-show-mark");
 
     function createMessageUnder(elem, text) {
@@ -21,6 +25,7 @@ document.addEventListener('DOMContentLoaded', function() {
     document.body.append(message);
     setTimeout(() => message.remove(), 5000);
   }
+}
 
 });
 
diff --git a/2-ui/2-events/01-introduction-browser-events/03-which-handlers-run/solution.md b/2-ui/2-events/01-introduction-browser-events/03-which-handlers-run/solution.md
index 2355e535..d569f0e4 100644
--- a/2-ui/2-events/01-introduction-browser-events/03-which-handlers-run/solution.md
+++ b/2-ui/2-events/01-introduction-browser-events/03-which-handlers-run/solution.md
@@ -13,4 +13,4 @@ button.addEventListener("click", handler);
 button.removeEventListener("click", handler);
 ```
 
-The handler `button.onclick` works independantly and in addition to `addEventListener`.
+The handler `button.onclick` works independently and in addition to `addEventListener`.
diff --git a/2-ui/2-events/01-introduction-browser-events/04-move-ball-field/move-ball-coords.png b/2-ui/2-events/01-introduction-browser-events/04-move-ball-field/move-ball-coords.png
index 871acdc7..ca2f49ed 100644
Binary files a/2-ui/2-events/01-introduction-browser-events/04-move-ball-field/move-ball-coords.png and b/2-ui/2-events/01-introduction-browser-events/04-move-ball-field/move-ball-coords.png differ
diff --git a/2-ui/2-events/01-introduction-browser-events/04-move-ball-field/move-ball-coords@2x.png b/2-ui/2-events/01-introduction-browser-events/04-move-ball-field/move-ball-coords@2x.png
index 923bfc82..b4c4d3ef 100644
Binary files a/2-ui/2-events/01-introduction-browser-events/04-move-ball-field/move-ball-coords@2x.png and b/2-ui/2-events/01-introduction-browser-events/04-move-ball-field/move-ball-coords@2x.png differ
diff --git a/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel1.png b/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel1.png
index 22a8ab6b..b58ac0a6 100644
Binary files a/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel1.png and b/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel1.png differ
diff --git a/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel1@2x.png b/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel1@2x.png
index 9d2ff7e5..fe6a0bad 100644
Binary files a/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel1@2x.png and b/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel1@2x.png differ
diff --git a/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel2.png b/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel2.png
index bb2c6219..351ead9c 100644
Binary files a/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel2.png and b/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel2.png differ
diff --git a/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel2@2x.png b/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel2@2x.png
index 37aa58cc..05dbc1ad 100644
Binary files a/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel2@2x.png and b/2-ui/2-events/01-introduction-browser-events/07-carousel/carousel2@2x.png differ
diff --git a/2-ui/2-events/01-introduction-browser-events/article.md b/2-ui/2-events/01-introduction-browser-events/article.md
index e5a0915a..423c41c6 100644
--- a/2-ui/2-events/01-introduction-browser-events/article.md
+++ b/2-ui/2-events/01-introduction-browser-events/article.md
@@ -2,8 +2,6 @@
 
 *An event* is a signal that something has happened. All DOM nodes generate such signals (but events are not limited to DOM).
 
-[cut]
-
 Here's a list of the most useful DOM events, just to take a look at:
 
 **Mouse events:**
diff --git a/2-ui/2-events/02-bubbling-and-capturing/article.md b/2-ui/2-events/02-bubbling-and-capturing/article.md
index 6e39eae2..bc5d70dc 100644
--- a/2-ui/2-events/02-bubbling-and-capturing/article.md
+++ b/2-ui/2-events/02-bubbling-and-capturing/article.md
@@ -5,7 +5,7 @@ Let's start with an example.
 This handler is assigned to `<div>`, but also runs if you click any nested tag like `<em>` or `<code>`:
 
 ```html autorun height=60
-<div onclick="alert('The handler !')">
+<div onclick="alert('The handler!')">
   <em>If you click on <code>EM</code>, the handler on <code>DIV</code> runs.</em>
 </div>
 ```
@@ -50,7 +50,7 @@ The process is called "bubbling", because events "bubble" from the inner element
 ```warn header="*Almost* all events bubble."
 The key word in this phrase is "almost".
 
-For instance, a `focus` event does not bubble. There are other examples too, we'll meet them. But still it's an exception, rather then a rule, most events do bubble.
+For instance, a `focus` event does not bubble. There are other examples too, we'll meet them. But still it's an exception, rather than a rule, most events do bubble.
 ```
 
 ## event.target
@@ -145,7 +145,7 @@ There are two possible values for that optional last argument:
 
 Note that while formally there are 3 phases, the 2nd phase ("target phase": the event reached the element) is not handled separately: handlers on both capturing and bubbling phases trigger at that phase.
 
-If one puts a handler on the target element -- it triggers last on the capturing state, and first on the bubbling stage.
+If one puts capturing and bubbling handlers on the target element, the capture handler triggers last in the capturing phase and the bubble handler triggers first in the bubbling phase.
 
 Let's see it in action:
 
diff --git a/2-ui/2-events/02-bubbling-and-capturing/bubble-target.view/script.js b/2-ui/2-events/02-bubbling-and-capturing/bubble-target.view/script.js
index d3959a68..b1353712 100644
--- a/2-ui/2-events/02-bubbling-and-capturing/bubble-target.view/script.js
+++ b/2-ui/2-events/02-bubbling-and-capturing/bubble-target.view/script.js
@@ -2,7 +2,9 @@
 form.onclick = function(event) {
   event.target.style.backgroundColor = 'yellow';
 
-  alert("target = " + event.target.tagName + ", this=" + this.tagName);
-
-  event.target.style.backgroundColor = '';
+  // chrome needs some time to paint yellow
+  setTimeout(() => {
+    alert("target = " + event.target.tagName + ", this=" + this.tagName);
+    event.target.style.backgroundColor = ''
+  }, 0);
 };
diff --git a/2-ui/2-events/03-event-delegation/article.md b/2-ui/2-events/03-event-delegation/article.md
index 16d9dc71..83b4b6ce 100644
--- a/2-ui/2-events/03-event-delegation/article.md
+++ b/2-ui/2-events/03-event-delegation/article.md
@@ -1,7 +1,7 @@
 
 # Event delegation
 
-Capturing and bubbling allow to implement one of most powerful event handling patterns called *event delegation*.
+Capturing and bubbling allow us to implement one of most powerful event handling patterns called *event delegation*.
 
 The idea is that if we have a lot of elements handled in a similar way, then instead of assigning a handler to each of them -- we put a single handler on their common ancestor.
 
diff --git a/2-ui/2-events/04-default-browser-action/article.md b/2-ui/2-events/04-default-browser-action/article.md
index 652253e1..2e338dc5 100644
--- a/2-ui/2-events/04-default-browser-action/article.md
+++ b/2-ui/2-events/04-default-browser-action/article.md
@@ -10,8 +10,6 @@ For instance:
 
 If we handle an event in JavaScript, often we don't want browser actions. Fortunately, it can be prevented.
 
-[cut]
-
 ## Preventing browser actions
 
 There are two ways to tell the browser we don't want it to act:
diff --git a/2-ui/2-events/05-dispatch-events/article.md b/2-ui/2-events/05-dispatch-events/article.md
index 28fd78ab..f6ac9f22 100644
--- a/2-ui/2-events/05-dispatch-events/article.md
+++ b/2-ui/2-events/05-dispatch-events/article.md
@@ -6,8 +6,6 @@ Custom events can be used to create "graphical components". For instance, a root
 
 Also we can generate built-in events like `click`, `mousedown` etc, that may be good for testing.
 
-[cut]
-
 ## Event constructor
 
 Events form a hierarchy, just like DOM element classes. The root is the built-in [Event](http://www.w3.org/TR/dom/#event) class.
diff --git a/2-ui/3-event-details/1-mouse-events-basics/article.md b/2-ui/3-event-details/1-mouse-events-basics/article.md
index fd1c6322..668b7ad9 100644
--- a/2-ui/3-event-details/1-mouse-events-basics/article.md
+++ b/2-ui/3-event-details/1-mouse-events-basics/article.md
@@ -1,8 +1,8 @@
 # Mouse events basics
 
-In this chapter we'll get into more details about mouse events and their properties.
+Mouse events come not only from "mouse manipulators", but are also emulated on touch devices, to make them compatible.
 
-[cut]
+In this chapter we'll get into more details about mouse events and their properties.
 
 ## Mouse event types
 
@@ -26,7 +26,7 @@ The most used simple events are:
 ### Complex events
 
 `click`
-: Triggers after `mousedown` and then `mouseup` over the same element.
+: Triggers after `mousedown` and then `mouseup` over the same element if the left mouse button was used.
 
 `contextmenu`
 : Triggers after `mousedown` if the right mouse button was used.
@@ -36,8 +36,6 @@ The most used simple events are:
 
 Complex events are made of simple ones, so in theory we could live without them. But they exist, and that's good, because they are convenient.
 
-For touchscreen and touchpad devices mouse events also happen, they are emulated.
-
 ### Events order
 
 An action may trigger multiple events.
@@ -58,7 +56,7 @@ Also we can see the `which` property that allows to detect the mouse button.
 
 ## Getting the button: which
 
-Click-related events always have the `which` property that allows to get the button.
+Click-related events always have the `which` property, which allows to get the exact mouse button.
 
 It is not used for `click` and `contextmenu` events, because the former happens only on left-click, and the latter -- only on right-click.
 
@@ -177,7 +175,7 @@ Now if you double-click on "Unselectable", it doesn't get selected. Seems to wor
 
 ...But there is a potential problem! The text became truly unselectable. Even if a user starts the selection from "Before" and ends with "After", the selection skips "Unselectable" part. Do we really want to make our text unselectable?
 
-Most of time, we don't. A user may have valid reasons to select the text, for copying or other needs. That may be disturbing if we don't allow him to do it. So the solution is not that good.
+Most of time, we don't. A user may have valid reasons to select the text, for copying or other needs. That may be inconvenient if we don't allow him to do it. So this solution is not that good.
 
 What we want is to prevent the selection on double-click, that's it.
 
@@ -193,7 +191,7 @@ Before...
 
 Now the bold element is not selected on double clicks.
 
-From the other hand, the text inside it is still selectable. The selection should start not on the text itself, but before or after it. Usually that's fine.
+The text inside it is still selectable. However, the selection should start not on the text itself, but before or after it. Usually that's fine though.
 
 ````smart header="Canceling the selection"
 Instead of *preventing* the selection, we can cancel it "post-factum" in the event handler.
@@ -228,18 +226,18 @@ Surely that can't stop the user from opening HTML-source, but not everyone knows
 
 ## Summary
 
-Mouse events have following properties:
+Mouse events have the following properties:
 
 - Button: `which`.
 - Modifier keys (`true` if pressed): `altKey`, `ctrlKey`, `shiftKey` and `metaKey` (Mac).
   - If you want to handle `key:Ctrl`, then don't forget Mac users, they use `key:Cmd`, so it's better to check `if (e.metaKey || e.ctrlKey)`.
 
 - Window-relative coordinates: `clientX/clientY`.
-- Document-relative coordinates: `pageX/clientX`.
+- Document-relative coordinates: `pageX/pageY`.
 
-In the tasks below it's also important to deal with the selection as an unwanted side-effect of clicks.
+It's also important to deal with text selection as an unwanted side-effect of clicks.
 
-There are several ways, for instance:
-1. CSS-property `user-select:none` (with browser prefixes) completely disables it.
+There are several ways to do this, for instance:
+1. The CSS-property `user-select:none` (with browser prefixes) completely disables text-selection.
 2. Cancel the selection post-factum using `getSelection().removeAllRanges()`.
 3. Handle `mousedown` and prevent the default action (usually the best).
diff --git a/2-ui/3-event-details/10-onload-ondomcontentloaded/article.md b/2-ui/3-event-details/10-onload-ondomcontentloaded/article.md
index 277b70ef..4bf6eaa7 100644
--- a/2-ui/3-event-details/10-onload-ondomcontentloaded/article.md
+++ b/2-ui/3-event-details/10-onload-ondomcontentloaded/article.md
@@ -14,8 +14,6 @@ Each event may be useful:
 
 Let's explore the details of these events.
 
-[cut]
-
 ## DOMContentLoaded
 
 The `DOMContentLoaded` event happens on the `document` object.
@@ -128,28 +126,24 @@ For that we should use another event -- `onbeforeunload`.
 
 ## window.onbeforeunload [#window.onbeforeunload]
 
-If a visitor initiated leaving the page or tries to close the window, the `beforeunload` handler can ask for additional confirmation.
+If a visitor initiated navigation away from the page or tries to close the window, the `beforeunload` handler asks for additional confirmation.
 
-It needs to return the string with the question. The browser will show it.
+It may return a string with the question. Historically browsers used to show it, but as of now only some of them do. That's because certain webmasters abused this event handler by showing misleading and hackish messages.
 
-For instance:
+You can try it by running this code and then reloading the page.
 
-```js
+```js run
 window.onbeforeunload = function() {
   return "There are unsaved changes. Leave now?";
 };
 ```
 
 ```online
-Click on the button in `<iframe>` below to set the handler, and then click the link to see it in action:
+Or you can click on the button in `<iframe>` below to set the handler, and then click the link:
 
 [iframe src="window-onbeforeunload" border="1" height="80" link edit]
 ```
 
-```warn header="Some browsers ignore the text and show their own message instead"
-Some browsers like Chrome and Firefox ignore the string and shows its own message instead. That's for sheer safety, to protect the user from potentially misleading and hackish messages.
-```
-
 ## readyState
 
 What happens if we set the `DOMContentLoaded` handler after the document is loaded?
diff --git a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/2-hoverintent/task.md b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/2-hoverintent/task.md
index 5c1846a9..5eedf0e6 100644
--- a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/2-hoverintent/task.md
+++ b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/2-hoverintent/task.md
@@ -44,4 +44,4 @@ The demo:
 
 If you move the mouse over the "clock" fast then nothing happens, and if you do it slow or stop on them, then there will be a tooltip.
 
-Please note: the tooltip doesn't "blink" when the cursor between the clock subelements.
+Please note: the tooltip doesn't "blink" when the cursor moves between the clock subelements.
diff --git a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/article.md b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/article.md
index 73ac58da..25b92181 100644
--- a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/article.md
+++ b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/article.md
@@ -2,8 +2,6 @@
 
 Let's dive into more details about events that happen when mouse moves between elements.
 
-[cut]
-
 ## Mouseover/mouseout, relatedTarget
 
 The `mouseover` event occurs when a mouse pointer comes over an element, and `mouseout` -- when it leaves.
diff --git a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout.png b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout.png
index 628aa330..cf9fa448 100644
Binary files a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout.png and b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout.png differ
diff --git a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout@2x.png b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout@2x.png
index c320e2cc..a2749d68 100644
Binary files a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout@2x.png and b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/mouseover-mouseout@2x.png differ
diff --git a/2-ui/3-event-details/5-keyboard-events/article.md b/2-ui/3-event-details/5-keyboard-events/article.md
index 445379b0..5430606e 100644
--- a/2-ui/3-event-details/5-keyboard-events/article.md
+++ b/2-ui/3-event-details/5-keyboard-events/article.md
@@ -6,8 +6,6 @@ So if we want to track any input into an `<input>` field, then keyboard events a
 
 Keyboard events should be used when we want to handle keyboard actions (virtual keyboard also counts). For instance, to react on arrow keys `key:Up` and `key:Down` or hotkeys (including combinations of keys).
 
-[cut]
-
 
 ## Teststand [#keyboard-test-stand]
 
diff --git a/2-ui/3-event-details/8-onscroll/1-endless-page/solution.md b/2-ui/3-event-details/8-onscroll/1-endless-page/solution.md
index a3f21b57..f7412bd4 100644
--- a/2-ui/3-event-details/8-onscroll/1-endless-page/solution.md
+++ b/2-ui/3-event-details/8-onscroll/1-endless-page/solution.md
@@ -18,7 +18,7 @@ For instance, if the height of the whole HTML document is 2000px, then:
 document.documentElement.getBoundingClientRect().top = 0
 
 // window-relative bottom = 2000
-// the document is long, so that is probably far beyound the window bottom
+// the document is long, so that is probably far beyond the window bottom
 document.documentElement.getBoundingClientRect().bottom = 2000
 ```
 
diff --git a/2-ui/3-event-details/8-onscroll/1-endless-page/task.md b/2-ui/3-event-details/8-onscroll/1-endless-page/task.md
index 4b49070b..7c8d14fc 100644
--- a/2-ui/3-event-details/8-onscroll/1-endless-page/task.md
+++ b/2-ui/3-event-details/8-onscroll/1-endless-page/task.md
@@ -12,7 +12,7 @@ Like this:
 
 Please note two important features of the scroll:
 
-1. **The scroll is "elastic".** We can scroll a little beyound the document start or end in some browsers/devices (empty space below is shown, and then the document will automatically "bounces back" to normal).
+1. **The scroll is "elastic".** We can scroll a little beyond the document start or end in some browsers/devices (empty space below is shown, and then the document will automatically "bounces back" to normal).
 2. **The scroll is imprecise.** When we scroll to page end, then we may be in fact like 0-50px away from the real document bottom.
 
 So, "scrolling to the end" should mean that the visitor is no more than 100px away from the document end.
diff --git a/2-ui/3-event-details/8-onscroll/article.md b/2-ui/3-event-details/8-onscroll/article.md
index 4eefb793..1eb134f9 100644
--- a/2-ui/3-event-details/8-onscroll/article.md
+++ b/2-ui/3-event-details/8-onscroll/article.md
@@ -6,8 +6,6 @@ For instance:
 - Show/hide additional controls or information depending on where in the document the user is.
 - Load more data when the user scrolls down till the end of the page.
 
-[cut]
-
 Here's a small function to show the current scroll:
 
 ```js autorun
diff --git a/2-ui/4-forms-controls/1-form-elements/article.md b/2-ui/4-forms-controls/1-form-elements/article.md
index 2c20ddfd..1a4009bc 100644
--- a/2-ui/4-forms-controls/1-form-elements/article.md
+++ b/2-ui/4-forms-controls/1-form-elements/article.md
@@ -4,8 +4,6 @@ Forms and control elements, such as `<input>` have a lot of special properties a
 
 Working with forms can be much more convenient if we know them.
 
-[cut]
-
 ## Navigation: form and elements
 
 Document forms are members of the special collection `document.forms`.
diff --git a/2-ui/4-forms-controls/2-focus-blur/article.md b/2-ui/4-forms-controls/2-focus-blur/article.md
index d829fb36..3177ee39 100644
--- a/2-ui/4-forms-controls/2-focus-blur/article.md
+++ b/2-ui/4-forms-controls/2-focus-blur/article.md
@@ -4,17 +4,15 @@ An element receives a focus when the user either clicks on it or uses the `key:T
 
 Focusing generally means: "prepare to accept the data here", so that's the moment when we can run the code to initialize or load something.
 
-The moment of loosing the focus ("blur") can be even more important. That's when a user clicks somewhere else or presses `key:Tab` to go to the next form field, or there are other means as well.
+The moment of losing the focus ("blur") can be even more important. That's when a user clicks somewhere else or presses `key:Tab` to go to the next form field, or there are other means as well.
 
-Loosing the focus generally means: "the data has been entered", so we can run the code to check it or even to save it to the server and so on.
+Losing the focus generally means: "the data has been entered", so we can run the code to check it or even to save it to the server and so on.
 
 There are important peculiarities when working with focus events. We'll do the best to cover them here.
 
-[cut]
-
 ## Events focus/blur
 
-The `focus` event is called on focusing, and `blur` -- when the element looses the focus.
+The `focus` event is called on focusing, and `blur` -- when the element loses the focus.
 
 Let's use them for validation of an input field.
 
@@ -68,6 +66,7 @@ For instance, let's make the visitor unable to leave the input if the value is i
 </style>
 
 Your email please: <input type="email" id="input">
+<input type="text" style="width:220px" placeholder="make email invalid and try to focus here">
 
 <script>
   input.onblur = function() {
@@ -89,7 +88,7 @@ It works in all browsers except Firefox ([bug](https://bugzilla.mozilla.org/show
 
 If we enter something into the input and then try to use `key:Tab` or click away from the `<input>`, then `onblur` returns the focus back.
 
-Please note that we can't "prevent loosing focus" by calling `event.preventDefault()` in `onblur`, because `onblur` works *after* the element lost the focus.
+Please note that we can't "prevent losing focus" by calling `event.preventDefault()` in `onblur`, because `onblur` works *after* the element lost the focus.
 
 ```warn header="JavaScript-initiated focus loss"
 A focus loss can occur for many reasons.
@@ -213,7 +212,7 @@ So here's another working variant:
 
 ## Summary
 
-Events `focus` and `blur` trigger on focusing/loosing focus on the element.
+Events `focus` and `blur` trigger on focusing/losing focus on the element.
 
 Their specials are:
 - They do not bubble. Can use capturing state instead or `focusin/focusout`.
diff --git a/2-ui/4-forms-controls/3-events-change-input/article.md b/2-ui/4-forms-controls/3-events-change-input/article.md
index 81407dc7..2b46b083 100644
--- a/2-ui/4-forms-controls/3-events-change-input/article.md
+++ b/2-ui/4-forms-controls/3-events-change-input/article.md
@@ -76,4 +76,4 @@ Data change events:
 |---------|----------|-------------|
 | `change`| A value was changed. | For text inputs triggers on focus loss. |
 | `input` | For text inputs on every change. | Triggers immediately unlike `change`. |
-| `cut/copy/paste` | Cut/copy/paste actions. | The action can be prevented. The `event.clipbordData` property gives read/write access to the clipboard. |
+| `cut/copy/paste` | Cut/copy/paste actions. | The action can be prevented. The `event.clipboardData` property gives read/write access to the clipboard. |
diff --git a/2-ui/4-forms-controls/4-forms-submit/article.md b/2-ui/4-forms-controls/4-forms-submit/article.md
index 15647dfc..69d5a3dc 100644
--- a/2-ui/4-forms-controls/4-forms-submit/article.md
+++ b/2-ui/4-forms-controls/4-forms-submit/article.md
@@ -6,8 +6,6 @@ The method `form.submit()` allows to initiate form sending from JavaScript. We c
 
 Let's see more details of them.
 
-[cut]
-
 ## Event: submit
 
 There are two main ways to submit a form:
diff --git a/2-ui/index.md b/2-ui/index.md
index 5c4e1484..d94378cf 100644
--- a/2-ui/index.md
+++ b/2-ui/index.md
@@ -1,3 +1,3 @@
-# Browser: Document, DOM, Interfaces 
+# Browser: Document, Events, Interfaces 
 
 Learning how to manage the browser page: add elements, manipulate their size and position, dynamically create interfaces and interact with the visitor.
diff --git a/3-animation/1-bezier-curve/article.md b/3-animation/1-bezier-curve/article.md
index 4af01bb5..6166f25c 100644
--- a/3-animation/1-bezier-curve/article.md
+++ b/3-animation/1-bezier-curve/article.md
@@ -4,8 +4,6 @@ Bezier curves are used in computer graphics to draw shapes, for CSS animation an
 
 They are actually a very simple thing, worth to study once and then feel comfortable in the world of vector graphics and advanced animations.
 
-[cut]
-
 ## Control points
 
 A [bezier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve) is defined by control points.
@@ -28,14 +26,14 @@ If you look closely at these curves, you can immediately notice:
 
 1. **Points are not always on curve.** That's perfectly normal, later we'll see how the curve is built.
 2. **The curve order equals the number of points minus one**.
-For two points we have a linear curve (that's a straight line), for three points -- quadratic curve (parabolic), for three points -- cubic curve.
+For two points we have a linear curve (that's a straight line), for three points -- quadratic curve (parabolic), for four points -- cubic curve.
 3. **A curve is always inside the [convex hull](https://en.wikipedia.org/wiki/Convex_hull) of control points:**
 
     ![](bezier4-e.png) ![](bezier3-e.png)
 
 Because of that last property, in computer graphics it's possible to optimize intersection tests. If convex hulls do not intersect, then curves do not either. So checking for the convex hulls intersection first can give a very fast "no intersection" result. Checking the intersection or convex hulls is much easier, because they are rectangles, triangles and so on (see the picture above), much simpler figures than the curve.
 
-The main value of Bezier curves for drawing -- by moving the points the curve is changing *in intuitively obvious way*.
+**The main value of Bezier curves for drawing -- by moving the points the curve is changing *in intuitively obvious way*.**
 
 Try to move control points using a mouse in the example below:
 
@@ -49,53 +47,16 @@ Here are some examples:
 
 ![](bezier-car.png) ![](bezier-letter.png) ![](bezier-vase.png)
 
-## Maths
-
-A Bezier curve can be described using a mathematical formula.
-
-As we'll see soon -- there's no need to know it. But for completeness -- here it is.
-
-Given the coordinates of control points <code>P<sub>i</sub></code>: the first control point has coordinates <code>P<sub>1</sub> = (x<sub>1</sub>, y<sub>1</sub>)</code>, the second: <code>P<sub>2</sub> = (x<sub>2</sub>, y<sub>2</sub>)</code>, and so on, the curve coordinates are described by the equation that depends on the parameter `t` from the segment `[0,1]`.
-
-- The formula for a 2-points curve:
-
-    <code>P = (1-t)P<sub>1</sub> + tP<sub>2</sub></code>
-- For three points:
-
-    <code>P = (1−t)<sup>2</sup>P<sub>1</sub> + 2(1−t)tP<sub>2</sub> + t<sup>2</sup>P<sub>3</sub></code>
-- For four points:
-
-    <code>P = (1−t)<sup>3</sup>P<sub>1</sub> + 3(1−t)<sup>2</sup>tP<sub>2</sub>  +3(1−t)t<sup>2</sup>P<sub>3</sub> + t<sup>3</sup>P<sub>4</sub></code>
-
-These are vector equations.
-
-We can rewrite them coordinate-by-coordinate, for instance the 3-point curve:
-
-- <code>x = (1−t)<sup>2</sup>x<sub>1</sub> + 2(1−t)tx<sub>2</sub> + t<sup>2</sup>x<sub>3</sub></code>
-- <code>y = (1−t)<sup>2</sup>y<sub>1</sub> + 2(1−t)ty<sub>2</sub> + t<sup>2</sup>y<sub>3</sub></code>
-
-Instead of <code>x<sub>1</sub>, y<sub>1</sub>, x<sub>2</sub>, y<sub>2</sub>, x<sub>3</sub>, y<sub>3</sub></code> we should put coordinates of 3 control points.
-
-For instance, if control points are  `(0,0)`, `(0.5, 1)` and `(1, 0)`, the equations are:
-
-- <code>x = (1−t)<sup>2</sup> * 0 + 2(1−t)t * 0.5 + t<sup>2</sup> * 1 = (1-t)t + t<sup>2</sup> = t</code>
-- <code>y = (1−t)<sup>2</sup> * 0 + 2(1−t)t * 1 + t<sup>2</sup> * 0 = 2(1-t)t = –t<sup>2</sup> + 2t</code>
-
-Now as `t` runs from `0` to `1`, the set of values `(x,y)` for each `t` forms the curve.
-
-That's probably too scientific, not very obvious why curves look like that, and how they depend on control points.
-
-So here's the drawing algorithm that may be easier to understand.
-
 ## De Casteljau's algorithm
 
-[De Casteljau's algorithm](https://en.wikipedia.org/wiki/De_Casteljau%27s_algorithm) is identical to the mathematical definition of the curve, but visually shows how it is built.
+There's a mathematical formula for Bezier curves, but let's cover it a bit later, because
+[De Casteljau's algorithm](https://en.wikipedia.org/wiki/De_Casteljau%27s_algorithm) it is identical to the mathematical definition and visually shows how it is constructed.
 
-Let's see it on the 3-points example.
+First let's see the 3-points example.
 
 Here's the demo, and the explanation follow.
 
-Points can be moved by the mouse. Press the "play" button to run it.
+Control points (1,2 and 3) can be moved by the mouse. Press the "play" button to run it.
 
 [iframe src="demo.svg?p=0,0,0.5,1,1,0&animate=1" height=370]
 
@@ -118,19 +79,19 @@ Points can be moved by the mouse. Press the "play" button to run it.
 | ------------------------ | ---------------------- |
 | ![](bezier3-draw1.png)   | ![](bezier3-draw2.png) |
 
-4. Now the <span style="color:#167490">blue</span> segment take a point on the distance proportional to the same value of `t`. That is, for `t=0.25` (the left picture) we have a point at the end of the left quarter of the segment, and for `t=0.5` (the right picture) -- in the middle of the segment. On pictures above that point is <span style="color:red">red</span>.
+4. Now in the <span style="color:#167490">blue</span> segment take a point on the distance proportional to the same value of `t`. That is, for `t=0.25` (the left picture) we have a point at the end of the left quarter of the segment, and for `t=0.5` (the right picture) -- in the middle of the segment. On pictures above that point is <span style="color:red">red</span>.
 
 5. As `t` runs from `0` to `1`, every value of `t` adds a point to the curve. The set of such points forms the Bezier curve. It's red and parabolic on the pictures above.
 
 That was a process for 3 points. But the same is for 4 points.
 
-The demo for 4 points (points can be moved by mouse):
+The demo for 4 points (points can be moved by a mouse):
 
 [iframe src="demo.svg?p=0,0,0.5,0,0.5,1,1,1&animate=1" height=370]
 
-The algorithm:
+The algorithm for 4 points:
 
-- Control points are connected by segments: 1 -> 2, 2 -> 3, 3 -> 4. We have 3 <span style="color:#825E28">brown</span> segments.
+- Connect control points by segments: 1 -> 2, 2 -> 3, 3 -> 4. There will be 3 <span style="color:#825E28">brown</span> segments.
 - For each `t` in the interval from `0` to `1`:
     - We take points on these segments on the distance proportional to `t` from the beginning. These points are connected, so that we have two <span style="color:#0A0">green segments</span>.
     - On these segments we take points proportional to `t`. We get one <span style="color:#167490">blue segment</span>.
@@ -139,41 +100,86 @@ The algorithm:
 
 The algorithm is recursive and can be generalized for any number of control points.
 
-Given N of control points, we connect them to get initially N-1 segments.
+Given N of control points:
 
-Then for each `t` from `0` to `1`:
-- Take a point on each of segment on the distance proportional to `t` and connect them -- there will be N-2 segments.
-- Take a point on each of these segments on the distance proportional to `t` and connect -- there will be N-3 segments, and so on...
-- Till we have one point. These points make the curve.
+1. We connect them to get initially N-1 segments.
+2. Then for each `t` from `0` to `1`, we take a point on each segment on the distance proportional to `t` and connect them. There will be N-2 segments.
+3. Repeat step 2 until there is only one point.
 
-Move examples of curves:
+These points make the curve.
+
+```online
+**Run and pause examples to clearly see the segments and how the curve is built.**
+```
+
+
+A curve that looks like `y=1/t`:
 
 [iframe src="demo.svg?p=0,0,0,0.75,0.25,1,1,1&animate=1" height=370]
 
-With other points:
+Zig-zag control points also work fine:
 
 [iframe src="demo.svg?p=0,0,1,0.5,0,0.5,1,1&animate=1" height=370]
 
-Loop form:
+Making a loop is possible:
 
 [iframe src="demo.svg?p=0,0,1,0.5,0,1,0.5,0&animate=1" height=370]
 
-Not smooth Bezier curve:
+A non-smooth Bezier curve (yeah, that's possible too):
 
 [iframe src="demo.svg?p=0,0,1,1,0,1,1,0&animate=1" height=370]
 
-As the algorithm is recursive, we can build Bezier curves of any order: using 5, 6 or more control points. But in practice they are less useful. Usually we take 2-3 points, and for complex lines glue several curves together. That's simpler to develop and calculate.
+```online
+If there's anything unclear in the algorithm description, then live examples above show how
+the curve is built.
+```
+
+As the algorithm is recursive, we can build Bezier curves of any order, that is: using 5, 6 or more control points. But in practice many points are less useful. Usually we take 2-3 points, and for complex lines glue several curves together. That's simpler to develop and calculate.
 
 ```smart header="How to draw a curve *through* given points?"
-We use control points for a Bezier curve. As we can see, they are not on the curve. Or, to be precise, the first and the last ones do belong to curve, but others don't.
+We use control points for a Bezier curve. As we can see, they are not on the curve, except the first and the last ones.
 
 Sometimes we have another task: to draw a curve *through several points*, so that all of them are on a single smooth curve. That task is called  [interpolation](https://en.wikipedia.org/wiki/Interpolation), and here we don't cover it.
 
-There are mathematical formulas for such curves, for instance [Lagrange polynomial](https://en.wikipedia.org/wiki/Lagrange_polynomial).
-
-In computer graphics [spline interpolation](https://en.wikipedia.org/wiki/Spline_interpolation) is often used to build smooth curves that connect many points.
+There are mathematical formulas for such curves, for instance [Lagrange polynomial](https://en.wikipedia.org/wiki/Lagrange_polynomial). In computer graphics [spline interpolation](https://en.wikipedia.org/wiki/Spline_interpolation) is often used to build smooth curves that connect many points.
 ```
 
+
+## Maths
+
+A Bezier curve can be described using a mathematical formula.
+
+As we saw -- there's actually no need to know it, most people just draw the curve by moving points with a mouse. But if you're into maths -- here it is.
+
+Given the coordinates of control points <code>P<sub>i</sub></code>: the first control point has coordinates <code>P<sub>1</sub> = (x<sub>1</sub>, y<sub>1</sub>)</code>, the second: <code>P<sub>2</sub> = (x<sub>2</sub>, y<sub>2</sub>)</code>, and so on, the curve coordinates are described by the equation that depends on the parameter `t` from the segment `[0,1]`.
+
+- The formula for a 2-points curve:
+
+    <code>P = (1-t)P<sub>1</sub> + tP<sub>2</sub></code>
+- For 3 control points:
+
+    <code>P = (1−t)<sup>2</sup>P<sub>1</sub> + 2(1−t)tP<sub>2</sub> + t<sup>2</sup>P<sub>3</sub></code>
+- For 4 control points:
+
+    <code>P = (1−t)<sup>3</sup>P<sub>1</sub> + 3(1−t)<sup>2</sup>tP<sub>2</sub>  +3(1−t)t<sup>2</sup>P<sub>3</sub> + t<sup>3</sup>P<sub>4</sub></code>
+
+
+These are vector equations. In other words, we can put `x` and `y` instead of `P` to get corresponding coordinates.
+
+For instance, the 3-point curve is formed by points `(x,y)` calculated as:
+
+- <code>x = (1−t)<sup>2</sup>x<sub>1</sub> + 2(1−t)tx<sub>2</sub> + t<sup>2</sup>x<sub>3</sub></code>
+- <code>y = (1−t)<sup>2</sup>y<sub>1</sub> + 2(1−t)ty<sub>2</sub> + t<sup>2</sup>y<sub>3</sub></code>
+
+Instead of <code>x<sub>1</sub>, y<sub>1</sub>, x<sub>2</sub>, y<sub>2</sub>, x<sub>3</sub>, y<sub>3</sub></code> we should put coordinates of 3 control points, and then as `t` moves from `0` to `1`, for each value of `t` we'll have `(x,y)` of the curve.
+
+For instance, if control points are  `(0,0)`, `(0.5, 1)` and `(1, 0)`, the equations become:
+
+- <code>x = (1−t)<sup>2</sup> * 0 + 2(1−t)t * 0.5 + t<sup>2</sup> * 1 = (1-t)t + t<sup>2</sup> = t</code>
+- <code>y = (1−t)<sup>2</sup> * 0 + 2(1−t)t * 1 + t<sup>2</sup> * 0 = 2(1-t)t = –t<sup>2</sup> + 2t</code>
+
+Now as `t` runs from `0` to `1`, the set of values `(x,y)` for each `t` forms the curve for such control points.
+
 ## Summary
 
 Bezier curves are defined by their control points.
diff --git a/3-animation/2-css-animations/article.md b/3-animation/2-css-animations/article.md
index 998a8c22..1189ab95 100644
--- a/3-animation/2-css-animations/article.md
+++ b/3-animation/2-css-animations/article.md
@@ -4,8 +4,6 @@ CSS animations allow to do simple animations without JavaScript at all.
 
 JavaScript can be used to control CSS animation and make them even better with a little of code.
 
-[cut]
-
 ## CSS transitions [#css-transition]
 
 The idea of CSS transitions is simple. We describe a property and how its changes should be animated. When the property changes, the browser paints the animation.
@@ -42,7 +40,7 @@ Click the button below to animate the background:
 </script>
 ```
 
-There are 5 properties to describe CSS transitions:
+There are 4 properties to describe CSS transitions:
 
 - `transition-property`
 - `transition-duration`
@@ -262,9 +260,15 @@ But how to make the Bezier curve for a specific task? There are many tools. For
 
 Timing function `steps(number of steps[, start/end])` allows to split animation into steps.
 
-Let's see that in an example with digits. We'll make the digits change not in a smooth, but in a discrete way.
+Let's see that in an example with digits.
 
-For that we split the animation into 9 steps:
+Here's a list of digits, without any animations, just as a source:
+
+[codetabs src="step-list"]
+
+We'll make the digits appear in a discrete way by making the part of the list outside of the red "window" invisible and shifting the list to the left with each step.
+
+There will be 9 steps, a step-move for each digit:
 
 ```css
 #stripe.animate  {
@@ -273,11 +277,11 @@ For that we split the animation into 9 steps:
 }
 ```
 
-In action `step(9, start)`:
+In action:
 
 [codetabs src="step"]
 
-The first argument of `steps` is the number of steps. The transform will be split into 9 parts (10% each). The time interval is divided as well: 9 seconds split into 1 second intervals.
+The first argument of `steps(9, start)` is the number of steps. The transform will be split into 9 parts (10% each). The time interval is automatically divided into 9 parts as well, so `transition: 9s` gives us 9 seconds for the whole animation – 1 second per digit.
 
 The second argument is one of two words: `start` or `end`.
 
@@ -303,7 +307,7 @@ So the process would go like this:
 - ...
 - `9s` -- `-90%`
 
-In action `step(9, end)`:
+Here's `step(9, end)` in action (note the pause between the first digit change):
 
 [codetabs src="step-end"]
 
diff --git a/3-animation/2-css-animations/step-list.view/index.html b/3-animation/2-css-animations/step-list.view/index.html
new file mode 100644
index 00000000..d7931f5e
--- /dev/null
+++ b/3-animation/2-css-animations/step-list.view/index.html
@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+  <meta charset="utf-8">
+  <link rel="stylesheet" href="style.css">
+</head>
+
+<body>
+
+  <div id="digit"><div id="stripe">0123456789</div></div>
+
+</body>
+</html>
diff --git a/3-animation/2-css-animations/step-list.view/style.css b/3-animation/2-css-animations/step-list.view/style.css
new file mode 100644
index 00000000..a934e834
--- /dev/null
+++ b/3-animation/2-css-animations/step-list.view/style.css
@@ -0,0 +1,9 @@
+#digit {
+  border: 1px solid red;
+  width: 1.2em;
+}
+
+#stripe {
+  display: inline-block;
+  font: 32px monospace;
+}
diff --git a/3-animation/3-js-animation/article.md b/3-animation/3-js-animation/article.md
index 99775934..f0f258c3 100644
--- a/3-animation/3-js-animation/article.md
+++ b/3-animation/3-js-animation/article.md
@@ -4,22 +4,19 @@ JavaScript animations can handle things that CSS can't.
 
 For instance, moving along a complex path, with a timing function different from Bezier curves, or an animation on a canvas.
 
-[cut]
+## Using setInterval
 
-## setInterval
+An animation can be implemented as a sequence of frames -- usually small changes to HTML/CSS properties.
 
-From the HTML/CSS point of view, an animation is a gradual change of the style property. For instance, changing `style.left` from `0px` to `100px` moves the element.
-
-And if we increase it in `setInterval`, by making 50 small changes per second, then it looks smooth. That's the same principle as in the cinema: 24 or more frames per second is enough to make it look smooth.
+For instance, changing `style.left` from `0px` to `100px` moves the element. And if we increase it in `setInterval`, changing by `2px` with a tiny delay, like 50 times per second, then it looks smooth. That's the same principle as in the cinema: 24 or more frames per second is enough to make it look smooth.
 
 The pseudo-code can look like this:
 
 ```js
-let delay = 1000 / 50; // in 1 second 50 frames
 let timer = setInterval(function() {
   if (animation complete) clearInterval(timer);
-  else increase style.left
-}, delay)
+  else increase style.left by 2px
+}, 20); // change by 2px every 20ms, about 50 frames per second
 ```
 
 More complete example of the animation:
@@ -52,15 +49,13 @@ Click for the demo:
 
 [codetabs height=200 src="move"]
 
-## requestAnimationFrame
+## Using requestAnimationFrame
 
 Let's imagine we have several animations running simultaneously.
 
-If we run them separately, each one with its own `setInterval(..., 20)`, then the browser would have to repaint much more often than every `20ms`.
+If we run them separately, then even though each one has `setInterval(..., 20)`, then the browser would have to repaint much more often than every `20ms`.
 
-Each `setInterval` triggers once per `20ms`, but they are independent, so we have several independent runs within `20ms`.
-
-These several independent redraws should be grouped together, to make it easier for the browser.
+That's because they have different starting time, so "every 20ms" differs between different animations. The intervals are not alignned. So we'll have several independent runs within `20ms`.
 
 In other words, this:
 
@@ -72,19 +67,19 @@ setInterval(function() {
 }, 20)
 ```
 
-...Is lighter than this:
+...Is lighter than three independent calls:
 
 ```js
-setInterval(animate1, 20);
-setInterval(animate2, 20);
+setInterval(animate1, 20); // independent animations
+setInterval(animate2, 20); // in different places of the script
 setInterval(animate3, 20);
 ```
 
-There's one more thing to keep in mind. Sometimes when CPU is overloaded, or there are other reasons to  redraw less often. For instance, if the browser tab is hidden, then there's totally no point in drawing.
+These several independent redraws should be grouped together, to make the redraw easier for the browser (and hence smoother for people).
 
-There's a standard [Animation timing](http://www.w3.org/TR/animation-timing/) that provides the function `requestAnimationFrame`.
+There's one more thing to keep in mind. Sometimes when CPU is overloaded, or there are other reasons to redraw less often (like when the browser tab is hidden), so we really shouldn't run it every `20ms`.
 
-It addresses all these issues and even more.
+But how do we know about that in JavaScript? There's a specification [Animation timing](http://www.w3.org/TR/animation-timing/) that provides the function `requestAnimationFrame`. It addresses all these issues and even more.
 
 The syntax:
 ```js
@@ -418,7 +413,7 @@ Here's the animated "bouncing" text typing:
 
 ## Summary
 
-JavaScript animation should be implemented via `requestAnimationFrame`. That built-in method allows to setup a callback function to run when the browser will be preparing a repaint. Usually that's very soon, but the exact time depends on the browser.
+For animations that CSS can't handle well, or those that need tight control, JavaScript can help. JavaScript animations should be implemented via `requestAnimationFrame`. That built-in method allows to setup a callback function to run when the browser will be preparing a repaint. Usually that's very soon, but the exact time depends on the browser.
 
 When a page is in the background, there are no repaints at all, so the callback won't run: the animation will be suspended and won't consume resources. That's great.
 
diff --git a/4-frames-and-windows/01-popup-windows/article.md b/4-frames-and-windows/01-popup-windows/article.md
index a1839d6a..fa144f88 100644
--- a/4-frames-and-windows/01-popup-windows/article.md
+++ b/4-frames-and-windows/01-popup-windows/article.md
@@ -9,8 +9,6 @@ window.open('http://javascript.info/')
 
 ... And it will open a new window with given URL. Most modern browsers are configured to open new tabs instead of separate windows.
 
-[cut]
-
 ## Popup blocking
 
 Popups exist from really ancient times. The initial idea was to show another content without closing the main window. As of now, there are other ways to do that: JavaScript is able to send requests for server, so popups are rarely used. But sometimes they are still handy.
diff --git a/4-frames-and-windows/03-cross-window-communication/article.md b/4-frames-and-windows/03-cross-window-communication/article.md
index 15394969..d9b9247c 100644
--- a/4-frames-and-windows/03-cross-window-communication/article.md
+++ b/4-frames-and-windows/03-cross-window-communication/article.md
@@ -4,8 +4,6 @@ The "Same Origin" (same site) policy limits access of windows and frame to each
 
 The idea is that if we have two windows open: one from `john-smith.com`, and another one is `gmail.com`, then we wouldn't want a script from `john-smith.com` to read our mail.
 
-[cut]
-
 ## Same Origin [#same-origin]
 
 Two URLs are said to have the "same origin" if they have the same protocol, domain and port.
@@ -27,7 +25,7 @@ If we have a reference to another window (a popup or iframe), and that window co
 
 If it comes from another origin, then we can only change its location. Please note: not *read* the location, but *modify* it, redirect it to another place. That's safe, because the URL may contain sensitive parameters, so reading it from another origin is prohibited, but changing is not.
 
-Also such windows windows may exchange messages. Soon about that later.
+Also such windows may exchange messages. Soon about that later.
 
 ````warn header="Exclusion: subdomains may be same-origin"
 
diff --git a/4-frames-and-windows/06-clickjacking/article.md b/4-frames-and-windows/06-clickjacking/article.md
index 66b918e1..bcffc3fd 100644
--- a/4-frames-and-windows/06-clickjacking/article.md
+++ b/4-frames-and-windows/06-clickjacking/article.md
@@ -4,22 +4,20 @@ The "clickjacking" attack allows an evil page to click on a "victim site" *on be
 
 Many sites were hacked this way, including Twitter, Facebook, Paypal and other sites. They are all fixed, of course.
 
-[cut]
-
 ## The idea
 
 The idea is very simple.
 
 Here's how clickjacking was done with Facebook:
 
-1. A visitor is lured to the evil page. No matter how.
-2. The page has a harmlessly-looking link on it (like "get rich now" or "click here, very funny" and so on).
+1. A visitor is lured to the evil page. It doesn't matter how.
+2. The page has a harmless-looking link on it (like "get rich now" or "click here, very funny").
 3. Over that link the evil page positions a transparent `<iframe>` with `src` from facebook.com, in such a way that the "Like" button is right above that link. Usually that's done with `z-index`.
-4. Clicking on that link, the visitor in fact presses that button.
+4. In attempting to click the link, the visitor in fact clicks the button.
 
 ## The demo
 
-Here's how the evil page looks like. To make things clear, the `<iframe>` is half-transparent (in real evil pages it's fully transparent):
+Here's how the evil page looks. To make things clear, the `<iframe>` is half-transparent (in real evil pages it's fully transparent):
 
 ```html run height=120 no-beautify
 <style>
@@ -39,10 +37,10 @@ iframe { /* iframe from the victim site */
 
 <!-- The url from the victim site -->
 *!*
-<iframe src="facebook.html"></iframe>
+<iframe src="/clickjacking/facebook.html"></iframe>
 
 <button>Click here!</button>
- */!*
+*/!*
 
 <div>...And you're cool (I'm a cool hacker actually)!</div>
 ```
@@ -53,7 +51,7 @@ The full demo of the attack:
 
 Here we have a half-transparent `<iframe src="facebook.html">`, and in the example we can see it hovering over the button. A click on the button actually clicks on the iframe, but that's not visible to the user, because the iframe is transparent.
 
-As a result if the visitor is authorized on facebook ("remember me" is usually turned on), then it adds a "Like". On Twitter that would be a "Follow" button.
+As a result, if the visitor is authorized on Facebook ("remember me" is usually turned on), then it adds a "Like". On Twitter that would be a "Follow" button.
 
 Here's the same example, but closer to reality, with `opacity:0` for `<iframe>`:
 
@@ -68,14 +66,14 @@ Technically, if we have a text field to hack, then we can position an iframe in
 
 But then there's a problem. Everything that the visitor types will be hidden, because the iframe is not visible.
 
-So that would look really odd to the user, and he will stop.
+People will usually stop typing when they can't see their new characters printing on the screen.
 ```
 
 ## Old-school defences (weak)
 
-The oldest defence method is the piece of JavaScript that forbids to open the page in a frame (so-called "framebusting").
+The oldest defence is a bit of JavaScript which forbids opening the page in a frame (so-called "framebusting").
 
-Like this:
+That looks like this:
 
 ```js
 if (top != window) {
@@ -83,15 +81,15 @@ if (top != window) {
 }
 ```
 
-That is: if the window finds out that it's not on the top, then it automatically makes itself the top.
+That is: if the window finds out that it's not on top, then it automatically makes itself the top.
 
-As of now, that's not reliable, because there are many ways to hack around it. Let's cover a few.
+This not a reliable defence, because there are many ways to hack around it. Let's cover a few.
 
 ### Blocking top-navigation
 
 We can block the transition caused by changing `top.location` in the [beforeunload](info:onload-ondomcontentloaded#window.onbeforeunload) event.
 
-The top page (that belongs to the hacker) sets a handler to it, and when the `iframe` tries to change `top.location` the visitor gets a message asking him whether he wants to leave.
+The top page (belonging to the hacker) sets a handler to it, and when the `iframe` tries to change `top.location` the visitor gets a message asking him whether he wants to leave.
 
 Like this:
 ```js
@@ -101,7 +99,7 @@ window.onbeforeunload = function() {
 };
 ```
 
-In most cases the visitor would answer negatively, because he doesn't know about the iframe, all he can see is the top page, there's no reason to leave. And so the `top.location` won't change!
+In most cases the visitor would answer negatively, because he doesn't know about the iframe, all he can see is the top page, leading him to think there is no reason to leave. So `top.location` won't change!
 
 In action:
 
@@ -111,7 +109,7 @@ In action:
 
 One of the things restricted by the `sandbox` attribute is navigation. A sandboxed iframe may not change `top.location`.
 
-So we can add the iframe with `sandbox="allow-scripts allow-forms"`. That would relax the restrictions allowing scripts and forms. But we don't put `allow-top-navigation` in the value so that the navigation is still forbidden. And the change of `top.location` won't work.
+So we can add the iframe with `sandbox="allow-scripts allow-forms"`. That would relax the restrictions, permitting scripts and forms. But we omit `allow-top-navigation` so that changing `top.location` is forbidden.
 
 Here's the code:
 
@@ -123,21 +121,21 @@ There are other ways to work around that simple protection too.
 
 ## X-Frame-Options
 
-Server-side header `X-Frame-Options` can allow or forbid showing the page inside a frame.
+The server-side header `X-Frame-Options` can permit or forbid displaying the page inside a frame.
 
-It must be sent by the server: browser ignore it if found in `<meta>` tags. So `<meta http-equiv="X-Frame-Options"...>` won't do anything.
+It must be sent *by the server*: the browser will ignore it if found in a `<meta>` tag. So, `<meta http-equiv="X-Frame-Options"...>` won't do anything.
 
 The header may have 3 values:
 
 
 `DENY`
-: Never ever show the page inside an iframe.
+: Never ever show the page inside a frame.
 
 `SAMEORIGIN`
-: Allow to show inside an iframe if the parent document comes from the same origin.
+: Allow inside a frame if the parent document comes from the same origin.
 
 `ALLOW-FROM domain`
-: Allows to show inside an iframe if the parent document is from the given domain.
+: Allow inside a frame if the parent document is from the given domain.
 
 For instance, Twitter uses `X-Frame-Options: SAMEORIGIN`. Here's the result:
 
@@ -147,15 +145,15 @@ For instance, Twitter uses `X-Frame-Options: SAMEORIGIN`. Here's the result:
 
 <iframe src="https://twitter.com"></iframe>
 
-Depending on the browser, `iframe` above is either empty or it has a message telling that "the browser can't show it".
+Depending on your browser, the `iframe` above is either empty or alerting you that the browser won't permit that page to be navigating in this way.
 
 ## Showing with disabled functionality
 
-The protecting `X-Frame-Options` header has a side-effect. Other sites can't show our page in an `iframe`, even if they have "legal" reasons to do so.
+The `X-Frame-Options` header has a side-effect. Other sites won't be able to show our page in a frame, even if they have good reasons to do so.
 
-So there are other solutions. For instance, we can "cover" the page with a `<div>` with `height:100%;width:100%`, so that it handles all clicks. That `<div>` should disappear if `window == top` or we figure out that we don't need protection.
+So there are other solutions... For instance, we can "cover" the page with a `<div>` with `height: 100%; width: 100%;`, so that it intercepts all clicks. That `<div>` should disappear if `window == top` or if we figure out that we don't need the protection.
 
-Like this:
+Something like this:
 
 ```html
 <style>
@@ -188,13 +186,13 @@ The demo:
 
 ## Summary
 
-Clickjacking is a way to "trick" users into a clicking on a victim site without even knowing what happens. That's dangerous if there are important click-activated actions.
+Clickjacking is a way to "trick" users into clicking on a malicious site without even knowing what's happening. That's dangerous if there are important click-activated actions.
 
-A hacker can post a link to his evil page in a message or lure visitors to his page by other means. There are many variants.
+A hacker can post a link to his evil page in a message, or lure visitors to his page by some other means. There are many variations.
 
-From one side -- the attack is "not deep": all a hacker can do is one click. But from another side, if the hacker knows that after the click another control appears, then it may use cunning messages to make the user to click on it as well.
+From one perspective -- the attack is "not deep": all a hacker is doing is intercepting a single click. But from another perspective, if the hacker knows that after the click another control will appear, then he may use cunning messages to coerce the user into clicking on them as well.
 
-The attack is quite dangerous, because when we engineer the UI we usually don't think that a hacker can click on behalf of the visitor. So vulnerabilities can be found in totally unexpected places.
+The attack is quite dangerous, because when we engineer the UI we usually don't anticipate that a hacker may click on behalf of the visitor. So vulnerabilities can be found in totally unexpected places.
 
-- It's recommended to use `X-Frame-Options: SAMEORIGIN` on pages that are totally not meant to be shown inside iframes (or just for the whole site).
-- Use a covering `<div>` if we want to allow our pages to be shown in iframes, and still stay safe.
+- It is recommended to use `X-Frame-Options: SAMEORIGIN` on pages (or whole websites) which are not intended to be viewed inside frames.
+- Use a covering `<div>` if we want to allow our pages to be shown in iframes, but still stay safe.
diff --git a/5-regular-expressions/01-regexp-introduction/article.md b/5-regular-expressions/01-regexp-introduction/article.md
index 7cdb55e0..5b6c9473 100644
--- a/5-regular-expressions/01-regexp-introduction/article.md
+++ b/5-regular-expressions/01-regexp-introduction/article.md
@@ -6,8 +6,6 @@ In JavaScript regular expressions are implemented using objects of a built-in `R
 
 Please note that regular expressions vary between programming languages. In this tutorial we concentrate on JavaScript. Of course there's a lot in common, but they are a somewhat different in Perl, Ruby, PHP etc.
 
-[cut]
-
 ## Regular expressions
 
 A regular expression (also "regexp", or just "reg") consists of a *pattern* and optional *flags*.
diff --git a/5-regular-expressions/02-regexp-methods/article.md b/5-regular-expressions/02-regexp-methods/article.md
index 1d808bf3..c5a4cbdc 100644
--- a/5-regular-expressions/02-regexp-methods/article.md
+++ b/5-regular-expressions/02-regexp-methods/article.md
@@ -7,8 +7,6 @@ There are two sets of methods to deal with regular expressions.
 
 The structure is a bit messed up, so we'll first consider methods separately, and then -- practical recipes for common tasks.
 
-[cut]
-
 ## str.search(reg)
 
 We've seen this method already. It returns the position of the first match or `-1` if none found:
@@ -153,7 +151,7 @@ We can use special characters in it:
 |`$&`|the whole match|
 |<code>$&#096;</code>|a part of the string before the match|
 |`$'`|a part of the string after the match|
-|`$n`|if `n` is a 1-2 digit number, then it means the contents of n-th parentheses counting fro left to right|
+|`$n`|if `n` is a 1-2 digit number, then it means the contents of n-th parentheses counting from left to right|
 
 For instance let's use `$&` to replace all entries of `"John"` by `"Mr.John"`:
 
diff --git a/5-regular-expressions/03-regexp-character-classes/article.md b/5-regular-expressions/03-regexp-character-classes/article.md
index 41372bd0..2b41d57e 100644
--- a/5-regular-expressions/03-regexp-character-classes/article.md
+++ b/5-regular-expressions/03-regexp-character-classes/article.md
@@ -4,8 +4,6 @@ Consider a practical task -- we have a phone number `"+7(903)-123-45-67"`, and w
 
 A character class is a special notation that matches any symbol from the set.
 
-[cut]
-
 For instance, there's a "digit" class. It's written as `\d`. We put it in the pattern, and during the search any digit matches it.
 
 For instance, the regexp `pattern:/\d/` looks for a single digit:
@@ -101,9 +99,9 @@ So it matches `pattern:\bHello\b` and `pattern:\bJava\b`, but not `pattern:\bHel
 
 ```js run
 alert( "Hello, Java!".match(/\bHello\b/) ); // Hello
-alert( "Hello, Java!".match(/\Java\b/) );  // Java
-alert( "Hello, Java!".match(/\Hell\b/) );  // null
-alert( "Hello, Java!".match(/\Java!\b/) ); // null
+alert( "Hello, Java!".match(/\bJava\b/) );  // Java
+alert( "Hello, Java!".match(/\bHell\b/) );  // null
+alert( "Hello, Java!".match(/\bJava!\b/) ); // null
 ```
 
 Once again let's note that `pattern:\b` makes the searching engine to test for the boundary, so that `pattern:Java\b` finds `match:Java` only when followed by a word boundary, but it does not add a letter to the result.
diff --git a/5-regular-expressions/04-regexp-escaping/article.md b/5-regular-expressions/04-regexp-escaping/article.md
index cb7a3eb1..11767c3d 100644
--- a/5-regular-expressions/04-regexp-escaping/article.md
+++ b/5-regular-expressions/04-regexp-escaping/article.md
@@ -30,7 +30,7 @@ alert( "function g()".match(/g\(\)/) ); // "g()"
 If we're looking for a backslash `\`, then we should double it:
 
 ```js run
-alert( "1\2".match(/\\/) ); // '\'
+alert( "1\\2".match(/\\/) ); // '\'
 ```
 
 ## A slash
diff --git a/5-regular-expressions/05-regexp-character-sets-and-ranges/article.md b/5-regular-expressions/05-regexp-character-sets-and-ranges/article.md
index 90c890c7..5c8a8bab 100644
--- a/5-regular-expressions/05-regexp-character-sets-and-ranges/article.md
+++ b/5-regular-expressions/05-regexp-character-sets-and-ranges/article.md
@@ -2,8 +2,6 @@
 
 Several characters or character classes inside square brackets `[…]` mean to "search for any character among given".
 
-[cut]
-
 ## Sets
 
 For instance, `pattern:[eao]` means any of the 3 characters: `'a'`, `'e'`, or `'o'`.
diff --git a/5-regular-expressions/08-regexp-greedy-and-lazy/article.md b/5-regular-expressions/08-regexp-greedy-and-lazy/article.md
index 43650b36..44a32062 100644
--- a/5-regular-expressions/08-regexp-greedy-and-lazy/article.md
+++ b/5-regular-expressions/08-regexp-greedy-and-lazy/article.md
@@ -4,8 +4,6 @@ Quantifiers are very simple from the first sight, but in fact they can be tricky
 
 We should understand how the search works very well if we plan to look for something more complex than `pattern:/\d+/`.
 
-[cut]
-
 Let's take the following task as an example.
 
 We have a text and need to replace all quotes `"..."` with guillemet marks: `«...»`. They are preferred for typography in many countries.
diff --git a/5-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/solution.md b/5-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/solution.md
index 2747933e..63c1da7b 100644
--- a/5-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/solution.md
+++ b/5-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/solution.md
@@ -12,5 +12,5 @@ let reg = /\d+(\.\d+)?/g;
 
 let str = "1.5 0 12. 123.4.";
 
-alert( str.match(re) );   // 1.5, 0, 12, 123.4
+alert( str.match(reg) );   // 1.5, 0, 12, 123.4
 ```
diff --git a/5-regular-expressions/09-regexp-groups/article.md b/5-regular-expressions/09-regexp-groups/article.md
index 6bd14e7c..ab0d301a 100644
--- a/5-regular-expressions/09-regexp-groups/article.md
+++ b/5-regular-expressions/09-regexp-groups/article.md
@@ -7,8 +7,6 @@ That has two effects:
 1. It allows to place a part of the match into a separate array item when using  [String#match](mdn:js/String/match) or [RegExp#exec](mdn:/RegExp/exec) methods.
 2. If we put a quantifier after the parentheses, it applies to the parentheses as a whole, not the last character.
 
-[cut]
-
 ## Example
 
 In the example below the pattern `pattern:(go)+` finds one or more `match:'go'`:
diff --git a/5-regular-expressions/10-regexp-backreferences/article.md b/5-regular-expressions/10-regexp-backreferences/article.md
index f47515d7..a5d25107 100644
--- a/5-regular-expressions/10-regexp-backreferences/article.md
+++ b/5-regular-expressions/10-regexp-backreferences/article.md
@@ -2,8 +2,6 @@
 
 Capturing groups may be accessed not only in the result, but in the replacement string, and in the pattern too.
 
-[cut]
-
 ## Group in replacement: $n
 
 When we are using `replace` method, we can access n-th group in the replacement string using `$n`.
diff --git a/5-regular-expressions/11-regexp-alternation/article.md b/5-regular-expressions/11-regexp-alternation/article.md
index c071be70..a01eac0f 100644
--- a/5-regular-expressions/11-regexp-alternation/article.md
+++ b/5-regular-expressions/11-regexp-alternation/article.md
@@ -4,8 +4,6 @@ Alternation is the term in regular expression that is actually a simple "OR".
 
 In a regular expression it is denoted with a vertical line character `pattern:|`.
 
-[cut]
-
 For instance, we need to find programming languages: HTML, PHP, Java or JavaScript.
 
 The corresponding regexp: `pattern:html|php|java(script)?`.
diff --git a/5-regular-expressions/12-regexp-anchors/article.md b/5-regular-expressions/12-regexp-anchors/article.md
index b4ae67cf..b4981e09 100644
--- a/5-regular-expressions/12-regexp-anchors/article.md
+++ b/5-regular-expressions/12-regexp-anchors/article.md
@@ -2,14 +2,12 @@
 
 The caret `pattern:'^'` and dollar `pattern:'$'` characters have special meaning in a regexp. They are called "anchors".
 
-[cut]
-
 The caret `pattern:^` matches at the beginning of the text, and the dollar `pattern:$` -- in the end.
 
 For instance, let's test if the text starts with `Mary`:
 
 ```js run
-let str1 = 'Mary had a little lamb, it's fleece was white as snow';
+let str1 = "Mary had a little lamb, it's fleece was white as snow";
 let str2 = 'Everywhere Mary went, the lamp was sure to go';
 
 alert( /^Mary/.test(str1) ); // true
diff --git a/5-regular-expressions/13-regexp-multiline-mode/article.md b/5-regular-expressions/13-regexp-multiline-mode/article.md
index fe95ca50..1b5623dc 100644
--- a/5-regular-expressions/13-regexp-multiline-mode/article.md
+++ b/5-regular-expressions/13-regexp-multiline-mode/article.md
@@ -2,8 +2,6 @@
 
 The multiline mode is enabled by the flag `pattern:/.../m`.
 
-[cut]
-
 It only affects the behavior of `pattern:^` and `pattern:$`.
 
 In the multiline mode they match not only at the beginning and end of the string, but also at start/end of line.
diff --git a/5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md b/5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
index bb4c7d6f..cdb5f40e 100644
--- a/5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
+++ b/5-regular-expressions/15-regexp-infinite-backtracking-problem/article.md
@@ -2,16 +2,14 @@
 
 Some regular expressions are looking simple, but can execute veeeeeery long time, and even "hang" the JavaScript engine.
 
-Sooner or later all developers occasionally meets this behavior.
+Sooner or later most developers occasionally face such behavior.
 
-The typical situation -- a regular expression works fine for some time, and then starts to "hang" the script and make it consume 100% of CPU.
+The typical situation -- a regular expression works fine sometimes, but for certain strings it "hangs"  consuming 100% of CPU.
 
-That may even be a vulnerability. For instance, if JavaScript is on the server and uses regular expressions on user data. There were many vulnerabilities of that kind even in widely distributed systems.
+That may even be a vulnerability. For instance, if JavaScript is on the server, and it uses regular expressions to process user data, then such an input may cause denial of service. The author personally saw and reported such vulnerabilities even for well-known and widely used programs.
 
 So the problem is definitely worth to deal with.
 
-[cut]
-
 ## Example
 
 The plan will be like this:
@@ -42,7 +40,7 @@ In the regexp language that is: `pattern:<\w+(\s*\w+=(\w+|"[^"]*")\s*)*>`:
 1. `pattern:<\w+` -- is the tag start,
 2. `pattern:(\s*\w+=(\w+|"[^"]*")\s*)*` -- is an arbitrary number of pairs `word=value`, where the value can be either a word `pattern:\w+` or a quoted string `pattern:"[^"]*"`.
 
-That doesn't yet support the details of HTML grammer, for instance strings can be in 'single' quotes, but these can be added later, so that's somewhat close to real life. For now we want the regexp to be simple.
+That doesn't yet support few details of HTML grammar, for instance strings in 'single' quotes, but they can be added later, so that's somewhat close to real life. For now we want the regexp to be simple.
 
 Let's try it in action:
 
@@ -58,7 +56,7 @@ Great, it works! It found both the long tag `match:<a test="<>" href="#">` and t
 
 Now let's see the problem.
 
-If you run the example below, it may hang the browser (or another JavaScript engine):
+If you run the example below, it may hang the browser (or whatever JavaScript engine runs):
 
 ```js run
 let reg = /<\w+(\s*\w+=(\w+|"[^"]*")\s*)*>/g;
@@ -76,7 +74,9 @@ Some regexp engines can handle that search, but most of them don't.
 
 What's the matter? Why a simple regular expression on such a small string "hangs"?
 
-Let's simplify the situation by removing the tag and quoted strings, we'll look only for attributes:
+Let's simplify the situation by removing the tag and quoted strings.
+
+Here we look only for attributes:
 
 ```js run
 // only search for space-delimited attributes
@@ -91,15 +91,15 @@ alert( str.match(reg) );
 */!*
 ```
 
-The same.
+The same problem persists.
 
-Here we end the demo of the problem and start looking into what's going on.
+Here we end the demo of the problem and start looking into what's going on and why it hangs.
 
 ## Backtracking
 
 To make an example even simpler, let's consider `pattern:(\d+)*$`.
 
-In most regexp engines that search takes a very long time (careful -- can hang):
+This regular expression also has the same problem. In most regexp engines that search takes a very long time (careful -- can hang):
 
 ```js run
 alert( '12345678901234567890123456789123456789z'.match(/(\d+)*$/) );
@@ -107,9 +107,9 @@ alert( '12345678901234567890123456789123456789z'.match(/(\d+)*$/) );
 
 So what's wrong with the regexp?
 
-Actually, it looks a little bit strange. The quantifier `pattern:*` looks extraneous. If we want a number, we can use `pattern:\d+$`.
+First, one may notice that the regexp is a little bit strange. The quantifier `pattern:*` looks extraneous. If we want a number, we can use `pattern:\d+$`.
 
-Yes, the regexp is artificial, but the reason why it is slow is the same as those we saw above. So let's understand it.
+Indeed, the regexp is artificial. But the reason why it is slow is the same as those we saw above. So let's understand it, and then return to the real-life examples.
 
 What happen during the search of `pattern:(\d+)*$` in the line `subject:123456789z`?
 
@@ -119,7 +119,7 @@ What happen during the search of `pattern:(\d+)*$` in the line `subject:12345678
     \d+.......
     (123456789)z
     ```
-2. Then it tries to apply the start around the parentheses `pattern:(\d+)*`, but there are no more digits, so it the star doesn't give anything.
+2. Then it tries to apply the star around the parentheses `pattern:(\d+)*`, but there are no more digits, so it the star doesn't give anything.
 
     Then the pattern has the string end anchor `pattern:$`, and in the text we have `subject:z`.
 
diff --git a/6-async/01-callbacks/article.md b/6-async/01-callbacks/article.md
index 60ed5e83..0cc13215 100644
--- a/6-async/01-callbacks/article.md
+++ b/6-async/01-callbacks/article.md
@@ -2,7 +2,7 @@
 
 # Introduction: callbacks
 
-Many actions in Javascript are *asynchronous*.
+Many actions in JavaScript are *asynchronous*.
 
 For instance, take a look at the function `loadScript(src)`:
 
@@ -23,7 +23,7 @@ We can use it like this:
 loadScript('/my/script.js');
 ```
 
-The function is called "asynchronous", because the action (script loading) finishes not now, but later.
+The function is called "asynchronously", because the action (script loading) finishes not now, but later.
 
 The call initiates the script loading, then the execution continues. While the script is loading, the code below may finish executing, and if the loading takes time, other scripts may run meanwhile too.
 
@@ -35,7 +35,7 @@ loadScript('/my/script.js');
 
 Now let's say we want to use the new script when it loads. It probably declares new functions, so we'd like to run them.
 
-...But if we do that immediately after the `loadScript(…)` call, that wouldn't work:
+But if we do that immediately after the `loadScript(…)` call, that wouldn't work:
 
 ```js
 loadScript('/my/script.js'); // the script has "function newFunction() {…}"
@@ -45,7 +45,7 @@ newFunction(); // no such function!
 */!*
 ```
 
-Naturally, the browser probably didn't have time to load the script. So the immediate call to the new function fails. As of now, `loadScript` function doesn't provide a way to track the load completion. The script loads and eventually runs, that's all. But we'd like to know when happens, to use new functions and variables from that script.
+Naturally, the browser probably didn't have time to load the script. So the immediate call to the new function fails. As of now, `loadScript` function doesn't provide a way to track the load completion. The script loads and eventually runs, that's all. But we'd like to know when it happens, to use new functions and variables from that script.
 
 Let's add a `callback` function as a second argument to `loadScript` that should execute when the script loads:
 
@@ -118,7 +118,7 @@ loadScript('/my/script.js', function(script) {
 
 After the outer `loadScript` is complete, the callback initiates the inner one.
 
-...What if we want one more script?
+What if we want one more script...?
 
 ```js
 loadScript('/my/script.js', function(script) {
@@ -183,7 +183,7 @@ So the single `callback` function is used both for reporting errors and passing
 
 From the first look it's a viable way of asynchronous coding. And indeed it is. For one or maybe two nested calls it looks fine.
 
-But for multiple asynchronous actions that follow one after another we'll have a code like this:
+But for multiple asynchronous actions that follow one after another we'll have code like this:
 
 ```js
 loadScript('1.js', function(error, script) {
@@ -264,8 +264,8 @@ See? It does the same, and there's no deep nesting now, because we made every ac
 
 It works, but the code looks like a torn apart spreadsheet. It's difficult to read, you probably noticed that. One needs to eye-jump between pieces while reading it. That's inconvenient, especially the reader is not familiar with the code and doesn't know where to eye-jump.
 
-Also the functions named `step*` are all of a single use, they are created only to evade the "pyramid of doom". No one is going to reuse them outside of the action chain. So there's a bit of a namespace cluttering here.
+Also the functions named `step*` are all of a single use, they are created only to avoid the "pyramid of doom". No one is going to reuse them outside of the action chain. So there's a bit of a namespace cluttering here.
 
 We'd like to have a something better.
 
-Luckily, there are other ways to evade such pyramids. One of the best ways is to use "promises", described in the next chapter.
+Luckily, there are other ways to avoid such pyramids. One of the best ways is to use "promises", described in the next chapter.
diff --git a/6-async/02-promise-basics/article.md b/6-async/02-promise-basics/article.md
index bae64b37..d7bdb036 100644
--- a/6-async/02-promise-basics/article.md
+++ b/6-async/02-promise-basics/article.md
@@ -1,18 +1,18 @@
 # Promise
 
-Imagine that you're a top singer, and fans ask for your next upcoming single day and night.
+Imagine that you're a top singer, and fans ask day and night for your upcoming single.
 
-To get a relief, you promise to send it to them when it's published. You give your fans a list. They can fill in their coordinates, so that when the song becomes available, all subscribed parties instantly get it. And if something goes very wrong, so that the song won't be published ever, then they are also to be notified.
+To get some relief, you promise to send it to them when it's published. You give your fans a list to which they can subscribe for updates. They can fill in their email addresses, so that when the song becomes available, all subscribed parties instantly receive it. And even if something goes very wrong, say, if plans to publish the song are cancelled, they will still be notified.
 
 Everyone is happy: you, because the people don't crowd you any more, and fans, because they won't miss the single.
 
-That was a real-life analogy for things we often have in programming:
+This is a real-life analogy for things we often have in programming:
 
-1. A "producing code" that does something and needs time. For instance, it loads a remote script. That's a "singer".
-2. A "consuming code" wants the result when it's ready. Many functions may need that result. These are  "fans".
-3. A *promise* is a special JavaScript object that links them together. That's a "list". The producing code creates it and gives to everyone, so that they can subscribe for the result.
+1. A "producing code" that does something and takes time. For instance, the code loads a remote script. That's a "singer".
+2. A "consuming code" that wants the result of the "producing code" once it's ready. Many functions  may need that result. These are the "fans".
+3. A *promise* is a special JavaScript object that links the "producing code" and the "consuming code" together. In terms of our analogy: this is the "subscription list". The "producing code" takes whatever time it needs to produce the promised result, and the "promise" makes that result available to all of the subscribed code when it's ready.
 
-The analogy isn't very accurate, because JavaScript promises are more complex than a simple list: they have additional features and limitations. But still they are alike.
+The analogy isn't terribly accurate, because JavaScript promises are more complex than a simple subscription list: they have additional features and limitations. But it's fine to begin with.
 
 The constructor syntax for a promise object is:
 
@@ -22,33 +22,32 @@ let promise = new Promise(function(resolve, reject) {
 });
 ```
 
-The function passed to `new Promise` is called *executor*. When the promise is created, it's called automatically. It contains the producing code, that should eventually finish with a result. In terms of the analogy above, the executor is a "singer".
+The function passed to `new Promise` is called the *executor*. When the promise is created, this executor function runs automatically. It contains the producing code, that should eventually produce a result. In terms of the analogy above: the executor is the "singer".
 
 The resulting `promise` object has internal properties:
 
-- `state` -- initially is "pending", then changes to "fulfilled" or "rejected",
-- `result` -- an arbitrary value, initially `undefined`.
+- `state` — initially "pending", then changes to either "fulfilled" or "rejected",
+- `result` — an arbitrary value of your choosing, initially `undefined`.
 
-When the executor finishes the job, it should call one of:
+When the executor finishes the job, it should call one of the functions that it gets as arguments:
 
-- `resolve(value)` -- to indicate that the job finished successfully:
+- `resolve(value)` — to indicate that the job finished successfully:
     - sets `state` to `"fulfilled"`,
     - sets `result` to `value`.
-- `reject(error)` -- to indicate that an error occurred:
+- `reject(error)` — to indicate that an error occurred:
     - sets `state` to `"rejected"`,
     - sets `result` to `error`.
 
 ![](promise-resolve-reject.png)
 
-Here's a simple executor, to gather that all together:
+Later we'll see how these changes become known to "fans".
+
+Here's an example of a Promise constructor and a simple executor function with its "producing code" (the `setTimeout`):
 
 ```js run
 let promise = new Promise(function(resolve, reject) {
   // the function is executed automatically when the promise is constructed
 
-  alert(resolve); // function () { [native code] }
-  alert(reject);  // function () { [native code] }
-
   // after 1 second signal that the job is done with the result "done!"
   setTimeout(() => *!*resolve("done!")*/!*, 1000);
 });
@@ -56,16 +55,16 @@ let promise = new Promise(function(resolve, reject) {
 
 We can see two things by running the code above:
 
-1. The executor is called automatically and immediately (by `new Promise`).
-2. The executor receives two arguments: `resolve` and `reject` -- these functions come from JavaScript engine. We don't need to create them. Instead the executor should call them when ready.
+1. The executor is called automatically and immediately (by the `new Promise`).
+2. The executor receives two arguments: `resolve` and `reject` — these functions are pre-defined by the JavaScript engine. So we don't need to create them. Instead, we should write the executor to call them when ready.
 
-After one second of thinking the executor calls `resolve("done")` to produce the result:
+After one second of "processing" the executor calls `resolve("done")` to produce the result:
 
 ![](promise-resolve-1.png)
 
-That was an example of the "successful job completion".
+That was an example of a successful job completion, a "fulfilled promise".
 
-And now an example where the executor rejects promise with an error:
+And now an example of the executor rejecting the promise with an error:
 
 ```js
 let promise = new Promise(function(resolve, reject) {
@@ -76,12 +75,12 @@ let promise = new Promise(function(resolve, reject) {
 
 ![](promise-reject-1.png)
 
-To summarize, the executor should do a job (something that takes time usually) and then call `resolve` or `reject` to change the state of the corresponding promise object.
+To summarize, the executor should do a job (something that takes time usually) and then call `resolve` or `reject` to change the state of the corresponding Promise object.
 
-The promise that is either resolved or rejected is called "settled", as opposed to a "pending" promise.
+The Promise that is either resolved or rejected is called "settled", as opposed to a "pending" Promise.
 
-````smart header="There can be only one result or an error"
-The executor should call only one `resolve` or `reject`. The promise state change is final.
+````smart header="There can be only a single result or an error"
+The executor should call only one `resolve` or `reject`. The promise's state change is final.
 
 All further calls of `resolve` and `reject` are ignored:
 
@@ -94,48 +93,58 @@ let promise = new Promise(function(resolve, reject) {
 });
 ```
 
-The idea is that a job done by the executor may have only one result or an error. In programming, there exist other data structures that allow many "flowing" results, for instance streams and queues. They have their own advantages and disadvantages versus promises. They are not supported by JavaScript core and lack certain language features that promises provide, we don't cover them here to concentrate on promises.
+The idea is that a job done by the executor may have only one result or an error.
 
-Also if we call `resolve/reject` with more then one argument -- only the first argument is used, the next ones are ignored.
+Further, `resolve`/`reject` expect only one argument and will ignore additional arguments.
 ````
 
 ```smart header="Reject with `Error` objects"
-Technically we can call `reject` (just like `resolve`) with any type of argument. But it's recommended to use `Error` objects in `reject` (or inherit from them). The reasoning for that will become obvious soon.
+In case if something goes wrong, we can call `reject` with any type of argument (just like `resolve`). But it is recommended to use `Error` objects (or objects that inherit from `Error`). The reasoning for that will soon become apparent.
 ```
 
-````smart header="Resolve/reject can be immediate"
-In practice an executor usually does something asynchronously and calls `resolve/reject` after some time, but it doesn't have to. We can call `resolve` or `reject` immediately, like this:
+````smart header="Immediately calling `resolve`/`reject`"
+In practice, an executor usually does something asynchronously and calls `resolve`/`reject` after some time, but it doesn't have to. We also can call `resolve` or `reject` immediately, like this:
 
 ```js
 let promise = new Promise(function(resolve, reject) {
+  // not taking our time to do the job
   resolve(123); // immediately give the result: 123
 });
 ```
 
-For instance, it happens when we start to do a job and then see that everything has already been done. Technically that's fine: we have a resolved promise right now.
+For instance, this might happen when we start to do a job but then see that everything has already been completed.
+
+That's fine. We immediately have a resolved Promise, nothing wrong with that.
 ````
 
 ```smart header="The `state` and `result` are internal"
-Properties `state` and `result` of a promise object are internal. We can't directly access them from our code, but we can use methods `.then/catch` for that, they are described below.
+The properties `state` and `result` of the Promise object are internal. We can't directly access them from our "consuming code". We can use the methods `.then`/`.catch` for that. They are described below.
 ```
 
-## Consumers: ".then" and ".catch"
-
-A promise object serves as a link between the producing code (executor) and the consuming functions -- those that want to receive the result/error. Consuming functions can be registered using methods `promise.then` and `promise.catch`.
+## Consumers: "then" and "catch"
 
+A Promise object serves as a link between the executor (the "producing code" or "singer) and the consuming functions (the "fans"), which will receive the result or error. Consuming functions can be registered (subscribed) using the methods `.then` and `.catch`.
 
 The syntax of `.then` is:
 
 ```js
 promise.then(
-  function(result) { /* handle a successful result */ },
-  function(error) { /* handle an error */ }
+  function(result) { *!*/* handle a successful result */*/!* },
+  function(error) { *!*/* handle an error */*/!* }
 );
 ```
 
-The first function argument runs when the promise is resolved and gets the result, and the second one -- when it's rejected and gets the error.
+The first argument of `.then` is a function that:
 
-For instance:
+1. runs when the Promise is resolved, and
+2. receives the result.
+
+The second argument of `.then` is a function that:
+
+1. runs when the Promise is rejected, and
+2. receives the error.
+
+For instance, here's the reaction to a successfuly resolved promise:
 
 ```js run
 let promise = new Promise(function(resolve, reject) {
@@ -151,7 +160,9 @@ promise.then(
 );
 ```
 
-In case of a rejection:
+The first function was executed.
+
+And in the case of a rejection -- the second one:
 
 ```js run
 let promise = new Promise(function(resolve, reject) {
@@ -167,7 +178,7 @@ promise.then(
 );
 ```
 
-If we're interested only in successful completions, then we can provide only one argument to `.then`:
+If we're interested only in successful completions, then we can provide only one function argument to `.then`:
 
 ```js run
 let promise = new Promise(resolve => {
@@ -179,7 +190,7 @@ promise.then(alert); // shows "done!" after 1 second
 */!*
 ```
 
-If we're interested only in errors, then we can use `.then(null, function)` or an "alias" to it: `.catch(function)`
+If we're interested only in errors, then we can use `null` as the first argument: `.then(null, errorHandlingFunction)`. Or we can use `.catch(errorHandlingFunction)`, which is exactly the same:
 
 
 ```js run
@@ -205,35 +216,44 @@ let promise = new Promise(resolve => resolve("done!"));
 promise.then(alert); // done! (shows up right now)
 ```
 
-That's handy for jobs that may sometimes require time and sometimes finish immediately. The handler is guaranteed to run in both cases.
+Some tasks may sometimes require time and sometimes finish immediately. The good thing is: the `.then` handler is guaranteed to run in both cases.
 ````
 
-````smart header="Handlers of `.then/catch` are always asynchronous"
-To be even more precise, when `.then/catch` handler should execute, it first gets into an internal queue. The JavaScript engine takes handlers from the queue and executes when the current code finishes, similar to `setTimeout(..., 0)`.
+````smart header="Handlers of `.then`/`.catch` are always asynchronous"
+Even when the Promise is immediately resolved, code which occurs on lines *below* your `.then`/`.catch` may still execute first.
 
-In other words, when `.then(handler)` is going to trigger, it does something like `setTimeout(handler, 0)` instead.
+The JavaScript engine has an internal execution queue which gets all `.then/catch` handlers.
 
-In the example below the promise is immediately resolved, so `.then(alert)` triggers right now: the `alert` call is queued and runs immediately after the code finishes.
+But it only looks into that queue when the current execution is finished.
+
+In other words, `.then/catch` handlers are pending execution until the engine is done with the current code.
+
+For instance, here:
 
 ```js run
-// an immediately resolved promise
-let promise = new Promise(resolve => resolve("done!"));
+// an "immediately" resolved Promise
+const executor = resolve => resolve("done!");
+const promise = new Promise(executor);
 
-promise.then(alert); // done! (right after the current code finishes)
+promise.then(alert); // this alert shows last (*)
 
 alert("code finished"); // this alert shows first
 ```
 
-So the code after `.then` always executes before the handler (even in the case of a pre-resolved promise). Usually that's unimportant, in some scenarios may matter.
+The promise becomes settled immediately, but the engine first finishes the current code, calls `alert`, and only *afterwards* looks into the queue to run `.then` handler.
+
+So the code *after* `.then` ends up always running *before* the Promise's subscribers, even in the case of an immediately-resolved Promise.
+
+Usually that's unimportant, but in some scenarios the order may matter a great deal.
 ````
 
-Now let's see more practical examples how promises can help us in writing asynchronous code.
+Next, let's see more practical examples of how promises can help us to write asynchronous code.
 
 ## Example: loadScript
 
 We've got the `loadScript` function for loading a script from the previous chapter.
 
-Here's the callback-based variant, just to remind it:
+Here's the callback-based variant, just to remind us of it:
 
 ```js
 function loadScript(src, callback) {
@@ -247,9 +267,9 @@ function loadScript(src, callback) {
 }
 ```
 
-Let's rewrite it using promises.
+Let's rewrite it using Promises.
 
-The new function `loadScript` will not require a callback. Instead it will create and return a promise object that settles when the loading is complete. The outer code can add handlers to it using `.then`:
+The new function `loadScript` will not require a callback. Instead, it will create and return a Promise object that resolves when the loading is complete. The outer code can add handlers (subscribing functions) to it using `.then`:
 
 ```js run
 function loadScript(src) {  
@@ -278,13 +298,13 @@ promise.then(
 promise.then(script => alert('One more handler to do something else!'));
 ```
 
-We can immediately see few benefits over the callback-based syntax:
+We can immediately see a few benefits over the callback-based pattern:
 
 ```compare minus="Callbacks" plus="Promises"
 - We must have a ready `callback` function when calling `loadScript`. In other words, we must know what to do with the result *before* `loadScript` is called.
 - There can be only one callback.
-+ Promises allow us to code things in the natural order. First we run `loadScript`, and `.then` write what to do with the result.
-+ We can call `.then` on a promise as many times as we want, at any time later.
++ Promises allow us to do things in the natural order. First, we run `loadScript`, and `.then` we write what to do with the result.
++ We can call `.then` on a Promise as many times as we want. Each time, we're adding a new "fan", a new subscribing function, to the "subscription list". More about this in the next section: [Promise Chaining](/promise-chaining).
 ```
 
-So promises already give us better code flow and flexibility. But there's more. We'll see that in the next chapters.
+So Promises already give us better code flow and flexibility. But there's more. We'll see that in the next chapters.
diff --git a/6-async/03-promise-chaining/02-error-async/task.md b/6-async/03-promise-chaining/02-error-async/task.md
index f3fdf62b..bafc47ce 100644
--- a/6-async/03-promise-chaining/02-error-async/task.md
+++ b/6-async/03-promise-chaining/02-error-async/task.md
@@ -1,6 +1,6 @@
 # Error in setTimeout
 
-How do you think, does the `.catch` trigger? Explain your answer?
+What do you think? Will the `.catch` trigger? Explain your answer.
 
 ```js
 new Promise(function(resolve, reject) {
diff --git a/6-async/03-promise-chaining/article.md b/6-async/03-promise-chaining/article.md
index 41acc387..3df3b0da 100644
--- a/6-async/03-promise-chaining/article.md
+++ b/6-async/03-promise-chaining/article.md
@@ -1,15 +1,13 @@
 
 # Promises chaining
 
-Let's return to the problem mentioned in the chapter <info:callbacks>:
+Let's return to the problem mentioned in the chapter <info:callbacks>.
 
 - We have a sequence of asynchronous tasks to be done one after another. For instance, loading scripts.
 - How to code it well?
 
 Promises provide a couple of recipes to do that.
 
-[cut]
-
 In this chapter we cover promise chaining.
 
 It looks like this:
@@ -49,7 +47,7 @@ As the result is passed along the chain of handlers, we can see a sequence of `a
 
 ![](promise-then-chain.png)
 
-The whole thing works, because a call to `promise.then` returns a promise, so that we can call next `.then` on it.
+The whole thing works, because a call to `promise.then` returns a promise, so that we can call the next `.then` on it.
 
 When a handler returns a value, it becomes the result of that promise, so the next `.then` is called with it.
 
@@ -142,7 +140,7 @@ new Promise(function(resolve, reject) {
 
 Here the first `.then` shows `1` returns `new Promise(…)` in the line `(*)`. After one second it resolves, and the result (the argument of `resolve`, here it's `result*2`) is passed on to handler of the second `.then` in the line `(**)`. It shows `2` and does the same thing.
 
-So the output is again 1 -> 2 > 4, but now with 1 second delay between `alert` calls.
+So the output is again 1 -> 2 -> 4, but now with 1 second delay between `alert` calls.
 
 Returning promises allows us to build chains of asynchronous actions.
 
@@ -365,7 +363,7 @@ loadJson('/article/promise-chaining/user.json')
 
 ## Error handling
 
-Asynchronous actions may sometimes fail: in case of an error the corresponding promises becomes rejected. For instance, `fetch` fails if the remote server is not available. We can use `.catch` to handle errors (rejections).
+Asynchronous actions may sometimes fail: in case of an error the corresponding promise becomes rejected. For instance, `fetch` fails if the remote server is not available. We can use `.catch` to handle errors (rejections).
 
 Promise chaining is great at that aspect. When a promise rejects, the control jumps to the closest rejection handler down the chain. That's very convenient in practice.
 
@@ -617,12 +615,13 @@ What happens when an error is not handled? For instance, after the rethrow as in
 ```js untrusted run refresh
 new Promise(function() {
   noSuchFunction(); // Error here (no such function)
-});
+}); // no .catch attached
 ```
 
 Or here:
 
 ```js untrusted run refresh
+// a chain of promises without .catch at the end
 new Promise(function() {
   throw new Error("Whoops!");
 }).then(function() {
@@ -634,9 +633,9 @@ new Promise(function() {
 });
 ```
 
-In theory, nothing should happen. In case of an error happens, the promise state becomes "rejected", and the execution should jump to the closest rejection handler. But there is no such handler in the examples above. So the error gets "stuck".
+In case of an error, the promise state becomes "rejected", and the execution should jump to the closest rejection handler. But there is no such handler in the examples above. So the error gets "stuck".
 
-In practice, that means that the code is bad. Indeed, how come that there's no error handling?
+In practice, that's usually because of the bad code. Indeed, how come that there's no error handling?
 
 Most JavaScript engines track such situations and generate a global error in that case. We can see it in the console.
 
diff --git a/6-async/04-promise-api/01-promise-errors-as-results/source.view/index.html b/6-async/04-promise-api/01-promise-errors-as-results/source.view/index.html
index 241b09ad..c760ad8c 100644
--- a/6-async/04-promise-api/01-promise-errors-as-results/source.view/index.html
+++ b/6-async/04-promise-api/01-promise-errors-as-results/source.view/index.html
@@ -21,7 +21,7 @@
         alert(responses[0].status); // 200
         alert(responses[1].status); // 200
         alert(responses[2]); // TypeError: failed to fetch (text may vary)
-      ));
+      });
   </script>
 
 </body>
diff --git a/6-async/04-promise-api/01-promise-errors-as-results/task.md b/6-async/04-promise-api/01-promise-errors-as-results/task.md
index 4d53cbc1..d6904f1b 100644
--- a/6-async/04-promise-api/01-promise-errors-as-results/task.md
+++ b/6-async/04-promise-api/01-promise-errors-as-results/task.md
@@ -17,7 +17,7 @@ Promise.all(urls.map(url => fetch(url)))
     for(let response of responses) {
       alert(`${response.url}: ${response.status}`);
     }
-  ));
+  });
 ```
 
 The problem is that if any of requests fails, then `Promise.all` rejects with the error, and we loose results of all the other requests.
diff --git a/LICENSE.md b/LICENSE.md
new file mode 100644
index 00000000..60f06924
--- /dev/null
+++ b/LICENSE.md
@@ -0,0 +1,14 @@
+
+# Attribution-NonCommercial-ShareAlike 4.0
+
+The full license text is at <https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode>.
+
+You are free to:
+- **Share** – copy and redistribute the tutorial in any medium or material.
+- **Adapt** – remix, transform, and build upon the material.
+
+Under the following terms:
+
+- **Attribution** — You must give appropriate credit, provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use.
+- **NonCommercial** — You may not use the material for commercial purposes.
+- **ShareAlike** — If you remix, transform, or build upon the material, you must distribute your contributions under the same license as the original.
diff --git a/README.md b/README.md
index 3f0565f5..c6f4a062 100755
--- a/README.md
+++ b/README.md
@@ -1,13 +1,25 @@
-
 # The JavaScript Tutorial
 
 This repository hosts the content of the Modern JavaScript Tutorial, published at [https://javascript.info](https://javascript.info).
 
-Other languages:
-- Russian: [https://github.com/iliakan/javascript-tutorial-ru](https://github.com/iliakan/javascript-tutorial-ru).
-- Chinese: the ongoing translation at [https://github.com/iliakan/javascript-tutorial-cn](https://github.com/iliakan/javascript-tutorial-cn), go ahead and join if you know Chinese.
+## Translations
 
-Please use this repository to file issues and suggest PRs for the text.
+(In alphabetical order):
+
+| Language | Github | Translation leads | Translated (%) | Published |
+|----------|--------|-------------------|-----------------|-----------|
+| Chinese | https://github.com/xitu/javascript-tutorial-zh | @leviding | ![](http://translate-hook.javascript.info/stats/zh.svg) | - |
+| Danish | https://github.com/ockley/javascript-tutorial-da | @ockey | ![](http://translate-hook.javascript.info/stats/da.svg) | - |
+| French | https://github.com/SugoiNelson/javascript-tutorial-fr | @SugoiNelson | ![](http://translate-hook.javascript.info/stats/fr.svg) | - |
+| German | https://github.com/MartinEls/javascript-tutorial-de | @MartilEls | ![](http://translate-hook.javascript.info/stats/de.svg) | - |
+| Japanese | https://github.com/KenjiI/javascript-tutorial-ja | @KenjiI | ![](http://translate-hook.javascript.info/stats/ja.svg) | - |
+| Russian | https://github.com/iliakan/javascript-tutorial-ru | @iliakan | | https://learn.javascript.ru |
+| Turkish | https://github.com/sahinyanlik/javascript-tutorial-tr | @sahinyanlik | ![](http://translate-hook.javascript.info/stats/tr.svg) | - |
+| Uzbek | https://github.com/aruzikulov/javascript-tutorial-uz | @aruzikulov | ![](http://translate-hook.javascript.info/stats/uz.svg) | - |
+
+If you'd like to translate it into your language, please clone the repository, change its name to `javascript-tutorial-...` (by the language) and [create an issue](https://github.com/iliakan/javascript-tutoria-en/issues/new) for me to add you to the list.
+
+You can edit the text in any editor (markdown-like syntax). The server to run the tutorial locally and see how it looks is at <https://github.com/iliakan/javascript-tutorial-server>.  
 
 ## Structure
 
@@ -22,5 +34,3 @@ The type of the material is defined by the file inside the folder:
   - `task.md` stands for a task (solution must be provided in `solution.md` file aswell)
 
 Each of these files starts from the `# Main header`.
-
-Assets required for the material reside in the same folder.
diff --git a/TRANSLATION.md b/TRANSLATION.md
new file mode 100644
index 00000000..bde4be18
--- /dev/null
+++ b/TRANSLATION.md
@@ -0,0 +1,13 @@
+
+# The JavaScript Tutorial
+
+This repository hosts the translation of the [Modern JavaScript Tutorial](https://javascript.info).
+
+The full list of translations and leads is at <https://github.com/iliakan/javascript-tutorial-en>.
+
+Please contact the translation lead for any questions. 
+Contact @iliakan there's no answer or the translation appears to be stalled. 
+
+If there are other translators, notify them (create an issue?) when you're taking a chapter.
+
+
diff --git a/archive/01-hello-world/article.md b/archive/01-hello-world/article.md
index bfab9428..b08909eb 100644
--- a/archive/01-hello-world/article.md
+++ b/archive/01-hello-world/article.md
@@ -6,8 +6,6 @@ But we need something like a "base environment" to run our scripts, and browser
 
 So we'll start with attaching a script to the webpage. For other environments like Node.JS there are other ways to run it.
 
-[cut]
-
 [todo remove defer/async from here and move to 2nd part?]
 
 ## The "script" tag
diff --git a/archive/2-events-and-timing-depth/article.md b/archive/2-events-and-timing-depth/article.md
index b56243f0..3254326f 100644
--- a/archive/2-events-and-timing-depth/article.md
+++ b/archive/2-events-and-timing-depth/article.md
@@ -4,8 +4,6 @@
 
 Здесь мы разберём, как браузер обычно работает с одновременно возникающими событиями и какие есть исключения из общего правила.
 
-[cut]
-
 ## Главный поток
 
 В каждом окне выполняется только один *главный* поток, который занимается выполнением JavaScript, отрисовкой и работой с DOM.
diff --git a/archive/5-drag-and-drop-objects/article.md b/archive/5-drag-and-drop-objects/article.md
index 74c58d1d..3b8f3313 100644
--- a/archive/5-drag-and-drop-objects/article.md
+++ b/archive/5-drag-and-drop-objects/article.md
@@ -8,8 +8,6 @@
 
 Этот материал не строго обязателен для изучения, он специфичен именно для Drag'n'Drop.
 
-[cut]
-
 ## Документ
 
 Как пример задачи -- возьмём документ с иконками браузера ("объекты переноса"), которые можно переносить в компьютер ("цель переноса"):
diff --git a/archive/recursion.md b/archive/recursion.md
index 0af749b5..4b142bd4 100644
--- a/archive/recursion.md
+++ b/archive/recursion.md
@@ -8,8 +8,6 @@ In particular, a function can make a sub-call *itself*. That's called *a recursi
 
 We'll fiddle around that advanced case to better learn how functions work.
 
-[cut]
-
 [smart header="A topic you already know?"]
 Recursion is a general programming term. If you are already familiar with it, then you may list the page to the next chapter. Please read on if you are new to functions or just prefer not to skip parts.
 [/smart]
diff --git a/contributors.md b/contributors.md
deleted file mode 100644
index c6b26c99..00000000
--- a/contributors.md
+++ /dev/null
@@ -1,13 +0,0 @@
-
-The file lists people who made significant contributions to the project:
-
-<ul>
-<li>Alexey Maximov @amaxcz (admin)</li>
-<li>Alexey Shisterov (tutorial)</li>
-<li>Anton Vernogor @smmurf (markup)</li>
-<li>Artem Beztsenny @bezart (design)</li>
-<li>Ilya Kantor @iliakan (tutorial, code)</li>
-<li>Yuri Tkachenko @tyv (markup)</li>
-</ul>
-
-The project exists for a long time, I might have missed someone. If you expect to find yourself in the list, but you're not -- please mail me at mk@javascript.ru.
diff --git a/figures.sketch b/figures.sketch
index ac92dd46..b6abb538 100644
Binary files a/figures.sketch and b/figures.sketch differ