Fix name of JavaScript

Author: lex111

1-js/01-getting-started/1-intro/article.md

@@ -45,7 +45,7 @@ The engine applies optimizations at each step of the process. It even watches th
 
 Modern JavaScript is a "safe" programming language. It does not provide low-level access to memory or CPU, because it was initially created for browsers which do not require it.
 
-Javascript's capabilities greatly depend on the environment it's running in. For instance, [Node.JS](https://wikipedia.org/wiki/Node.js) supports functions that allow JavaScript to read/write arbitrary files, perform network requests, etc.
+JavaScript's capabilities greatly depend on the environment it's running in. For instance, [Node.JS](https://wikipedia.org/wiki/Node.js) supports functions that allow JavaScript to read/write arbitrary files, perform network requests, etc.
 
 In-browser JavaScript can do everything related to webpage manipulation, interaction with the user, and the webserver.
 
@@ -88,7 +88,7 @@ There are at least *three* great things about JavaScript:
 + Simple things are done simply.
 + Support by all major browsers and enabled by default.
 ```
-Javascript is the only browser technology that combines these three things.
+JavaScript is the only browser technology that combines these three things.
 
 That's what makes JavaScript unique. That's why it's the most widespread tool for creating browser interfaces.
 

1-js/06-advanced-functions/03-closure/article.md

@@ -221,7 +221,7 @@ function sayHiBye(firstName, lastName) {
 }
 ```
 
-Here the *nested* function `getFullName()` is made for convenience. It can access the outer variables and so can return the full name. Nested functions are quite common in Javascript.
+Here the *nested* function `getFullName()` is made for convenience. It can access the outer variables and so can return the full name. Nested functions are quite common in JavaScript.
 
 What's much more interesting, a nested function can be returned: either as a property of a new object (if the outer function creates an object with methods) or as a result by itself. It can then be used somewhere else. No matter where, it still has access to the same outer variables.
 
@@ -473,7 +473,7 @@ The code outside of the block (or inside another script) doesn't see variables i
 
 ### IIFE
 
-In the past, there were no block-level lexical environment in Javascript.
+In the past, there were no block-level lexical environment in JavaScript.
 
 So programmers had to invent something. And what they did is called "immediately-invoked function expressions" (abbreviated as IIFE).
 

1-js/06-advanced-functions/05-global-object/article.md

@@ -79,7 +79,7 @@ No, it's not, because it may lead to naming conflicts: the same variable name ca
 
 As of now, the multi-purpose `window` is considered a design mistake in the language.
 
-Luckily, there's a "road out of hell", called "Javascript modules".
+Luckily, there's a "road out of hell", called "JavaScript modules".
 
 If we set `type="module"` attribute on a `<script>` tag, then such script is considered a separate "module" with its own top-level scope (lexical environment), not interfering with `window`.
 

1-js/08-prototypes/04-prototype-methods/article.md

@@ -3,7 +3,7 @@
 
 In the first chapter of this section, we mentioned that there are modern methods to setup a prototype.
 
-The `__proto__` is considered outdated and somewhat deprecated (in browser-only part of the Javascript standard).
+The `__proto__` is considered outdated and somewhat deprecated (in browser-only part of the JavaScript standard).
 
 The modern methods are:
 
@@ -81,7 +81,7 @@ Why was `__proto__` replaced by the functions? That's an interesting question, r
 ```warn header="Don't reset `[[Prototype]]` unless the speed doesn't matter"
 Technically, we can get/set `[[Prototype]]` at any time. But usually we only set it once at the object creation time, and then do not modify: `rabbit` inherits from `animal`, and that is not going to change.
 
-And JavaScript engines are highly optimized to that. Changing a prototype "on-the-fly" with `Object.setPrototypeOf` or `obj.__proto__=` is a very slow operation, it breaks internal optimizations for object property access operations. So evade it unless you know what you're doing, or Javascript speed totally doesn't matter for you.
+And JavaScript engines are highly optimized to that. Changing a prototype "on-the-fly" with `Object.setPrototypeOf` or `obj.__proto__=` is a very slow operation, it breaks internal optimizations for object property access operations. So evade it unless you know what you're doing, or JavaScript speed totally doesn't matter for you.
 ```
 
 ## "Very plain" objects

1-js/09-classes/01-class/article.md

@@ -68,7 +68,7 @@ So, what exactly is a `class`? That's not an entirely  new language-level entity
 
 Let's unveil any magic and see what a class really is. That'll help in understanding many complex aspects.
 
-In Javascript, a class is a kind of a function.
+In JavaScript, a class is a kind of a function.
 
 Here, take a look:
 

1-js/09-classes/04-private-protected-properties-methods/article.md

@@ -55,9 +55,9 @@ In JavaScript, there are three types of properties and members:
 
 In many other languages there also exist "protected" fields: accessible only from inside the class and those extending it. They are also useful for the internal interface. They are in a sense more widespread than private ones, because we usually want inheriting classes to gain access to properly do the extension.
 
-Protected fields are not implemented in Javascript on the language level, but in practice they are very convenient, so they are emulated.
+Protected fields are not implemented in JavaScript on the language level, but in practice they are very convenient, so they are emulated.
 
-In the next step we'll make a coffee machine in Javascript with all these types of properties. A coffee machine has a lot of details, we won't model them to stay simple (though we could).
+In the next step we'll make a coffee machine in JavaScript with all these types of properties. A coffee machine has a lot of details, we won't model them to stay simple (though we could).
 
 ## Protecting "waterAmount"
 
@@ -186,7 +186,7 @@ So protected fields are naturally inheritable. Unlike private ones that we'll se
 
 [recent browser=none]
 
-There's a finished Javascript proposal, almost in the standard, that provides language-level support for private properties and methods.
+There's a finished JavaScript proposal, almost in the standard, that provides language-level support for private properties and methods.
 
 Privates should start with `#`. They are only accessible from inside the class.
 
@@ -325,6 +325,6 @@ Hiding complexity
 To hide internal interface we use either protected or public properties:
 
 - Protected fields start with `_`. That's a well-known convention, not enforced at the language level. Programmers should only access a field starting with `_` from its class and classes inheriting from it.
-- Private fields start with `#`. Javascript makes sure we only can access those from inside the class.
+- Private fields start with `#`. JavaScript makes sure we only can access those from inside the class.
 
 Right now, private fields are not well-supported among browsers, but can be polyfilled.

1-js/11-async/07-microtask-queue/article.md

@@ -30,7 +30,7 @@ As said in the [specification](https://tc39.github.io/ecma262/#sec-jobs-and-job-
 - The queue is first-in-first-out: tasks enqueued first are run first.
 - Execution of a task is initiated only when nothing else is running.
 
-Or, to say that simply, when a promise is ready, its `.then/catch/finally` handlers are put into the queue. They are not executed yet. Javascript engine takes a task from the queue and executes it, when it becomes free from the current code.
+Or, to say that simply, when a promise is ready, its `.then/catch/finally` handlers are put into the queue. They are not executed yet. JavaScript engine takes a task from the queue and executes it, when it becomes free from the current code.
 
 That's why "code finished" in the example above shows first.
 
@@ -54,7 +54,7 @@ Now the order is as intended.
 
 ## Event loop
 
-In-browser Javascript, as well as Node.js, is based on an *event loop*.
+In-browser JavaScript, as well as Node.js, is based on an *event loop*.
 
 "Event loop" is a process when the engine sleeps and waits for events, then reacts on those and sleeps again.
 

1-js/11-async/08-async-await/article.md

@@ -12,7 +12,7 @@ async function f() {
 }
 ```
 
-The word "async" before a function means one simple thing: a function always returns a promise. Even If a function actually returns a non-promise value, prepending the function definition with the "async" keyword directs Javascript to automatically wrap that value in a resolved promise.
+The word "async" before a function means one simple thing: a function always returns a promise. Even If a function actually returns a non-promise value, prepending the function definition with the "async" keyword directs JavaScript to automatically wrap that value in a resolved promise.
 
 For instance, the code above returns a resolved promise with the result of `1`, let's test it:
 

1-js/12-generators-iterators/1-generators/01-pseudo-random-generator/task.md

@@ -5,7 +5,7 @@ There are many areas where we need random data.
 
 One of them is testing. We may need random data: text, numbers etc, to test things out well.
 
-In Javascript, we could use `Math.random()`. But if something goes wrong, we'd like to be able to repeat the test, using exactly the same data.
+In JavaScript, we could use `Math.random()`. But if something goes wrong, we'd like to be able to repeat the test, using exactly the same data.
 
 For that, so called "seeded pseudo-random generators" are used. They take a "seed", the first value, and then generate next ones using a formula. So that the same seed yields the same sequence, and hence the whole flow is easily reproducible. We only need to remember the seed to repeat it.
 

1-js/12-generators-iterators/1-generators/article.md

@@ -462,7 +462,7 @@ If we don't catch the error there, then, as usual, it falls through to the outer
 - Inside generators (only) there exists a `yield` operator.
 - The outer code and the generator may exchange results via `next/yield` calls.
 
-In modern Javascript, generators are rarely used. But sometimes they come in handy, because the ability of a function to exchange data with the calling code during the execution is quite unique.
+In modern JavaScript, generators are rarely used. But sometimes they come in handy, because the ability of a function to exchange data with the calling code during the execution is quite unique.
 
 Also, in the next chapter we'll learn async generators, which are used to read streams of asynchronously generated data in `for` loop.