Fix grammar and typos (javascript-tutorial#3628)

Co-authored-by: Stanislav (Stanley) Modrak <44023416+smith558@users.noreply.github.com>

Author: nakhodkin

1-js/02-first-steps/04-variables/article.md

@@ -88,16 +88,16 @@ In older scripts, you may also find another keyword: `var` instead of `let`:
 *!*var*/!* message = 'Hello';
 ```
 
-The `var` keyword is *almost* the same as `let`. It also declares a variable, but in a slightly different, "old-school" way.
+The `var` keyword is *almost* the same as `let`. It also declares a variable but in a slightly different, "old-school" way.
 
-There are subtle differences between `let` and `var`, but they do not matter for us yet. We'll cover them in detail in the chapter <info:var>.
+There are subtle differences between `let` and `var`, but they do not matter to us yet. We'll cover them in detail in the chapter <info:var>.
 ````
 
 ## A real-life analogy
 
 We can easily grasp the concept of a "variable" if we imagine it as a "box" for data, with a uniquely-named sticker on it.
 
-For instance, the variable `message` can be imagined as a box labeled `"message"` with the value `"Hello!"` in it:
+For instance, the variable `message` can be imagined as a box labelled `"message"` with the value `"Hello!"` in it:
 
 ![](variable.svg)
 
@@ -198,14 +198,14 @@ Variables named `apple` and `APPLE` are two different variables.
 ```
 
 ````smart header="Non-Latin letters are allowed, but not recommended"
-It is possible to use any language, including cyrillic letters, Chinese logograms and so on, like this:
+It is possible to use any language, including Cyrillic letters, Chinese logograms and so on, like this:
 
 ```js
 let имя = '...';
 let 我 = '...';
 ```
 
-Technically, there is no error here. Such names are allowed, but there is an international convention to use English in variable names. Even if we're writing a small script, it may have a long life ahead. People from other countries may need to read it some time.
+Technically, there is no error here. Such names are allowed, but there is an international convention to use English in variable names. Even if we're writing a small script, it may have a long life ahead. People from other countries may need to read it sometime.
 ````
 
 ````warn header="Reserved names"
@@ -260,11 +260,11 @@ const myBirthday = '18.04.1982';
 myBirthday = '01.01.2001'; // error, can't reassign the constant!
 ```
 
-When a programmer is sure that a variable will never change, they can declare it with `const` to guarantee and clearly communicate that fact to everyone.
+When a programmer is sure that a variable will never change, they can declare it with `const` to guarantee and communicate that fact to everyone.
 
 ### 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 before execution.
 
 Such constants are named using capital letters and underscores.
 
@@ -289,15 +289,15 @@ Benefits:
 
 When should we use capitals for a constant and when should we name it normally? Let's make that clear.
 
-Being a "constant" just means that a variable's value never changes. But there are constants that are known prior to execution (like a hexadecimal value for red) and there are constants that are *calculated* in run-time, during the execution, but do not change after their initial assignment.
+Being a "constant" just means that a variable's value never changes. But some constants are known before execution (like a hexadecimal value for red) and some constants are *calculated* in run-time, during the execution, but do not change after their initial assignment.
 
 For instance:
 
 ```js
 const pageLoadTime = /* time taken by a webpage to load */;
 ```
 
-The value of `pageLoadTime` is not known prior to the page load, so it's named normally. But it's still a constant because it doesn't change after assignment.
+The value of `pageLoadTime` is not known before the page load, so it's named normally. But it's still a constant because it doesn't change after the assignment.
 
 In other words, capital-named constants are only used as aliases for "hard-coded" values.
 
@@ -307,18 +307,18 @@ Talking about variables, there's one more extremely important thing.
 
 A variable name should have a clean, obvious meaning, describing the data that it stores.
 
-Variable naming is one of the most important and complex skills in programming. A quick glance at variable names can reveal which code was written by a beginner versus an experienced developer.
+Variable naming is one of the most important and complex skills in programming. A glance at variable names can reveal which code was written by a beginner versus an experienced developer.
 
-In a real project, most of the time is spent modifying and extending an existing code base rather than writing something completely separate from scratch. When we return to some code after doing something else for a while, it's much easier to find information that is well-labeled. Or, in other words, when the variables have good names.
+In a real project, most of the time is spent modifying and extending an existing code base rather than writing something completely separate from scratch. When we return to some code after doing something else for a while, it's much easier to find information that is well-labelled. Or, in other words, when the variables have good names.
 
 Please spend time thinking about the right name for a variable before declaring it. Doing so will repay you handsomely.
 
 Some good-to-follow rules are:
 
 - Use human-readable names like `userName` or `shoppingCart`.
-- Stay away from abbreviations or short names like `a`, `b`, `c`, unless you really know what you're doing.
+- Stay away from abbreviations or short names like `a`, `b`, and `c`, unless you know what you're doing.
 - Make names maximally descriptive and concise. Examples of bad names are `data` and `value`. Such names say nothing. It's only okay to use them if the context of the code makes it exceptionally obvious which data or value the variable is referencing.
-- Agree on terms within your team and in your own mind. If a site visitor is called a "user" then we should name related variables `currentUser` or `newUser` instead of `currentVisitor` or `newManInTown`.
+- Agree on terms within your team and in your mind. If a site visitor is called a "user" then we should name related variables `currentUser` or `newUser` instead of `currentVisitor` or `newManInTown`.
 
 Sounds simple? Indeed it is, but creating descriptive and concise variable names in practice is not. Go for it.