TMatrix · TMatrix · Nov 21, 2017 · Sep 16, 2017 · Sep 16, 2017 · Sep 16, 2017
diff --git a/1-js/01-getting-started/1-intro/article.md b/1-js/01-getting-started/1-intro/article.md
@@ -25,7 +25,7 @@ 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.
@@ -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/02-first-steps/01-hello-world/article.md b/1-js/02-first-steps/01-hello-world/article.md
@@ -0,0 +1,137 @@
+# Hello, world!
+
+The tutorial that you're reading is about core JavaScript, which is platform-independent. Further on, you will learn Node.JS and other platforms that use it.
+
+But, we need a working environment to run our scripts, and, just because this book is online, the browser is a good choice. We'll keep the amount of browser-specific commands (like `alert`) to a minimum, so that you don't spend time on them if you plan to concentrate on another environment like Node.JS. On the other hand, browser details are explained in detail in the [next part](/ui) of the tutorial.
+
+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.
+
+For instance:
+
+```html run height=100
+<!DOCTYPE HTML>
+<html>
+
+<body>
+
+  <p>Before the script...</p>
+
+*!*
+  <script>
+    alert( 'Hello, world!' );
+  </script>
+*/!*
+
+  <p>...After the script.</p>
+
+</body>
+
+</html>
+```
+
+```online
+You can run the example by clicking on the "Play" button in its right-top corner.
+```
+
+The `<script>` tag contains JavaScript code which is automatically executed when the browser meets the tag.
+
+
+## The modern markup
+
+The `<script>` tag has a few attributes that are rarely used nowadays, but we can find them in old code:
+
+ The `type` attribute: <code>&lt;script <u>type</u>=...&gt;</code>
+
+ : The old standard HTML4 required a script to have a type. Usually it was `type="text/javascript"`. The modern HTML standard assumes this `type` by default. No attribute is required.
+
+ The `language` attribute: <code>&lt;script <u>language</u>=...&gt;</code>
+  : This attribute was meant to show the language of the script. As of now, this attribute makes no sense, the language is JavaScript by default. No need to use it.
+
+Comments before and after scripts.
+: In really ancient books and guides, one may find comments inside `<script>`, like this:
+
+    ```html no-beautify
+    <script type="text/javascript"><!--
+        ...
+    //--></script>
+    ```
+
+    These comments were supposed to hide the code from an old browser that didn't know about a `<script>` tag. But all browsers born in the past 15+ years don't have any issues. We mention it here, because such comments serve as a sign. If you see that somewhere -- that code is probably really old and not worth looking into.
+
+
+## External scripts
+
+If we have a lot of JavaScript code, we can put it into a separate file.
+
+The script file is attached to HTML with the `src` attribute:
+
+```html
+<script src="/path/to/script.js"></script>
+```
+
+Here `/path/to/script.js` is an absolute path to the file with the script (from the site root).
+
+It is also possible to provide a path relative to the current page. For instance, `src="script.js"` would mean a file `"script.js"` in the current folder.
+
+We can give a full URL as well, for instance:
+
+```html
+<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/3.2.0/lodash.js"></script>
+```
+
+To attach several scripts, use multiple tags:
+
+```html
+<script src="/js/script1.js"></script>
+<script src="/js/script2.js"></script>
+…
+```
+
+```smart
+As a rule, only the simplest scripts are put into HTML. More complex ones reside in separate files.
+
+The benefit of a separate file is that the browser will download it and then store in its [cache](https://en.wikipedia.org/wiki/Web_cache).
+
+After this, other pages that want the same script will take it from the cache instead of downloading it. So the file is actually downloaded only once.
+
+That saves traffic and makes pages faster.
+```
+
+````warn header="If `src` is set, the script content is ignored."
+A single `<script>` tag can't have both the `src` attribute and the code inside.
+
+This won't work:
+
+```html
+<script *!*src*/!*="file.js">
+  alert(1); // the content is ignored, because src is set
+</script>
+```
+
+We must choose: either it's an external `<script src="…">` or a regular `<script>` with code.
+
+The example above can be split into two scripts to work:
+
+```html
+<script src="file.js"></script>
+<script>
+  alert(1);
+</script>
+```
+````
+
+## Summary
+
+- We can use a `<script>` tag to add JavaScript code to the page.
+- The `type` and `language` attributes are not required.
+- A script in an external file can be inserted with `<script src="path/to/script.js"></script>`.
+
+
+There is much more to learn about browser scripts and their interaction with the web-page. But let's keep in mind that this part of the tutorial is devoted to the JavaScript language, so we shouldn't distract ourselves from it. We'll be using a browser as a way to run JavaScript, which is very convenient for online reading, but yet one of many.
diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md
@@ -1,8 +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.
+Variables are used to store this information.
 
 [cut]
 
@@ -296,7 +298,7 @@ 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-labelled. 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.
 
@@ -305,14 +307,14 @@ 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
@@ -191,7 +191,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/...2-first-steps/06-type-conversions/1-primitive-conversions-questions/solution.md b/...2-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/07-operators/article.md b/1-js/02-first-steps/07-operators/article.md
@@ -173,7 +173,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.
@@ -281,7 +281,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 +292,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 +381,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
 ```
@@ -409,18 +409,18 @@ 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/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
@@ -68,7 +68,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.
 

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
@@ -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/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
@@ -21,7 +21,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;
@@ -37,7 +37,7 @@ If there were no `i++` in the example above, the loop would repeat (in theory) f
 
 Any expression or a variable can be a loop condition, not just a comparison. They are evaluated and converted to 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 +108,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 +188,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:
 
@@ -239,7 +239,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++) {
@@ -324,7 +324,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 +369,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,7 +381,7 @@ 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.
 

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
@@ -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?
-Original file line number
+Diff line change
@@ Expand Up / @@ -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?