javascript-tutorial
diff --git a/‎1-js/01-getting-started/1-intro/article.md
+6-1 b/‎1-js/01-getting-started/1-intro/article.md
+6-1
diff --git a/‎1-js/01-getting-started/4-devtools/article.md
+5 b/‎1-js/01-getting-started/4-devtools/article.md
+5
diff --git a/‎1-js/02-first-steps/01-hello-world/1-hello-alert/index.html
+12 b/‎1-js/02-first-steps/01-hello-world/1-hello-alert/index.html
+12
diff --git a/‎1-js/02-first-steps/01-hello-world/1-hello-alert/solution.md
+2 b/‎1-js/02-first-steps/01-hello-world/1-hello-alert/solution.md
+2
diff --git a/‎1-js/02-first-steps/02-structure/article.md
+2-2 b/‎1-js/02-first-steps/02-structure/article.md
+2-2
diff --git a/‎1-js/02-first-steps/03-strict-mode/article.md
+1-1 b/‎1-js/02-first-steps/03-strict-mode/article.md
+1-1
diff --git a/‎1-js/02-first-steps/05-types/article.md
+31-10 b/‎1-js/02-first-steps/05-types/article.md
+31-10
diff --git a/‎1-js/02-first-steps/06-type-conversions/article.md
+8 b/‎1-js/02-first-steps/06-type-conversions/article.md
+8
diff --git a/‎1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/solution.md ‎1-js/02-first-steps/07-operators/3-primitive-conversions-questions/solution.md b/‎1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/solution.md ‎1-js/02-first-steps/07-operators/3-primitive-conversions-questions/solution.md
diff --git a/‎1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/task.md ‎1-js/02-first-steps/07-operators/3-primitive-conversions-questions/task.md b/‎1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/task.md ‎1-js/02-first-steps/07-operators/3-primitive-conversions-questions/task.md
diff --git a/‎1-js/02-first-steps/07-operators/article.md
+5-5 b/‎1-js/02-first-steps/07-operators/article.md
+5-5
diff --git a/‎1-js/02-first-steps/08-comparison/1-comparison-questions/solution.md
+1-1 b/‎1-js/02-first-steps/08-comparison/1-comparison-questions/solution.md
+1-1
diff --git a/‎1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md
+1-1 b/‎1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md
+1-1
diff --git a/‎1-js/02-first-steps/12-while-for/article.md
+2-2 b/‎1-js/02-first-steps/12-while-for/article.md
+2-2
diff --git a/‎1-js/02-first-steps/14-function-basics/article.md
+1-1 b/‎1-js/02-first-steps/14-function-basics/article.md
+1-1
diff --git a/‎1-js/02-first-steps/15-function-expressions-arrows/article.md ‎1-js/02-first-steps/15-function-expressions/article.md
+1-107 b/‎1-js/02-first-steps/15-function-expressions-arrows/article.md ‎1-js/02-first-steps/15-function-expressions/article.md
+1-107
diff --git a/‎1-js/02-first-steps/15-function-expressions-arrows/1-rewrite-arrow/solution.md ‎1-js/02-first-steps/16-arrow-functions-basics/1-rewrite-arrow/solution.md b/‎1-js/02-first-steps/15-function-expressions-arrows/1-rewrite-arrow/solution.md ‎1-js/02-first-steps/16-arrow-functions-basics/1-rewrite-arrow/solution.md
@@ -41,8 +41,13 @@ Engines are complicated. But the basics are easy.
 2. Then it converts ("compiles") the script to the machine language.
 3. And then the machine code runs, pretty fast.
 
+<<<<<<< HEAD
 The engine applies optimizations at each step of the process. It even watches the compiled script as it runs, analyzes the data that flows through it, and applies optimizations to the machine code based on that knowledge. When it's done, scripts run quite fast.
 '''
+=======
+The engine applies optimizations at each step of the process. It even watches the compiled script as it runs, analyzes the data that flows through it, and further optimizes the machine code based on that knowledge.
+```
+>>>>>>> fcfef6a07842ed56144e04a80c3a24de049a952a
 
 ## What can in-browser JavaScript do?
 
@@ -66,7 +71,7 @@ JavaScript's abilities in the browser are limited for the sake of the user's saf
 
 Examples of such restrictions include:
 
-- JavaScript on a webpage may not read/write arbitrary files on the hard disk, copy them or execute programs. It has no direct access to OS system functions.
+- JavaScript on a webpage may not read/write arbitrary files on the hard disk, copy them or execute programs. It has no direct access to OS functions.
 
 Modern browsers allow it to work with files, but the access is limited and only provided if the user does certain actions, like "dropping" a file into a browser window or selecting it via an '<input>' tag.
 
 
@@ -33,6 +33,11 @@
 
 Τώρα μπορούμε να δούμε λάθη, και αυτό είναι αρκετό για μια αρχή. Θα επιστρέψουμε αργότερα στα developer tools και θα καλύψουμε λεπτομερέστερα το σφάλμα στο κεφάλαιο <info:debugging-chrome>.
 
+```smart header="Multi-line input"
+Usually, when we put a line of code into the console, and then press `key:Enter`, it executes.
+
+To insert multiple lines, press `key:Shift+Enter`. This way one can enter long fragments of JavaScript code.
+```
 
 ## Firefox, Edge, και άλλο
 
 
@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+
+<body>
+
+  <script>
+    alert( "I'm JavaScript!" );
+  </script>
+
+</body>
+
+</html>
@@ -0,0 +1,2 @@
+
+[html src="index.html"]
@@ -94,7 +94,7 @@ But it should be two separate statements, not one. Such a merging in this case i
 
 We recommend putting semicolons between statements even if they are separated by newlines. This rule is widely adopted by the community. Let's note once again -- *it is possible* to leave out semicolons most of the time. But it's safer -- especially for a beginner -- to use them.
 
-## Comments
+## Comments [#code-comments]
 
 As time goes on, programs become more and more complex. It becomes necessary to add *comments* which describe what the code does and why.
 
@@ -136,7 +136,7 @@ alert('World');
 ```
 
 ```smart header="Use hotkeys!"
-In most editors, a line of code can be commented out by pressing the `key:Ctrl+/` hotkey for a single-line comment and something like `key:Ctrl+Shift+/` -- for multiline comments (select a piece of code and press the hotkey). For Mac, try `key:Cmd` instead of `key:Ctrl`.
+In most editors, a line of code can be commented out by pressing the `key:Ctrl+/` hotkey for a single-line comment and something like `key:Ctrl+Shift+/` -- for multiline comments (select a piece of code and press the hotkey). For Mac, try `key:Cmd` instead of `key:Ctrl` and `key:Option` instead of `key:Shift`.
 ```
 
 ````warn header="Nested comments are not supported!"
 
@@ -42,7 +42,7 @@ Only comments may appear above `"use strict"`.
 ```warn header="There's no way to cancel `use strict`"
 There is no directive like `"no use strict"` that reverts the engine to old behavior.
 
-Once we enter strict mode, there's no return.
+Once we enter strict mode, there's no going back.
 ```
 
 ## Browser console
 
@@ -10,9 +10,9 @@ message = 123456;
 
 Programming languages that allow such things are called "dynamically typed", meaning that there are data types, but variables are not bound to any of them.
 
-There are seven basic data types in JavaScript. Here, we'll cover them in general and in the next chapters we'll talk about each of them in detail.
+There are eight basic data types in JavaScript. Here, we'll cover them in general and in the next chapters we'll talk about each of them in detail.
 
-## A number
+## Number
 
 ```js
 let n = 123;
@@ -62,14 +62,33 @@ Special numeric values formally belong to the "number" type. Of course they are
 
 We'll see more about working with numbers in the chapter <info:number>.
 
-## A string
+## BigInt
+
+In JavaScript, the "number" type cannot represent integer values larger than <code>2<sup>53</sup></code> (or less than <code>-2<sup>53</sup></code> for negatives), that's a technical limitation caused by their internal representation. That's about 16 decimal digits, so for most purposes the limitation isn't a problem, but sometimes we need really big numbers, e.g. for cryptography or microsecond-precision timestamps.
+
+`BigInt` type was recently added to the language to represent integers of arbitrary length.
+
+A `BigInt` is created by appending `n` to the end of an integer literal:
+
+```js
+// the "n" at the end means it's a BigInt
+const bigInt = 1234567890123456789012345678901234567890n;
+```
+
+As `BigInt` numbers are rarely needed, we devoted them a separate chapter <info:bigint>.
+
+```smart header="Compatability issues"
+Right now `BigInt` is supported in Firefox and Chrome, but not in Safari/IE/Edge.
+```
+
+## String
 
 A string in JavaScript must be surrounded by quotes.
 
 ```js
 let str = "Hello";
 let str2 = 'Single quotes are ok too';
-let phrase = `can embed ${str}`;
+let phrase = `can embed another ${str}`;
 ```
 
 In JavaScript, there are 3 types of quotes.
@@ -78,7 +97,7 @@ In JavaScript, there are 3 types of quotes.
 2. Single quotes: `'Hello'`.
 3. Backticks: <code>&#96;Hello&#96;</code>.
 
-Double and single quotes are "simple" quotes. There's no difference between them in JavaScript.
+Double and single quotes are "simple" quotes. There's practically no difference between them in JavaScript.
 
 Backticks are "extended functionality" quotes. They allow us to embed variables and expressions into a string by wrapping them in `${…}`, for example:
 
@@ -102,12 +121,12 @@ alert( "the result is ${1 + 2}" ); // the result is ${1 + 2} (double quotes do n
 We'll cover strings more thoroughly in the chapter <info:string>.
 
 ```smart header="There is no *character* type."
-In some languages, there is a special "character" type for a single character. For example, in the C language and in Java it is `char`.
+In some languages, there is a special "character" type for a single character. For example, in the C language and in Java it is called "char".
 
 In JavaScript, there is no such type. There's only one type: `string`. A string may consist of only one character or many of them.
 ```
 
-## A boolean (logical type)
+## Boolean (logical type)
 
 The boolean type has only two values: `true` and `false`.
 
@@ -198,6 +217,8 @@ typeof undefined // "undefined"
 
 typeof 0 // "number"
 
+typeof 10n // "bigint"
+
 typeof true // "boolean"
 
 typeof "foo" // "string"
@@ -223,12 +244,12 @@ The last three lines may need additional explanation:
 2. The result of `typeof null` is `"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, this is an error in the language.
 3. The result of `typeof alert` is `"function"`, because `alert` is a function. We'll study functions in the next chapters where we'll also see that there's no special "function" type in JavaScript. Functions belong to the object type. But `typeof` treats them differently, returning `"function"`. That's not quite correct, but very convenient in practice.
 
-
 ## Summary
 
-There are 7 basic data types in JavaScript.
+There are 8 basic data types in JavaScript.
 
-- `number` for numbers of any kind: integer or floating-point.
+- `number` for numbers of any kind: integer or floating-point, integers are limited by ±2<sup>53</sup>.
+- `bigint` is for integer numbers of arbitrary length.
 - `string` for strings. A string may have one or more characters, there's no separate single-character type.
 - `boolean` for `true`/`false`.
 - `null` for unknown values -- a standalone type that has a single value `null`.
 
@@ -1,6 +1,10 @@
 # Μετατροπές Τύπων
 
+<<<<<<< HEAD
 Τις περισσότερες φορές, οι τελεστές και οι συναρτήσεις μετατρέπουν αυτόματα, και στον σωστό τύπο, τις τιμές που δίνονται σε αυτές.
+=======
+Most of the time, operators and functions automatically convert the values given to them to the right type.
+>>>>>>> fcfef6a07842ed56144e04a80c3a24de049a952a
 
 Για παράδειγμα, η `alert` μετατρέπει αυτόματα σε string οποιαδήποτε τιμή, ώστε να την εμφανίσει. Οι Μαθηματικές πράξεις μετατρέπουν τιμές σε νούμερα.
 
@@ -81,6 +85,7 @@ alert(Number(false)); // 0
 
 Παρακαλώ προσέξτε ότι οι τιμές `null` και `undefined` συμπεριφέρονται διαφορετικά εδώ: η `null` γίνεται 0 (μηδέν), ενώ η `undefined` γίνεται `NaN`.
 
+<<<<<<< HEAD
 ````smart header="Ο τελεστής '+' συνενώνει συμβολοσειρές"
 Σχεδόν όλες οι Μαθηματικές πράξεις μετατρέπουν τιμές σε αριθμούς. Μια ξεχωριστή εξαίρεση είναι ο τελεστής `+`. Έαν μία από τις προστιθέμενες τιμές είναι μια συμβολοσειρά, τότε και η άλλη μετατρέπεται σε συμβολοσειρά.
 
@@ -93,6 +98,9 @@ alert( '1' + 2 ); // '12' (συμβολοσειρά στα αριστερά)
 
 Αυτό συμβαίνει μόνο όταν τουλάχιστον μία από τις παραμέτρους είναι μια συμβολοσειρά. Διαφορετικά, οι τιμές μετατρέπονται σε αριθμούς.
 ````
+=======
+Most mathematical operators also perform such conversion, we'll see that in the next chapter.
+>>>>>>> fcfef6a07842ed56144e04a80c3a24de049a952a
 
 ## Boolean Conversion
 
 
@@ -138,17 +138,17 @@ Here's an extract from the [precedence table](https://developer.mozilla.org/en/J
 | Precedence | Name | Sign |
 |------------|------|------|
 | ... | ... | ... |
-| 16 | unary plus | `+` |
-| 16 | unary negation | `-` |
-| 14 | multiplication | `*` |
-| 14 | division | `/` |
+| 17 | unary plus | `+` |
+| 17 | unary negation | `-` |
+| 15 | multiplication | `*` |
+| 15 | division | `/` |
 | 13 | addition | `+` |
 | 13 | subtraction | `-` |
 | ... | ... | ... |
 | 3 | assignment | `=` |
 | ... | ... | ... |
 
-As we can see, the "unary plus" has a priority of `16` which is higher than the `13` of "addition" (binary plus). That's why, in the expression `"+apples + +oranges"`, unary pluses work before the addition.
+As we can see, the "unary plus" has a priority of `17` which is higher than the `13` of "addition" (binary plus). That's why, in the expression `"+apples + +oranges"`, unary pluses work before the addition.
 
 ## Assignment
 
 
@@ -13,7 +13,7 @@ null === +"\n0\n" → false
 Some of the reasons:
 
 1. Obviously, true.
-2. Dictionary comparison, hence false.
+2. Dictionary comparison, hence false. `"a"` is smaller than `"p"`.
 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.
 
@@ -6,7 +6,7 @@ alert( alert(1) || 2 || alert(3) );
 
 The call to `alert` does not return a value. Or, in other words, it returns `undefined`.
 
-1. The first OR `||` evaluates it's left operand `alert(1)`. That shows the first message with `1`.
+1. The first OR `||` evaluates its left operand `alert(1)`. That shows the first message with `1`.
 2. The `alert` returns `undefined`, so OR goes on to the second operand searching for a truthy value.
 3. The second operand `2` is truthy, so the execution is halted, `2` is returned and then shown by the outer alert.
 
 
@@ -256,7 +256,7 @@ For even values of `i`, the `continue` directive stops executing the body and pa
 ````smart header="The `continue` directive helps decrease nesting"
 A loop that shows odd values could look like this:
 
-```js
+```js run
 for (let i = 0; i < 10; i++) {
 
   if (i % 2) {
@@ -268,7 +268,7 @@ for (let i = 0; i < 10; i++) {
 
 From a technical point of view, this is identical to the example above. Surely, we can just wrap the code in an `if` block instead of using `continue`.
 
-But as a side-effect, this created one more level of nesting (the `alert` call inside the curly braces). If the code inside of`if` is longer than a few lines, that may decrease the overall readability.
+But as a side-effect, this created one more level of nesting (the `alert` call inside the curly braces). If the code inside of `if` is longer than a few lines, that may decrease the overall readability.
 ````
 
 ````warn header="No `break/continue` to the right side of '?'"
 
@@ -266,7 +266,7 @@ There may be many occurrences of `return` in a single function. For instance:
 
 ```js run
 function checkAge(age) {
-  if (age > 18) {
+  if (age >= 18) {
 *!*
     return true;
 */!*
 
@@ -1,4 +1,4 @@
-# Function expressions and arrows
+# Function expressions
 
 In JavaScript, a function is not a "magical language structure", but a special kind of value.
 
@@ -355,107 +355,6 @@ That's also better for readability, as it's easier to look up `function f(…) {
 ...But if a Function Declaration does not suit us for some reason, or we need a conditional declaration (we've just seen an example), then Function Expression should be used.
 ```
 
-
-## Arrow functions [#arrow-functions]
-
-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
-let func = (arg1, arg2, ...argN) => expression
-```
-
-...This creates a function `func` that has arguments `arg1..argN`, evaluates the `expression` on the right side with their use and returns its result.
-
-In other words, it's roughly the same as:
-
-```js
-let func = function(arg1, arg2, ...argN) {
-  return expression;
-};
-```
-
-...But much more concise.
-
-Let's see an example:
-
-```js run
-let sum = (a, b) => a + b;
-
-/* The arrow function is a shorter form of:
-
-let sum = function(a, b) {
-  return a + b;
-};
-*/
-
-alert( sum(1, 2) ); // 3
-
-```
-
-If we have only one argument, then parentheses around parameters can be omitted, making that even shorter:
-
-```js run
-// same as
-// let double = function(n) { return n * 2 }
-*!*
-let double = n => n * 2;
-*/!*
-
-alert( double(3) ); // 6
-```
-
-If there are no arguments, parentheses should be empty (but they should be present):
-
-```js run
-let sayHi = () => alert("Hello!");
-
-sayHi();
-```
-
-Arrow functions can be used in the same way as Function Expressions.
-
-For instance, here's the rewritten example with `welcome()`:
-
-```js run
-let age = prompt("What is your age?", 18);
-
-let welcome = (age < 18) ?
-  () => alert('Hello') :
-  () => alert("Greetings!");
-
-welcome(); // ok now
-```
-
-Arrow functions may appear unfamiliar and not very readable at first, but that quickly changes as the eyes get used to the structure.
-
-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 curly braces. Then use a normal `return` within them.
-
-Like this:
-
-```js run
-let sum = (a, b) => {  // the curly brace opens a multiline function
-  let result = a + b;
-*!*
-  return result; // if we use curly braces, use return to get results
-*/!*
-};
-
-alert( sum(1, 2) ); // 3
-```
-
-```smart header="More to come"
-Here we praised arrow functions for brevity. But that's not all! Arrow functions have other interesting features. We'll return to them later in the chapter <info:arrow-functions>.
-
-For now, we can already use arrow functions for one-line actions and callbacks.
-```
-
 ## Summary
 
 - Functions are values. They can be assigned, copied or declared in any place of the code.
@@ -467,8 +366,3 @@ For now, we can already use arrow functions for one-line actions and callbacks.
 In most cases when we need to declare a function, a Function Declaration is preferable, because it is visible prior to the declaration itself. That gives us more flexibility in code organization, and is usually more readable.
 
 So we should use a Function Expression only when a Function Declaration is not fit for the task. We've seen a couple of examples of that in this chapter, and will see more in the future.
-
-Arrow functions are handy for one-liners. They come in two flavors:
-
-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.