CrazyPython
diff --git a/‎1-js/2-first-steps/02-structure/article.md‎
Lines changed: 15 additions & 10 deletions b/‎1-js/2-first-steps/02-structure/article.md‎
Lines changed: 15 additions & 10 deletions
diff --git a/‎1-js/2-first-steps/03-strict-mode/article.md‎
Lines changed: 5 additions & 4 deletions b/‎1-js/2-first-steps/03-strict-mode/article.md‎
Lines changed: 5 additions & 4 deletions
diff --git a/‎1-js/2-first-steps/04-variables/article.md‎
Lines changed: 27 additions & 17 deletions b/‎1-js/2-first-steps/04-variables/article.md‎
Lines changed: 27 additions & 17 deletions
diff --git a/‎1-js/2-first-steps/05-types/article.md‎
Lines changed: 27 additions & 26 deletions b/‎1-js/2-first-steps/05-types/article.md‎
Lines changed: 27 additions & 26 deletions
@@ -6,7 +6,7 @@ The first overall thing to know is the code structure.
 
 ## Statements
 
-[Statements](https://en.wikipedia.org/wiki/Statement_(computer_science)) are syntax constructs and commands to perform actions. 
+Statements are syntax constructs and commands that perform actions.
 
 We've already seen a statement `alert('Hello, world!')`, which shows the message.
 
@@ -48,11 +48,11 @@ alert(3 +
 + 2);
 ```
 
-The code outputs `6`, because JavaScript does not insert semicolons here. It is intuitively obvious that if the line ends with a plus `"+"`, then it is an "incomplete expression". And in this case that's actually fine and comfortable.
+The code outputs `6`, because JavaScript does not insert semicolons here. It is intuitively obvious that if the line ends with a plus `"+"`, then it is an "incomplete expression", no semicolon required. And in this case that works as intended.
 
 **But there are situations where JavaScript "fails" to assume a semicolon where it is really needed.**
 
-Errors which come appear in such cases are quite hard to find and fix.
+Errors which occur in such cases are quite hard to find and fix.
 
 ````smart header="An example of the error"
 If you're curious to see a concrete example, check this code out:
@@ -65,25 +65,29 @@ It shows `1` then `2`.
 
 No need to think about the meaning of the brackets `[]` and `forEach`, for now -- it does not matter. Let's just remember the result.
 
-Now we prepend the code with an `alert` statement *not followed by a semicolon*:
+Now let's put an `alert` before the code. And *not* finish it with a semicolon:
 
 ```js run no-beautify
 alert( "There will be an error" ) // shown
-[1, 2].forEach(alert) // doesn't work!
+
+[1, 2].forEach(alert) // doesn't work any more!
 ```
 
 Now if we run it, only the first `alert` is shown, and then an error.
 
-But everything's fine if we add a semicolon:
+But everything is fine again if we add a semicolon after `alert`:
 ```js run
 alert( "All fine now" ); // shown
+
 [1, 2].forEach(alert)  // this works too
 ```
 
-The error in the no-semicolon variant occurs because JavaScript engine does not assume a semicolon before square brackets `[...]`, so the code is actually treated as a one-line statement:
+The error in the no-semicolon variant occurs because automatic semicolon insertion rules are complex, and in particular, JavaScript does not imply a semicolon before square brackets `[...]`.
+
+And, because the semicolon is not auto-inserted, the code is treated as a single statement, like this:
 
 ```js run no-beautify
-alert( "There will be an error" )[1, 2].forEach(alert) 
+alert( "There will be an error" )[1, 2].forEach(alert)
 ```
 
 And in this particular case, that's just wrong, hence the error. There are other situations when such thing happens.
@@ -133,11 +137,11 @@ alert( 'World' );
 ```
 
 ```smart header="Use hotkeys!"
-In most editors a line of code can be commented out by `key:Ctrl+/` hotkey for a single-line comment and something like `key:Ctrl+Shift+/` -- for multiline comments (select a code and press the hotkey).
+In most editors a line of code can be commented out by `key:Ctrl+/` hotkey for a single-line comment and something like `key:Ctrl+Shift+/` -- for multiline comments (select a code and press the hotkey). For Mac try `key:Cmd` instead of `key:Ctrl`.
 ```
 
 ````warn header="Nested comments are not supported!"
-There may not be comments inside comments.
+There may not be `/*...*/` inside another `/*...*/`.
 
 This code will die with an error:
 
@@ -155,3 +159,4 @@ Comments increase the overall code footprint, but that's not a problem at all. T
 
 Further in the tutorial we'll devote a special chapter to code style, also explaining how to write better comments.
 
+[todo is there such a chapter?]
@@ -48,9 +48,9 @@ Only comments may appear above `"use strict"`.
 
 
 ```smart header="`use strict` for functions"
-We will learn functions (a way to group commands) soon. 
+We will learn functions (a way to group commands) soon.
 
-Looking ahead let's just note that `"use strict"` can be put at the start of a function instead of the whole script. Then the strict mode is enabled in that function only. But usually people put it on top of scripts.
+Looking ahead let's just note that `"use strict"` can be put at the start of a function (most kinds of functions) instead of the whole script. Then strict mode is enabled in that function only. But usually people use it for the whole script.
 ```
 
 
@@ -66,5 +66,6 @@ Here in the tutorial all code (except where said otherwise) works in `"use stric
 ## Summary
 
 - The `"use strict"` directive switches the engine to the "modern" mode, changing the behavior of some builtin features.
-- Several modern features of the language enable `"use strict"` implicitly.
-- It's recommended to start scripts with `"use strict"`.
+- Several modern features of the language enable `"use strict"` implicitly, so it's quite hard to evade it.
+
+It's always recommended to start scripts with `"use strict"`. All examples in this book assume so, unless (very rarely) specified otherwise.
@@ -46,7 +46,7 @@ To be concise we can merge the variable declaration and assignment into a single
 ```js run
 let message = 'Hello!'; // define the variable and assign the value
 
-alert( message ); // Hello!
+alert(message); // Hello!
 ```
 
 We can also declare multiple variables in one line:
@@ -55,11 +55,11 @@ We can also declare multiple variables in one line:
 let user = 'John', age = 25, message = 'Hello';
 ```
 
-That might seem shorter, but it's not recommended. For the sake of beter readability, please use a single line per variable.
+That might seem shorter, but it's not recommended. For the sake of better readability, please use a single line per variable.
 
-The rewritten code is a bit longer, but easier to read:
+The multiline variant is a bit longer, but easier to read:
 
-```js no-beautify
+```js
 let user = 'John';
 let age = 25;
 let message = 'Hello';
@@ -80,7 +80,7 @@ let user = 'John'
   , message = 'Hello';
 ```
 
-Technically, all these variants do the same. So, it's a matter of personal taste and aestetics.
+Technically, all these variants do the same. So, it's a matter of personal taste and aesthetics.
 
 
 ````smart header="`var` instead of `let`"
@@ -103,7 +103,7 @@ For instance, the variable `message` can be imagined as a box labelled `"message
 
 ![](variable.png)
 
-We can put any value into the box. 
+We can put any value into the box.
 
 Also we can change it. The value can be changed as many times as needed:
 
@@ -211,12 +211,12 @@ let return = 5; // also can't name it "return", error!
 
 ````warn header="An assignment without `use strict`"
 
-Normally, we need to define a variable before using it. But in the old times, it was technically possible to create a variable by a mere assignment of the value. This still works now in if we don't put `use strict`, the behavior is kept for compatibility with old scripts. 
+Normally, we need to define a variable before using it. But in the old times, it was technically possible to create a variable by a mere assignment of the value. This still works now in if we don't put `use strict`, the behavior is kept for compatibility with old scripts.
 
 ```js run no-strict
 num = 5; // the variable "num" is created if didn't exist
 
-alert(num); // 5 
+alert(num); // 5
 ```
 
 That's a bad practice of course, it gives an error in the strict mode:
@@ -252,7 +252,7 @@ When a programmer is sure that the variable should never change, he can use `con
 
 ### Uppercase constants
 
-There is a widespread practice to use constants as aliases for difficult-to-remember values that are known prior to execution. 
+There is a widespread practice to use constants as aliases for difficult-to-remember values that are known prior to execution.
 
 Such constants are named using capitals and underscores.
 
@@ -269,19 +269,29 @@ let color = COLOR_ORANGE;
 alert( color ); // #FF7F00
 ```
 
-`COLOR_ORANGE` is much easier to remember than `"#FF7F00"`. Also it is much easier to mistype in `"#FF7F00"` than in `COLOR_ORANGE`. And when reading the code -- `COLOR_ORANGE` is much more meaningful. 
+`COLOR_ORANGE` is much easier to remember than `"#FF7F00"`. Also it is much easier to mistype in `"#FF7F00"` than in `COLOR_ORANGE`. And when reading the code -- `COLOR_ORANGE` is much more meaningful.
+
+When should we use capitals for a constant, and when -- name them normally? Let's make that clear.
+
+Being a "constant" just means that the value never changes. But there are constants that are known prior to execution (like a hexadimal value for red), and there are those that are *calculated* during the execution, but do not change since then.
+
+```js
+const ordinaryConst = /* an expression that uses the current date */;
+// the expression value is not known prior to execution
+// such a constant must be named normally
+```
+
+In other words, capital-named constants are only used as aliases for "hard-coded" values.  
 
 ## Name things right
 
-Talking about variables, there's an exteremely important thing.
+Talking about variables, there's one more exteremely important thing.
 
 Please name the variables sensibly.
 
 Variable naming is one of the most important and complex skills in programming. A quick glance at variable names can obviously show which code is written by a beginner and which by an experienced guru.
 
-In a real project, most of the time is spent on modifying and extending the existing code, rather than writing something completely new.
-
-And when we return to the code after some time of doing something else, it's much easier to find the information that is well-labelled. Or, in other words, when the variables are named right.
+In a real project, most of the time is spent on modifying and extending the existing code base, rather than writing something completely separate of it. And when we return to the code after some time of doing something else, it's much easier to find the 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.
 
@@ -290,7 +300,7 @@ Few good-to-follow rules are:
 - Use human-readable names like `userName` or `shoppingCart`.
 - Stay away from abbreviations or short names `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 variables like `currentUser` or `newUser`, but not `currentVisitor` or a `newManInTown`.
+- 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`.
 
 Sounds simple? Indeed it is. But creating good descriptive-and-concise names in practice is not. Go for it.
 
@@ -301,7 +311,7 @@ As the result, the variable is like a box where people throw different things wi
 
 Such a programmer saves a little bit on variable declaration, but looses ten times more on debugging the code.
 
-An extra variable is good, not evil. 
+An extra variable is good, not evil.
 
 Modern JavaScript minifiers and browsers optimize code well enough, so it won't create performance issues. Using different variables for values of different types can even help the engine to optimize better.
 ```
@@ -314,4 +324,4 @@ We can declare variables to store data. That can be done using `var` or `let` or
 - `var` -- is an old-school variable declaration. We'll study the subtle differences from `let` later.
 - `const` -- is like `let`, but the variable can't be changed.
 
-Variables should be named in a way that allows to easily understand what's inside.
+Variables should be named in a way that allows to easily understand what's inside.
@@ -1,8 +1,16 @@
 # Data types
 
-There are 7 data types in JavaScript.
+A variable in JavaScript can contain any data. A variable can at one moment be a string and later recieve a numeric value:
 
-In this chapter we'll get the common understanding of them. In further chapters we'll talk about each type in detail.
+```js
+// no error
+let message = "hello";
+message = 123456;
+```
+
+Such languages are called "dynamically typed", meaning that there are language types, but variables are not bound to any of them.
+
+There are 7 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]
 
@@ -19,7 +27,7 @@ There are many operations for numbers, e.g. multiplication `*`, division `/`, ad
 
 Besides regular numbers there are so-called "special numeric values" which also belong to that type: `Infinity`, `-Infinity` and `NaN`.
 
-- `Infinity` represents the mathematical [Infinity](https://en.wikipedia.org/wiki/Infinity). It is a value that's greater than any number.
+- `Infinity` represents the mathematical [Infinity](https://en.wikipedia.org/wiki/Infinity) ∞. It is a special value that's greater than any number.
 
     We can get it as a result of division by zero:
 
@@ -44,12 +52,12 @@ Besides regular numbers there are so-called "special numeric values" which also
     alert( "not a number" / 2 + 5 ); // NaN + 5 is still NaN
     ```
 
-    So, in a long mathematical expression if we have `NaN` in one place, it propagates to the whole result.
+    So, if there's `NaN` somewhere in a mathematical expression, it propagates to the whole result.
 
 ```smart header="Mathematical operations are safe"
-Doing maths is safe in JavaScript. We can do anything: divide by zero, treat non-numeric strings as numbers, etc. 
+Doing maths is safe in JavaScript. We can do anything: divide by zero, treat non-numeric strings as numbers, etc.
 
-The script will never stop with a fatal error ("die"). At worst we'll get `NaN` as the result. 
+The script will never stop with a fatal error ("die"). At worst we'll get `NaN` as the result.
 ```
 
 Special numeric values formally belong to the "number" type. Of course they are not numbers in a common sense of this word.
@@ -80,7 +88,7 @@ let name = "John";
 // embed variable
 alert( `Hello, ${name}!` ); // Hello, John!
 
-// embed expression 
+// embed expression
 alert( `the result is ${1 + 2}` ); // the result is 3
 ```
 
@@ -98,24 +106,24 @@ In JavaScript, there is no such type. There's only one type: `string`. A string
 
 The boolean type has only two values: `true` and `false`.
 
-This type is commonly used to store yes/no values.
+This type is commonly used to store yes/no values: `true` means "yes, correct", and `false` means the "no, incorrect".
 
 For instance:
 
-```js no-beautify
-let checked = true; // the form field is checked
-checked = false;    // the form field is not checked
+```js
+let checked1 = true;  // yes, the form field is checked
+let checked2 = false; // no, the form field is not checked
 ```
 
 Boolean values also come as the result of comparisons:
 
 ```js run
-let isGreater = 4 > 1; 
+let isGreater = 4 > 1;
 
 alert( isGreater ); // true (the comparison result is "yes")
 ```
 
-We'll cover booleans more deeply while discussing logical operators.
+We'll cover booleans more deeply later while discussing [logical operators](/logical-ops).
 
 ## The "null" value
 
@@ -131,13 +139,13 @@ In JavaScript `null` is not a "reference to a non-existing object" or a "null po
 
 It's just a special value which has the sense of "nothing", "empty" or "value unknown".
 
-The code above states that the `age` is unknown or empty for some reason. 
+The code above states that the `age` is unknown or empty for some reason.
 
 ## The "undefined" value
 
 The special value `undefined` stands apart. It makes a type of its own, just like `null`.
 
-The sense of `undefined` is "value is not assigned". 
+The sense of `undefined` is "value is not assigned".
 
 If a variable is declared, but not assigned, then its value is exactly `undefined`:
 
@@ -163,15 +171,11 @@ alert( x ); // "undefined"
 
 The `object` type is special.
 
-All other types are called "primitive", because their values can contain only a single thing (be it a string or a number or whatever).
-
-In contrast, objects are used to store collections data and more complex entities. We'll deal with them later after we know enough about primitives.
-
-The `symbol` type is used to create unique identifiers, mainly used to store data in objects. We'll return to them as soon as we cover objects.
+All other types are called "primitive", because their values can contain only a single thing (be it a string or a number or whatever). In contrast, objects are used to store collections data and more complex entities. We'll deal with them later after we know enough about primitives.
 
+The `symbol` type is used to create unique identifiers for objects. We have to mention it here for completeness, but we'd better study them after covering objects.
 
 [todo when ? chapter?]
-[todo move tasks]
 
 ## The typeof operator [#type-typeof]
 [todo we need typeof in types]
@@ -213,7 +217,7 @@ typeof alert // "function"  (3)
 
 The last three lines may be a little unobvious so here's explanations:
 
-1. `Math` is a built-in object that provides mathematical operations. We will learn it in the chapter <info:number>. Here it servers as an example, nothing more.
+1. `Math` is a built-in object that provides mathematical operations. We will learn it in the chapter <info:number>. Here it serves just as an example of an object.
 2. The result of `typeof null` equals to `"object"`. That's wrong. It is an officially recognized error in `typeof`, kept for compatibility. Of course, `null` is not an object. It is a special value with a separate type of its own. So, again, that's an error in the language.
 3. The result of `typeof alert` is `"function"`, because `alert` is a function of the language. We'll study functions in the near future and see that actually functions belong to the object type. But `typeof` treats them differently. That's very convenient in practice.
 
@@ -230,13 +234,10 @@ There are 7 basic types in JavaScript.
 - `object` for more complex data structures.
 - `symbol` for unique identifiers.
 
-The `typeof` operator allows to see which type is stored in the variable. 
+The `typeof` operator allows to see which type is stored in the variable.
 
 - Two forms: `typeof x` or `typeof(x)`.
 - Returns a string with the name of the type, like `"string"`.
 - Mistreats `null` as an `object` -- the old official error in the language.
 
 In nearest chapters we'll concentrate on understanding how to operate on primitives and once we're familiar with that, then we'll move on to objects.
-
-
-