chore: fixing content

Author: Hubert Koster

docs/core-concepts/_category_.json

@@ -1,5 +1,5 @@
 {
-  "label": "Core Concepts",
+  "label": "Core concepts",
   "position": 2,
   "link": {
     "type": "generated-index",

docs/core-concepts/api-calls-anatomy/index.md

@@ -1,6 +1,6 @@
 ---
 title: API calls' anatomy
-hide_title: true
+hide_title: false
 draft: false
 sidebar_label: API calls' anatomy
 sidebar_position: 1
@@ -27,26 +27,26 @@ Some of these API calls automatically subscribe (e.g. [ticks](https://api.deriv.
 
 For example, you can call [Tick History](https://api.deriv.com/api-explorer#ticks_history) to receive tick history data. But when you add the `subscribe` option to this call, you will receive the tick history data you requested in the first response, and you will continue to receive a new response every time there is a new tick published by the server for the given symbol.
 
-In the message stream from `subscribe` there is a field called `subscription`, this is the `Stream ID`. with this ID you can identify the message stream in your logic and stop the stream with `Forget` and `Forget All` API calls.
+In the message stream from `subscribe`, there is a field called `subscription`. This is the `Stream ID`. With this ID, you can identify the message stream in your logic and stop the stream with `Forget` and `Forget All` API calls.
 
 The data provided by API calls with the `subscribe` functionality can be used as a data source for other API calls and features.
 
 ### Send
 
-If you call the API with the `send` functionality, then the server will only send back the requested data one time. In order to get updated data you have to send the API call again. Usually, this method is used when you get other API call responses or UI events such as `Click`, `Scroll` and more.
+If you call the API with the `send` functionality, then the server will only send back the requested data one time. In order to get updated data, you have to send the API call again. Usually, this method is used when you get other API call responses or UI events such as `Click`, `Scroll`, and more.
 
 ### Forget
 
-If you want to stop the message Stream created by `subscribe`, you will have to call the `Forget` API call with the correct `Stream ID`. Otherwise, you can use the `Forget All` API call to stop streams by their `Method name`.
+If you want to stop the message stream created by `subscribe`, you will have to call the `Forget` API call with the correct `Stream ID`. Otherwise, you can use the `Forget All` API call to stop streams by their `Method name`.
 
 :::caution
-For more information on the `Forget` API call, you can have a look at [Forget](https://api.deriv.com/api-explorer#forget) and [Forget All](https://api.deriv.com/api-explorer#forget_all) in the API explorer.
+For more information on the `Forget` API call, have a look at [Forget](https://api.deriv.com/api-explorer#forget) and [Forget All](https://api.deriv.com/api-explorer#forget_all) in the API explorer.
 :::
 
 
 ## Request data
 
-In order to make it easier for you to handle the `request` and `response` flow of your WebSocket connection, every deriv WebSocket API calls has a general structure. you can use it for caching, validation, request and response synchronization are some of the things you can use it for.
+To make it easier for you to handle the request and response flow of your WebSocket connection, each Deriv WebSocket API call follows a standardised structure. You can use it for caching, validation, request, and response synchronisation.
 
 #### API call method name
 
@@ -58,11 +58,11 @@ API Call Method Name is always required. this field determines the data you'll g
 
 ### Required fields
 
-Every request data has several required fields which you must provide them and they may contain optional fields as well, let's explore this with an example on `Residence List`:
+Each request data has mandatory fields that you must provide, and it may also include optional fields. Let's explore this with an example from `Residence List`.
 
-`Residence List` Call returns a list of countries and 2-letter country codes, suitable for populating the account opening form.
+A `Residence List` call returns a list of countries and 2-letter country codes, suitable for populating the account opening form.
 
-Request data for this call is like so:
+The request data for this call is as below:
 
 ```ts
 {
@@ -72,19 +72,19 @@ Request data for this call is like so:
 }
 ```
 
-The `residence_list` field is the `method name` for the call and is required. There may be other required fields which are related to this type of the request you want to send. if you want to know more about `Residence List` and other API calls please check them out in the [API Explorer](https://api.deriv.com/api-explorer#residence_list).
+The `residence_list` field is the `method name` for the call and is required. There may be other required fields related to this type of the request you want to send. To know more about `Residence List` and other API calls, please check them out in [API Explorer](https://api.deriv.com/api-explorer#residence_list).
 
 ### Optional fields
 
-Every Call has several `Optional` fields as well, `passthrough` and `req_id` are always part of the request data but you can choose to opt-out and not use them.
+Every call has several `Optional` fields as well. `Passthrough` and `req_id` are always part of the request data but you can choose to opt out and not use them.
 
-#### `passthrough` field
+#### The `passthrough` field
 
-Whatever you pass to this field will be returned back to you inside a `response` object, this can be helpful when you need to simulate a stateful flow for your `requests` and `responses`.
+Whatever you pass to this field will be returned back to you inside a `response` object. This can be helpful when you need to simulate a stateful flow for your `requests` and `responses`.
 
-#### `req_id` field
+#### The `req_id` field
 
-You may need to `tag` your requests and pass them through our `WebSocket` calls. you can do it by passing a `number` to this field. it can be helpful when you need to map `requests` to `responses`.
+You may need to `tag` your requests and pass them through our `WebSocket` calls. You can do so by passing a `number` to this field. it can be helpful when you need to map `requests` to `responses`.
 
 :::caution
 To learn about additional optional fields specific to each API call, please refer to our [API Explorer](https://api.deriv.com/api-explorer).

docs/core-concepts/websocket/index.md

@@ -77,7 +77,7 @@ socket.onerror = function (error) {
 };
 ```
 
-## Why do we need websocket and when should we avoid it?
+## Why do we need WebSockets and when should we avoid them?
 
 WebSocket are an essential client-server communication tool and one needs to be fully aware of its utility and avoid scenarios to benefit from its utmost potential. It’s explained extensively in the next section.
 
@@ -95,25 +95,25 @@ WebSocket shouldn’t be taken onboard when old data fetching is the need of the
 
 ## WebSocket vs HTTP
 
-As both HTTP and WebSocket are employed for application communication, people often get confused and find it difficult to pick one out of these two. Have a look at the below-mentioned text and gain better clarity on HTTP and WebSocket.
+As both HTTP and WebSocket protocols are employed for application communication, people often get confused and find it difficult to pick one.
 
-As told previously, WebSocket is a framed and bidirectional protocol. On the contrary, to this, HTTP is a unidirectional protocol functioning above the TCP protocol.
+As told previously, WebSocket is a framed and bidirectional protocol. On the other hand, HTTP is a unidirectional protocol functioning above the TCP protocol.
 
-As WebSocket protocol is capable to support continual data transmission, it’s majorly used in real-time application development. HTTP is stateless and is used for the development of [RESTful](https://de.wikipedia.org/wiki/Representational_State_Transfer) and [SOAP](https://de.wikipedia.org/wiki/SOAP) applications. Soap can still use HTTP for implementation, but REST is widely spread and used.
+As the WebSocket protocol is capable of supporting continual data transmission, it’s majorly used in real-time application development. HTTP is stateless and is used for the development of [RESTful](https://de.wikipedia.org/wiki/Representational_State_Transfer) and [SOAP](https://de.wikipedia.org/wiki/SOAP) applications. SOAP can still use HTTP for implementation, but REST is widely spread and used.
 
-In WebSocket, communication occurs at both ends, which makes it a faster protocol. In HTTP, the connection is built at one end, making it a bit sluggish than WebSocket.
+In WebSocket, communication occurs at both ends, which makes it a faster protocol. In HTTP, the connection is built at one end, making it a bit more sluggish than WebSocket.
 
 WebSocket uses a unified TCP connection and needs one party to terminate the connection. Until it happens, the connection remains active. HTTP needs to build a distinct connection for separate requests. Once the request is completed, the connection breaks automatically.
 
 ## How are WebSocket connections established?
 
-The process starts with a WebSocket handshake that involves using a new scheme ws or wss. To understand quickly, you may consider them equivalent to HTTP and secure HTTP (HTTPS) respectively.
+The process starts with a WebSocket handshake that involves using a new scheme (ws or wss). To help you understand, consider them equivalent to HTTP and secure HTTP (HTTPS) respectively.
 
-Using this scheme, servers and clients are expected to follow the standard WebSocket connection protocol. The WebSocket connection establishment begins with HTTP request upgrading that features a couple of headers such as Connection: Upgrade, Upgrade: WebSocket, Sec-WebSocket- Key, and so on.
+Using this scheme, servers and clients are expected to follow the standard WebSocket connection protocol. The WebSocket connection establishment begins with a HTTP request upgrading that features a couple of headers such as Connection: Upgrade, Upgrade: WebSocket, Sec-WebSocket- Key, and so on.
 
 Here is how this connection is established:
 
-1. **The Request :** Connection Upgrade header denotes the WebSocket handshake while the Sec-WebSocket-Key features Base64-encoded random value. This value is arbitrarily generated during every WebSocket handshake. Besides the above, the key header is also a part of this request.
+1. **The Request :** The Connection Upgrade header denotes the WebSocket handshake while the Sec-WebSocket-Key features Base64-encoded random value. This value is arbitrarily generated during every WebSocket handshake. Besides the above, the key header is also a part of this request.
 
 The above-listed headers, when combined, form an HTTP GET request. It will have similar data in it:
 
@@ -128,7 +128,7 @@ Sec-WebSocket-Version: 13
 Sec-WebSocket-Key: b6gjhT32u488lpuRwKaOWs==
 ```
 
-To clarify, Sec-WebSocket-Version, one can explain the WebSocket protocol version ready to use for the client.
+To clarify Sec-WebSocket-Version, one can explain the WebSocket protocol version ready to use for the client.
 
 2. **The Response:** The response header, Sec-WebSocket-Accept, features the rest of value submitted in the Sec-WebSocket-Key request header. This is connected with a particular protocol specification and is used widely to keep misleading information at bay. In other words, it enhances the API security and stops ill-configured servers from creating blunders in the application development.
 

docs/intro.md

@@ -22,8 +22,8 @@ description: Getting started with Deriv API
 
 Our Documentation is divided in several sections:
 
-- [Core Concepts](category/core-concepts)
-- [Code Examples](category/code-examples)
+- [Core concepts](category/core-concepts)
+- [Code examples](category/code-examples)
 - [Languages](category/languages)
 - [Guides](category/guides)
 - [Setting up a deriv app](/docs/setting-up-a-deriv-application.md)

docs/languages/javascript/project-setup/index.md

@@ -30,13 +30,13 @@ Next, create the required files as you see below:
 touch index.html index.css index.js
 ```
 
-Now, you can open the folder with your prefered code editor or IDE.
-
 :::tip
 We suggest using [Visual Studio Code](https://code.visualstudio.com/) with [Live Server Extension](https://marketplace.visualstudio.com/items?itemName=ritwickdey.LiveServer) enabled. This will help you a lot with implementations.
 :::
 
-Your final code should be:
+Now open the `index.html` file or use the [Live Server Extension](https://marketplace.visualstudio.com/items?itemName=ritwickdey.LiveServer)
+
+Now, change the content of the files using the following approach:
 
 ```js title="index.js"
 console.log("we will create our websocket connection here");

docs/languages/javascript/websocket-connection/index.md

@@ -17,10 +17,9 @@ If you're not familiar with WebSockets, please check out [our documentation](/do
 :::
 
 ### Set up a WebSocket connection
+<!-- To create a websocket connection, we want to use the Deriv websocket URL with an `app_id`. You can create your own app_id within your [dashboard](/dashboard) or keep the default `1089` app_id for testing. Keep in mind that eventually, you should make your own app_id. Especially if you would like to monetize your application. -->
 
-To create a websocket connection, we want to use the Deriv websocket URL with an `app_id`. You can create your own app_id within your [dashboard](/dashboard) or keep the default `1089` app_id for testing. Keep in mind that eventually, you should make your own app_id. Especially if you would like to monetize your application.
-
-To setup the connection, add the following code in your JavaScript file:
+Next, we'll create a WebSocket connection to Deriv WebSocket Server as seen below:
 
 ```js title="index.js"
 const app_id = 1089; // Replace with your app_id or leave as 1089 for testing.
@@ -72,7 +71,7 @@ Now, open the `index.html` file in our browser and check your developer console.
 
 ### Send and receive data
 
-Our WebSocket server provides a [ping/pong](/api-explorer#ping) functionality. Let's use it in our demo project to send and receive data. Change the event listeners for `open` and `message` as below:
+Our WebSocket server provides [ping/pong](/api-explorer#ping) functionality. Let's use it in our demo project to send and receive data. Change the event listeners for `open` and `message` as below:
 
 :::caution
 The `send` function on the WebSocket connection, only receives `string`, `ArrayBuffer`, `Blob`, `TypedArray` and `DataView`. You can read more about them on [MDN](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send). This means, if we want to send an `object`, we have to stringify it with `JSON.stringify` first.