ok

Author: iliakan

1-js/4-data-types/01-object/article.md

@@ -1,17 +1,13 @@
 
 # Objects 
 
-As we know, there are 7 language types in Javascript.
+As we know, there are 7 language types in Javascript. Six of them are called "primitive", because their values contain only a single thing (be it a string or a number or whatever).
 
-Six of them are called "primitive", because their values contain only a single thing (be it a string or a number or whatever).
-
-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.
+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 is defined with the figure brackets `{…}` with an optional list of "key: value" pairs. In programming that's sometimes called an "associative array" or a "hash".
+An object can be created with figure brackets `{…}` with an optional list of "key: value" pairs. In programming that's sometimes called an "associative array" or a "hash".
 
 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.
 
@@ -144,14 +140,14 @@ let bag = {
 alert( bag.apple ); // 5 if fruit="apple"
 ```
 
-Here, the object `bag` is created with a property with the name from `fruit` variable and the value `5`. So, if a visitor enters `"apple"`, `bag` will become `{apple: 5}`.
+Here, the value of `fruit` variable is used as the property name. So, if a visitor enters `"apple"`, `bag` will become `{apple: 5}`.
 
 Essentially, that works the same as:
 ```js run
 let fruit = prompt("Which fruit to buy?", "apple");
 let bag = {};
 
-// take property name from the fruit variable, assign 5 to it
+// take property name from the fruit variable
 bag[fruit] = 5; 
 ```
 
@@ -160,7 +156,7 @@ We can use more complex expressions inside square brackets. Anything that result
 ```js
 let fruit = 'apple';
 let bag = {
-  [ 'apple' + 'Computers' ]: 5 // bag.appleComputers = 5
+  ['apple' + 'Computers']: 5 // bag.appleComputers = 5
 };
 ```
 

1-js/4-data-types/02-garbage-collection/article.md

@@ -12,7 +12,9 @@ The main concept of memory management in Javascript is *reachability*.
 
 Simply put, "reachable" values are those that are accessible now or in the future. They are guaranteed to be stored in memory.
 
-1. There's a base set of inherently reachable values. For instance:
+1. There's a base set of inherently reachable values, that cannot be deleted for obvious reasons. 
+
+    For instance:
 
     - Local variables and parameters of the current function.
     - Variables and parameters for other functions on the current chain of nested calls.
@@ -38,9 +40,9 @@ let user = {
 
 ![](memory-user-john.png)
 
-Here an on further pictures, arrows depict references. For instance, the global variable `"user"` references John (the object `{name: "John"}`). The `"name"` property is not a reference, it stores a primitive, so it's painted inside the object.
+Here the arrow depicts an object reference. The global variable `"user"` references the object `{name: "John"}` (we'll call it John for brevity). The `"name"` property of John stores a primitive, so it's painted inside the object.
 
-If the `user` is overwritten, the reference is lost:
+If the value of `user` is overwritten, the reference is lost:
 
 ```js
 user = null;
@@ -102,22 +104,24 @@ The resulting memory structure:
 
 ![](family.png)
 
-To activate garbage collection, let's remove two references:
+As of now, all objects are reachable. 
+
+Now let's remove two references:
 
 ```js
 delete family.father;
 delete family.mother.husband;
 ```
 
-Note that if the deletion of any single one of them would not lead to anything, because all objects would still be reachable.
+![](family-delete-refs.png)
+
+It's not enough to delete any one of them, because all objects would still be reachable.
 
 But if we delete both, then we can see that John has no incoming references any more:
 
 ![](family-no-father.png)
 
-Outgoing references do not matter. Only incoming ones can make an object reachable.
-
-John, the former `family.father` is now unreachable and will be removed from the memory with all its data that also became unaccessible.
+Outgoing references do not matter. Only incoming ones can make an object reachable. So, John is now unreachable and will be removed from the memory with all its data that also became unaccessible.
 
 After garbage collection:
 
@@ -133,15 +137,15 @@ The source object is the same as above. Then:
 family = null;
 ```
 
-The result:
+The in-memory picture becomes:
 
 ![](family-no-family.png)
 
 This example demonstrates how important the concept of reachability is.
 
-It is clearly seen that John and Ann are still linked, both have incoming references. But it's not enough. 
+It's obvious that John and Ann are still linked, both have incoming references. But that's not enough. 
 
-The former `"family"` object has been unlinked from the root, there's no reference to it any more, so the whole island became unreachable and will be removed.
+The former `"family"` object has been unlinked from the root, there's no reference to it any more, so the whole island becomes unreachable and will be removed.
 
 ## Internal algorithms
 
@@ -151,10 +155,12 @@ Regularly the following "garbage collection" steps are performed:
 
 - The garbage collector takes roots and "marks" them.
 - Then it visits and "marks" all references from them.
-- Then it visits marked objects and marks *their* references, but the same object is not visited twice.
+- Then it visits marked objects and marks *their* references. All visited objects are remembered, not to visit the same object twice in the future.
+
 - ...And so on until there are unvisited references (reachable from the roots).
 - All objects except marked ones are removed.
 
+
 For instance, if our object structure looks like this:
 
 ![](garbage-collection-1.png)
@@ -182,10 +188,10 @@ Javascript engines apply many optimizations to it, to make it run faster and be
 Some of the optimizations:
 
 - **Generational collection** -- objects are split into two sets: "new ones" and "old ones". Many objects appear, do their job and die fast, so they can be cleaned up more aggressively. Those "new" that survive for long enough, become "old". 
-- **Incremental collection** -- if there are many objects, and we try to walk and mark the whole object set at once, it may take some time and introduce visible delays. So the engine tries to split the job into pieces. Then pieces are executed one at a time. That requires some extra bookkeeping in-between them to stay consistent.
+- **Incremental collection** -- if there are many objects, and we try to walk and mark the whole object set at once, it may take some time and introduce visible delays. So the engine tries to split the job into pieces. Then pieces are executed one at a time. That requires some extra bookkeeping between them.
 - **Idle-time collection** -- the garbage collector tries to run only while the CPU is idle, to reduce the possible effect on the execution.
 
-In-depth understanding of these optimization is also possible, there's no magic, but it requires a lot of under-the-hood digging. Javascript engines implement garbage collection differently. And -- what's even more important, things change, so going really deep "in advance" is probably not worth that. Unless, of course, it is a matter of pure interest. 
+Detailed learning of these optimization is also possible, but it requires a lot of under-the-hood digging. Javascript engines implement garbage collection differently. And -- what's even more important, things change, so going really deep "in advance", without a real need is probably not worth that. Unless, of course, it is a matter of pure interest, then there will be some links for you below. 
 
 ## Summary
 
@@ -197,7 +203,7 @@ The main things to know:
 
 Modern engines implement advanced algorithms of garbage collection.
 
-If you are familiar with low-level programming, the more detailed information about V8 garbage collector is in the article [A tour of V8: Garbage Collection](http://jayconrod.com/posts/55/a-tour-of-v8-garbage-collection). Also you'd better prepare yourself by learning how values are stored in V8. I'm saying: "V8", because it is best covered with articles in the internet. For other engines, things are somewhat similar, but not the same.
+If you are familiar with low-level programming, the more detailed information about V8 garbage collector is in the article [A tour of V8: Garbage Collection](http://jayconrod.com/posts/55/a-tour-of-v8-garbage-collection), and [V8 blog](http://v8project.blogspot.com/) also publishes articles about changes in memory management from time to time. Also you'd better prepare yourself by learning about V8 in general and read the blog of [Vyacheslav Egorov](http://mrale.ph) who worked as one of V8 engineers. I'm saying: "V8", because it is best covered with articles in the internet. For other engines, many approaches are similar, but garbage collection differs in many aspects.
 
 In-depth knowledge of engines is good when you need low-level optimizations. It would be wise to plan that as the next step after you're familiar with the language.  
 

1-js/4-data-types/02-garbage-collection/family-delete-refs.png

@@ -42,12 +42,6 @@ A function that is the property of an object is called its *method*.
 
 So, here we've got a method `sayHi` of the object `user`.
 
-```smart header="Object-oriented programming"
-When we write our code using objects to represent entities, that's called an [object-oriented programming](https://en.wikipedia.org/wiki/Object-oriented_programming), in short: "OOP". 
-
-OOP is a big thing, an interesting science of its own. How to choose the right entities? How to organize the interaction between them? That's architecture. We will make use of OOP further when we get enough familarity with the language. 
-```
-
 Of course, we could use a Function Declaration to add a method:
 
 ```js run
@@ -70,6 +64,11 @@ user.sayHi(); // Hello!
 
 That would also work, but is longer. Also we get an "extra" function `sayHi` outside of the `user` object. Usually we don't want that.
 
+```smart header="Object-oriented programming"
+When we write our code using objects to represent entities, that's called an [object-oriented programming](https://en.wikipedia.org/wiki/Object-oriented_programming), in short: "OOP". 
+
+OOP is a big thing, an interesting science of its own. How to choose the right entities? How to organize the interaction between them? That's architecture. 
+```
 ### Method shorthand
 
 There exists a shorter syntax for methods in an object literal:
@@ -93,7 +92,7 @@ let user = {
 }; 
 ```
 
-As demonstrated, we can omit a colon with the word `"function"`. 
+As demonstrated, we can omit `"function"` and just write `sayHi()`. 
 
 To say the truth, the notations are not fully identical. There are subtle differences related to object inheritance (to be covered later), but for now they do not matter. In almost all cases the shorter syntax is preferred.
 
@@ -218,6 +217,14 @@ In non-strict mode (if you forgot `use strict`) the value of `this` in such case
 
 Please note that usually a call of a function using `this` without an object is not normal, but rather a programming mistake. If a function has `this`, then it is usually meant to be called in the context of an object.
 
+```smart header="The consequences of unbound `this`"
+If you come from another programming languages, then you are probably used to an idea of a "bound `this`", where methods defined in an object always have `this` referencing that object.
+
+The idea of unbound, run-time evaluated `this` has both pluses and minuses. From one side, a function can be reused for different objects. From the other side, it's possible to occasionally loose `this` by making an improper call. 
+
+Here we are not to judge whether this language design decision is good or bad. We will understand how to work with it, how to get benefits and evade problems.
+```
+
 ## Internals: Reference Type
 
 An intricate method call can loose `this`, for instance:
@@ -290,75 +297,6 @@ Any other operation like assignment `hi = user.hi` discards the reference type a
 
 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).
 
-## Methods on primitives [todo: remove]
-
-In JavaScript primitives (strings, numbers etc) also have methods, as if they were objects. Still, primitives are not objects, and this section explains the interesting design solution of Javascript that makes it possible.
-
-Let's formulate the definitive distinction between primitives and objects.
-
-A primitive
-: Is a value of one of 6 primitive types: `string`, `number`, `boolean`, `symbol`, `null` and `undefined`.
-
-An object
-: Can be created with `{}`, for instance: `{name: "John", age: 30}`, is capable of storing multiple values as properties. There are other kinds of objects in JavaScript, e.g. functions are objects, there are objects that work with dates, errors and so on. They have different properties and methods.
-
-But features come at a price!
-
-Objects are "heavier" than primitives. They require additional resources to support the internal machinery. But properties and methods are useful in programming, Javascript engines try to optimize them, so the price is usually fair.
-
-So here's the paradox faced by the creator of JavaScript:
-
-- There are many things one would want to do with a primitive like a string or a number. Could be great to access them as methods.
-- Primitives must be as fast and lightweight as possible.
-
-The solution looks a little bit awkward, but here it is.
-
-1. Primitives are still primitive. A single lightweight value, as described.
-2. The language allows to access methods and properties of strings, numbers, booleans and symbols.
-3. When it happens, a special "object wrapper" is created, it provides the functionality, and then is destroyed. 
-
-The "object wrappers" are different for each primitive type and are named specifically: `String`, `Number`, `Boolean` and `Symbol`. Thus they provide different sets of methods.
-
-For instance, there exists a method [str.toUpperCase()](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase) that returns the capitalized string.
-
-Here's how it works:
-
-```js run
-let str = "Hello";
-
-alert( str.toUpperCase() ); // HELLO
-```
-
-Simple, right? And here's what actually happens in `str.toUpperCase()`:
-
-1. The string `str` is a primitive. So in the moment of accessing its property a special object is created that both knows the value of the string and has useful methods, like `toUpperCase()`.
-2. That method runs and returns a new string (shown by `alert`).
-3. The special object is destroyed, leaving the primitive `str` alone.
-
-So, primitives can provide methods, but they still remain lightweight.
-
-Of course, a JavaScript engine highly optimizes that process. Internally it may skip creation of the extra object at all. But it must 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:
-
-```js run
-let n = 1.23456;
-
-alert( n.toFixed(2) ); // 1.23
-```
-
-We'll learn more specific methods in next chapters. 
-
-````warn header="null/undefined have no methods"
-Special primitives `null` and `undefined` are exceptions. They have no corresponding "wrapper objects" and provide no methods. In a sense, they are "the most primitive".
-
-An attempt to access a property of such value would give an error:
-
-```js run
-alert(null.test); // error
-````
-
-
 ## Summary
 
 [todo]