diff --git a/1-js/08-prototypes/02-function-prototype/1-changing-prototype/solution.md b/1-js/08-prototypes/02-function-prototype/1-changing-prototype/solution.md
@@ -1,20 +1,20 @@

-Answers:

-1. `true`. 

-    The assignment to `Rabbit.prototype` sets up `[[Prototype]]` for new objects, but it does not affect the existing ones. 

-2. `false`. 

-    Objects are assigned by reference. The object from `Rabbit.prototype` is not duplicated, it's still a single object is referenced both by `Rabbit.prototype` and by the `[[Prototype]]` of `rabbit`. 

-    So when we change its content through one reference, it is visible through the other one.

3. `true`.

-    All `delete` operations are applied directly to the object. Here `delete rabbit.eats` tries to remove `eats` property from `rabbit`, but it doesn't have it. So the operation won't have any effect.

4. `undefined`.

-    The property `eats` is deleted from the prototype, it doesn't exist any more.
diff --git a/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md b/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md
@@ -1,6 +1,6 @@
-We can use such approach if we are sure that `"constructor"` property has the correct value.

-For instance, if we don't touch the default `"prototype"`, then this code works for sure:

```js run
function User(name) {
@@ -10,14 +10,14 @@ function User(name) {
let user = new User('John');
let user2 = new user.constructor('Pete');

-alert( user2.name ); // Pete (worked!)
```

-It worked, because `User.prototype.constructor == User`.

-..But if someone, so to say, overwrites `User.prototype` and forgets to recreate `"constructor"`, then it would fail.

-For instance:

```js run
function User(name) {
@@ -33,12 +33,12 @@ let user2 = new user.constructor('Pete');
alert( user2.name ); // undefined
```

-Why `user2.name` is `undefined`?

-Here's how `new user.constructor('Pete')` works:

-1. First, it looks for `constructor` in `user`. Nothing.
-2. Then it follows the prototype chain. The prototype of `user` is `User.prototype`, and it also has nothing.
-3. The value of `User.prototype` is a plain object `{}`, its prototype is `Object.prototype`. And there is `Object.prototype.constructor == Object`. So it is used.

-At the end, we have `let user2 = new Object('Pete')`. The built-in `Object` constructor ignores arguments, it always creates an empty object -- that's what we have in `user2` after all.
diff --git a/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/task.md b/1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/task.md
@@ -2,14 +2,14 @@ importance: 5

---

-# Create an object with the same constructor

-Imagine, we have an arbitrary object `obj`, created by a constructor function -- we don't know which one, but we'd like to create a new object using it.

-Can we do it like that?

```js
let obj2 = new obj.constructor();
```

-Give an example of a constructor function for `obj` which lets such code work right. And an example that makes it work wrong.
diff --git a/1-js/08-prototypes/02-function-prototype/article.md b/1-js/08-prototypes/02-function-prototype/article.md
@@ -1,18 +1,18 @@
# F.prototype

-Remember, new objects can be created with a constructor function, like `new F()`.

-If `F.prototype` is an object, then `new` operator uses it to set `[[Prototype]]` for the new object.

-```smart
-JavaScript had prototypal inheritance from the beginning. It was one of the core features of the language.

-But in the old times, there was no direct access to it. The only thing that worked reliably was a `"prototype"` property of the constructor function, described in this chapter. So there are many scripts that still use it.
```

-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.

-Here's the example:

```js run
let animal = {
@@ -32,65 +32,65 @@ let rabbit = new Rabbit("White Rabbit"); //  rabbit.__proto__ == animal
alert( rabbit.eats ); // true
```

-Setting `Rabbit.prototype = animal` literally states the following: "When a `new Rabbit` is created, assign its `[[Prototype]]` to `animal`".

-That's the resulting picture:

![](proto-constructor-animal-rabbit.svg)

-On the picture, `"prototype"` is a horizontal arrow, meaning a regular property, and `[[Prototype]]` is vertical, meaning the inheritance of `rabbit` from `animal`.

-```smart header="`F.prototype` only used at `new F` time"
-`F.prototype` property is only used when `new F` is called, it assigns `[[Prototype]]` of the new object. After that, there's no connection between `F.prototype` and the new object. Think of it as a "one-time gift".

-If, after the creation, `F.prototype` property changes (`F.prototype = <another object>`), then new objects created by `new F` will have another object as `[[Prototype]]`, but already existing objects keep the old one.
```

-## Default F.prototype, constructor property

-Every function has the `"prototype"` property even if we don't supply it.

-The default `"prototype"` is an object with the only property `constructor` that points back to the function itself.

-Like this:

```js
function Rabbit() {}

-/* default prototype
Rabbit.prototype = { constructor: Rabbit };
*/
```

![](function-prototype-constructor.svg)

-We can check it:

```js run
function Rabbit() {}
-// by default:
// Rabbit.prototype = { constructor: Rabbit }

alert( Rabbit.prototype.constructor == Rabbit ); // true
```

-Naturally, if we do nothing, the `constructor` property is available to all rabbits through  `[[Prototype]]`:

```js run
function Rabbit() {}
-// by default:
// Rabbit.prototype = { constructor: Rabbit }

-let rabbit = new Rabbit(); // inherits from {constructor: Rabbit}

-alert(rabbit.constructor == Rabbit); // true (from prototype)
```

![](rabbit-prototype-constructor.svg)

-We can use `constructor` property to create a new object using the same constructor as the existing one.

-Like here:

```js run
function Rabbit(name) {
@@ -105,17 +105,17 @@ let rabbit2 = new rabbit.constructor("Black Rabbit");
*/!*
```

-That's handy when we have an object, don't know which constructor was used for it (e.g. it comes from a 3rd party library), and we need to create another one of the same kind.

-But probably the most important thing about `"constructor"` is that...

-**...JavaScript itself does not ensure the right `"constructor"` value.**

-Yes, it exists in the default `"prototype"` for functions, but that's all. What happens with it later -- is totally on us.

-In particular, if we replace the default prototype as a whole, then there will be no `"constructor"` in it.

-For instance:

```js run
function Rabbit() {}
@@ -129,18 +129,18 @@ alert(rabbit.constructor === Rabbit); // false
*/!*
```

-So, to keep the right `"constructor"` we can choose to add/remove properties to the default `"prototype"` instead of overwriting it as a whole:

```js
function Rabbit() {}

-// Not overwrite Rabbit.prototype totally
-// just add to it
Rabbit.prototype.jumps = true
-// the default Rabbit.prototype.constructor is preserved
```

-Or, alternatively, recreate the `constructor` property manually:

```js
Rabbit.prototype = {
@@ -150,26 +150,26 @@ Rabbit.prototype = {
*/!*
};

-// now constructor is also correct, because we added it
```


-## Summary

-In this chapter we briefly described the way of setting a `[[Prototype]]` for objects created via a constructor function. Later we'll see more advanced programming patterns that rely on it.

-Everything is quite simple, just few notes to make things clear:

-- The `F.prototype` property (don't mess with `[[Prototype]]`) sets `[[Prototype]]` of new objects when `new F()` is called.
-- The value of `F.prototype` should be either an object or `null`: other values won't work.
--  The `"prototype"` property only has such a special effect when set on a constructor function, and invoked with `new`.

-On regular objects the `prototype` is nothing special:
```js
let user = {
  name: "John",
-  prototype: "Bla-bla" // no magic at all
};
```

-By default all functions have `F.prototype = { constructor: F }`, so we can get the constructor of an object by accessing its `"constructor"` property.