add the chapter 6.1 - HTTP verbs

Author: ishtms

Readme.md

@@ -161,5 +161,13 @@ The repo for our backend framework- [Velocy](https://github.com/ishtms/velocy)
         - [Starting our web server](/chapters/ch06.0-http-deep-dive.md#starting-our-web-server)
         - [Testing our web server](/chapters/ch06.0-http-deep-dive.md#testing-our-web-server)
         - [Testing with `cURL`](/chapters/ch06.0-http-deep-dive.md#testing-with-curl)
+- [HTTP Verbs](/chapters/ch06.1-http-verbs.md)
+    - [`GET` - Retrieve data](/chapters/ch06.1-http-verbs.md#get---retrieve-data)
+    - [`POST` - Create something](/chapters/ch06.1-http-verbs.md#post---create-something)
+    - [`PUT` - Replace or create](/chapters/ch06.1-http-verbs.md#put---replace-or-create)
+    - [`HEAD` - Retrieve metadata](/chapters/ch06.1-http-verbs.md#head---retrieve-metadata)
+    - [`DELETE` - Remove from existence](/chapters/ch06.1-http-verbs.md#delete---remove-from-existence)
+    - [`PATCH` - Partial updates](/chapters/ch06.1-http-verbs.md#patch---partial-updates)
+    - [A small recap](/chapters/ch06.1-http-verbs.md#a-small-recap)
 
 ![](https://uddrapi.com/api/img?page=readme)

chapters/ch06.0-http-deep-dive.md

@@ -155,106 +155,108 @@ That's a lot of stuff to digest. One thing to notice is two different operators
 
 Let me walk through this line by line:
 
-```
+```bash
 Trying 127.0.0.1:3000...
 ```
 
 This line is indicating that `cURL` is attempting to establish a connection to the IP address 127.0.0.1. This IP address is also known as localhost and it refers to the local computer you are currently working on.
 
 The connection is being made on port number 3000, which is a number used to identify a specific process to which data is being sent or received. We'll talk about PORTs in the next chapter.
 
-```
+```bash
 Connected to localhost (127.0.0.1) port 3000 (#0)
 ```
 
 This means the connection to the specified IP address and port has been successfully established. This is great news and means that you can proceed with your task without any further delay.
 
 The (#0) in the message refers to the connection index. This is helpful information, especially if you're making multiple connections at the same time. By keeping track of the connection index, you can avoid any confusion or errors that could arise from mixing up different connections.
 
-```
+```bash
 > GET / HTTP/1.1
 ```
 
 **`cURL`** is sending an HTTP request to the server using the HTTP method **`GET`**. The **`/`** after the method indicates that the request is being made to the root path, or the root endpoint of the server.
 
-```
+```bash
 > Host: localhost:3000
 ```
 
 This line specifies that the `cURL` command is setting the **`Host`** header on the **request**, which tells the server the domain name and port of the request.
 
-```
+```bash
 > User-Agent: curl/7.87.0
 ```
 
 This line is also part of the HTTP request headers. It includes the **`User-Agent`** header, which identifies the client making the request. In this case, it indicates that the request is being made by **`curl`** version 7.87.0.
 
-```
+```bash
 > Accept: */*
 ```
 
 This line sets the **`Accept`** header, which tells the server what types of response content the client can handle. In this case, it indicates that the client accepts any type of content.
 
-```
+```bash
 >
 ```
 
 This line indicates the end of the HTTP request headers. An empty line like this separates the headers from the request body, which is not present in this case because it's a `GET` request. We'll talk about `POST` and other http verbs/methods in the upcoming chapters.
 
-```
+```bash
 Mark bundle as not supporting multiuse
 ```
 
 This is an internal log message from **`curl`** and doesn't have a direct impact on the request or response interpretation. It's related to how **`curl`** manages multiple connections in a session.
 
-```
+```bash
 < HTTP/1.1 200 OK
 ```
 
 This line is part of the HTTP response. It indicates that the server has responded with an HTTP status code **`200 OK`**, which means the request was successful. Again, we're going to understand HTTP status codes in the next chapter. For now, it's enough to think that any status code in the form `2xx`, where x is a number, means everything is fine.
 
-```
+```bash
 < Date: Wed, 23 Aug 2023 13:13:32 GMT
 ```
 
 This line is part of the HTTP response headers. Important thing to note, this is the header set by the server, and not the client. It includes the **`Date`** header, which indicates the date and time when the response was generated on the server.
 
-```
+```bash
 < Connection: keep-alive
 ```
 
 This line is part of the response headers and informs the client that the server wants to maintain a persistent connection, and re-use the connection for potential future requests. This helps with the performance.
 
-```
+```bash
 < Keep-Alive: timeout=5
 ```
 
 This line, also part of the response headers, specifies the duration of time (5 seconds in this case) that the server will keep the connection alive if no further requests are made.
 
-```
+```bash
 < Content-Length: 11
 ```
 
 This line indicates the length of the response content in bytes. In this case, the response body has a length of 11 bytes.
 
-```
+```bash
 <
 ```
 
 This line marks the end of the response headers and the beginning of the response body.
 
-```
+```bash
 Connection #0 to host localhost left intact
 ```
 
 This line is a log message from **`curl`** indicating that the connection to the server is being left open (**`intact`**) and not closed immediately after receiving the response. It could potentially be reused for subsequent requests.
 
-```
+```bash
 Hello world%
 ```
 
 This is the actual response body returned by the server. In this case, it's a simple text string saying "Hello world". The `%` is nothing to worry about. It indicates that the response doesn't ends with a `\n` character.
 
 Now that we understand what are the basic components of the `request` and the `response`, let's understand these components in more detail, in the next chapter
 
+[![Read Prev](/assets/imgs/next.png)](/chapters/ch06.1-http-verbs.md)
+
 ![](https://uddrapi.com/api/img?page=http_deep_dive)

chapters/ch06.1-http-verbs.md

@@ -0,0 +1,120 @@
+[![Read Prev](/assets/imgs/prev.png)](/chapters/ch06.0-http-deep-dive.md)
+
+## HTTP Verbs
+
+In the previous chapter, we made a simple request to `http://localhost:3000` with `cURL` and received the following output on the terminal: 
+
+```bash
+$ curl http://localhost:3000 -v
+*   Trying 127.0.0.1:3000...
+* Connected to localhost (127.0.0.1) port 3000 (#0)
+> GET / HTTP/1.1
+> Host: localhost:3000
+> User-Agent: curl/7.87.0
+> Accept: */*
+>
+* Mark bundle as not supporting multiuse
+< HTTP/1.1 200 OK
+< Date: Wed, 23 Aug 2023 13:13:32 GMT
+< Connection: keep-alive
+< Keep-Alive: timeout=5
+< Content-Length: 11
+<
+* Connection #0 to host localhost left intact
+Hello world%
+```
+
+Our focus of this chapter will be the first line of the request:
+
+```bash
+> GET / HTTP/1.1
+```
+
+This starts with `GET` which is a **HTTP method** or commonly called as HTTP verb, because they describe the action. These HTTP methods are an essential part of the communication process between client applications, such as web browsers, and web servers. They provide a structured and standardized way for client applications to interact with web servers, ensuring that communication is clear and concise.
+
+HTTP methods offer a set of instructions for the server to carry out, which can include retrieving a resource, submitting data, or deleting a resource. These methods are essential for ensuring that client applications can perform a variety of tasks in a streamlined and efficient way.
+
+The most commonly used HTTP methods include `GET`, `POST`, `PUT`, `DELETE`, and `PATCH`, each with a specific purpose and set of rules. For example, the `GET` method is used to retrieve data from a server, while the `POST` method is used to submit data to a server for processing. By following these rules, client applications can communicate effectively with web servers, ensuring that data is transmitted correctly and that the server can respond appropriately.
+
+### `GET` - Retrieve data
+
+The most basic example of the `GET` method is typing any URL in the browser and pressing enter. You're looking to `GET` the contents of a certain website. 
+
+Then, the browser sends a request to the server that hosts the website, asking for the content you want to see. The server processes the request and sends a response back to your browser with the content you requested.
+
+The `GET` method helps digital content (like text, pictures, HTML pages, stylesheets and sounds) appear on your web browser. 
+
+When a client sends a GET request to a server, the server should only return data to the client and not modify or change its state. This means that the server should not alter any data on the server-side or perform any actions that could modify the system's state in any way. 
+
+This is important to ensure that the data requested by the client is accurate and consistent with the server-side data. By following this protocol, developers can ensure that their applications function smoothly and without any unexpected side effects that could cause problems in the future.
+
+> Note: It's technically possible to modify anything on a GET request from the server side, but it's a bad practice and goes against standard HTTP protocol rules. Stick to the REST API guidelines for good API design.
+
+### `POST` - Create something
+
+The `POST` method serves a different purpose compared to the `GET` method. While `GET` is used for retrieving data, `POST` is employed when you want to send data to a server, to create a new resource on the server.
+
+Imagine you're filling out a form on a website to create a new account. When you submit the form, the website sends a `POST` HTTP request to send the information you provided (such as your username, password, and email) to the server. The server processes this data, typically validating it, and if everything is fine - create a new user account.
+
+Just like with `GET`, it's crucial to follow proper HTTP API guidelines when using the `POST` method. Ensuring that your `POST` requests only create data and don't have unintended side effects helps maintain the integrity of your application and the server's data.
+
+> Note: Again, it is technically possible to use the `POST` method to retrieve data from a server, or update data, it's considered non-standard and goes against conventional HTTP practices. 
+
+### `PUT` - Replace or Create
+
+The PUT method is used to change or replace data that already exists on the server, completely. It's important to remember that, according to HTTP API guidelines, the PUT request should not be used to update only part of the content. 
+
+You may ask, aren't `POST` and `PUT` same as they do the same thing - `CREATE` data if it doesn't exist? There's a difference.
+
+The main difference between the `PUT` and `POST` methods is that PUT is considered **idempotent**. This means that calling it once or multiple times in a row will result in the same outcome, without any additional side effects. 
+
+In contrast, successive identical [POST](<https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST>) requests may have additional effects, such as creating multiple instances of a resource or submitting duplicate orders.
+
+### `HEAD` - Retrieve Metadata
+
+The `HEAD` method shares a resemblance to the `GET` method in that it retrieves information from the server, but with one fundamental difference: it only retrieves the metadata associated with a resource, not the resource's actual content. 
+
+Metadata can include details like the resource's size, modification timestamp, content-type, and more.
+
+When a `HEAD` request is made to a server, the server processes the request in a manner similar to a `GET` request, but instead of sending back the full content, it responds with just the metadata in the HTTP headers. This can be useful when a client needs information about a resource without the need to transfer the entire content, which can save bandwidth and improve performance.
+
+For example, imagine a web page that lists links to various files for download. When a user clicks on a link, the client can initiate a `HEAD` request to gather information about the file, such as its size, without actually downloading the file itself.
+
+By using the `HEAD` method when needed, we can optimize data retrieval, minimize unnecessary network traffic, and obtain crucial resource information efficiently and quickly.
+
+> It's worth noting that servers are not required to support the `HEAD` method, but when they do, they should ensure that the metadata provided in the response headers accurately reflects the current state of the resource.
+
+### `DELETE` - Remove from existence
+
+The `DELETE` method is used when you need to remove or delete a specific resource from the server. When using the `DELETE` method, it's important to know that the action is **idempotent**. This means that no matter how many times you execute the same `DELETE` request, the outcome remains the same – the targeted resource is removed.
+
+We should be careful when using the DELETE method, as it's purpose is to permanently remove the resource from the server. To avoid accidental or unauthorized deletions, it's recommended to use proper authentication and authorization mechanisms. 
+
+After successfully deleting a resource, the server may respond with a `204 No Content` status code to indicate that the resource has been removed, or a 404 Not Found status code if the resource was not found on the server.
+
+If you only need to remove part of something and not the whole thing, using the `DELETE` method might not be the best idea. To make things clear and well-organized, it's better to identify each part as a separate resource, like with the `PATCH` method for partial updates.
+
+### `PATCH` - Partial updates
+
+The `PATCH` method is used to partially update an existing resource on the server. `PATCH` is different from the `PUT` method, which replaces the entire resource. With `PATCH`, you can modify only the specific parts of the resource's representation that you want to change.
+
+So, if you're looking to update a document, or update a user, use the `PATCH` method.
+
+PATCH requests provide instructions to the server on how to modify a resource. These instructions may include adding, modifying, or removing fields or attributes. The server executes the instructions and makes the changes to the resource accordingly.
+
+### A small recap
+
+| Method Name | Description                                                                                                      |
+| ----------- | ---------------------------------------------------------------------------------------------------------------- |
+| GET         | Transfers a current representation of the target resource to the client.                                         |
+| HEAD        | Same as GET, but doesn't transfer the response content - only the metadata.                                      |
+| POST        | Creates new data.                                                                                                |
+| PUT         | Replaces the current representation of the target resource with the request content, if not found - creates one. |
+| DELETE      | Removes all current representations of the target resource.                                                      |
+| PATCH       | Modifies/Updates data partially.                                                                                 |
+
+There are mother HTTP methods as well, but these are the most commonly used ones, and would suffice for most use-cases.
+
+In the next chapter, we'll take a look at status codes.
+
+![](https://uddrapi.com/api/img?page=http_verbs)