diff --git a/1-js/04-object-basics/04-object-methods/4-object-property-this/solution.md b/1-js/04-object-basics/04-object-methods/4-object-property-this/solution.md
@@ -1,10 +1,10 @@
-**Answer: an error.**

Try it:
```js run
function makeUser() {
  return {
-    name: "John",
    ref: this
  };
}
@@ -14,31 +14,31 @@ let user = makeUser();
alert( user.ref.name ); // Error: Cannot read property 'name' of undefined
```

-That's because rules that set `this` do not look at object definition. Only the moment of call matters.

-Here the value of `this` inside `makeUser()` is `undefined`, because it is called as a function, not as a method with "dot" syntax.

-The value of `this` is one for the whole function, code blocks and object literals do not affect it.

-So `ref: this` actually takes current `this` of the function.

-We can rewrite the function and return the same `this` with `undefined` value: 

```js run
function makeUser(){
-  return this; // this time there's no object literal
}

alert( makeUser().name ); // Error: Cannot read property 'name' of undefined
```
-As you can see the result of `alert( makeUser().name )` is the same as the result of `alert( user.ref.name )` from the previous example.

-Here's the opposite case:

```js run
function makeUser() {
  return {
-    name: "John",
*!*
    ref() {
      return this;
@@ -49,7 +49,7 @@ function makeUser() {

let user = makeUser();

-alert( user.ref().name ); // John
```

-Now it works, because `user.ref()` is a method. And the value of `this` is set to the object before dot `.`.
diff --git a/1-js/04-object-basics/04-object-methods/7-calculator/task.md b/1-js/04-object-basics/04-object-methods/7-calculator/task.md
@@ -2,17 +2,17 @@ importance: 5

---

-# Create a calculator

-Create an object `calculator` with three methods:

-- `read()` prompts for two values and saves them as object properties.
-- `sum()` returns the sum of saved values.
-- `mul()` multiplies saved values and returns the result.

```js
let calculator = {
-  // ... your code ...
};

calculator.read();

diff --git a/1-js/04-object-basics/04-object-methods/8-chain-calls/solution.md b/1-js/04-object-basics/04-object-methods/8-chain-calls/solution.md
@@ -1,4 +1,4 @@
-The solution is to return the object itself from every call.

```js run demo
let ladder = {
@@ -26,7 +26,7 @@ let ladder = {
ladder.up().up().down().up().down().showStep(); // 1
```

-We also can write a single call per line. For long chains it's more readable:

```js
ladder

diff --git a/1-js/04-object-basics/04-object-methods/8-chain-calls/task.md b/1-js/04-object-basics/04-object-methods/8-chain-calls/task.md
@@ -2,9 +2,9 @@ importance: 2

---

-# Chaining

-There's a `ladder` object that allows to go up and down:

```js
let ladder = {
@@ -15,13 +15,13 @@ let ladder = {
  down() { 
    this.step--;
  },
-  showStep: function() { // shows the current step
    alert( this.step );
  }
};
```

-Now, if we need to make several calls in sequence, can do it like this:

```js
ladder.up();
@@ -30,10 +30,10 @@ ladder.down();
ladder.showStep(); // 1
```

-Modify the code of `up`, `down` and `showStep` to make the calls chainable, like this:

```js
ladder.up().up().down().showStep(); // 1
```

-Such approach is widely used across JavaScript libraries.