HTTP (Hypertext Transfer Protocol)

HTTP (Hypertext Transfer Protocol) is an application-layer protocol for transmitting hypermedia documents, such as HTML. It was designed for communication between web browsers and web servers, but it has become a foundational protocol for communication over the internet, powering data exchange for web applications, APIs, and various other services.

Key Characteristics:
1. Client-Server Model: HTTP operates within a client-server architecture, where a client (e.g., a web browser) sends a request to a server, and the server returns a response.
2. Request-Response Cycle: Every interaction consists of a client sending an HTTP request message to a server, and the server returning an HTTP response message.
3. Statelessness: HTTP is a stateless protocol, meaning each request from a client to a server is treated as an independent transaction. The server does not retain any memory of past requests. While the core protocol is stateless, mechanisms like cookies and sessions are used at a higher level to manage stateful interactions.
4. Methods (Verbs): HTTP defines several request methods (often called verbs) to indicate the desired action to be performed on the identified resource. Common methods include:
* GET: Retrieves data from the server.
* POST: Submits data to be processed to a specified resource.
* PUT: Updates a resource or creates one if it does not exist.
* DELETE: Deletes a specified resource.
* PATCH: Applies partial modifications to a resource.
* HEAD: Similar to GET, but retrieves only the headers, not the body.
* OPTIONS: Describes the communication options for the target resource.
5. Status Codes: After receiving and interpreting a request, a server responds with an HTTP status code, indicating the outcome of the request. These codes are grouped into five classes:
* 1xx (Informational): Request received, continuing process.
* 2xx (Success): The action was successfully received, understood, and accepted (e.g., 200 OK, 201 Created).
* 3xx (Redirection): Further action needs to be taken by the user agent to fulfill the request (e.g., 301 Moved Permanently, 302 Found).
* 4xx (Client Error): The request contains bad syntax or cannot be fulfilled (e.g., 400 Bad Request, 401 Unauthorized, 404 Not Found).
* 5xx (Server Error): The server failed to fulfill an apparently valid request (e.g., 500 Internal Server Error, 503 Service Unavailable).
6. Headers: Both requests and responses contain headers, which provide metadata about the message, such as content type, caching instructions, authentication credentials, etc.

Versions:
* HTTP/1.0: The initial version, with a simple request-response model where each request typically opened a new TCP connection.
* HTTP/1.1: Introduced persistent connections (keeping TCP connections open for multiple requests), pipelining, host headers, and chunked transfer encoding, significantly improving performance.
* HTTP/2: A major revision that introduced multiplexing (allowing multiple requests/responses over a single connection), header compression, and server push, further enhancing efficiency and speed.
* HTTP/3: The latest major version, built on QUIC (Quick UDP Internet Connections) instead of TCP, aiming to reduce latency and improve reliability, especially in challenging network conditions.

In Rust, interacting with HTTP typically involves using external crates. For client-side operations (making requests), `reqwest` is a popular asynchronous HTTP client. For server-side operations (building web applications or APIs), frameworks like `actix-web`, `warp`, and `axum` are commonly used.

```rust
// Cargo.toml dependencies:
// reqwest = { version = "0.11", features = ["json"] }
// tokio = { version = "1", features = ["full"] }

use reqwest::Error;
use serde::Deserialize;

// Define a struct to deserialize the JSON response into
#[derive(Deserialize, Debug)]
struct Todo {
    #[serde(rename = "userId")]
    user_id: u32,
    id: u32,
    title: String,
    completed: bool,
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    // The URL for the public API we want to fetch data from
    let url = "https://jsonplaceholder.typicode.com/todos/1";

    println!("Attempting to fetch data from: {}", url);

    // Create an HTTP client
    let client = reqwest::Client::new();

    // Make an asynchronous GET request to the specified URL
    let response = client.get(url).send().await?;

    // Check if the request was successful (status code 2xx)
    if response.status().is_success() {
        println!("HTTP Status: {}", response.status());

        // Deserialize the JSON response body directly into our Todo struct
        // Requires the `json` feature for `reqwest` and `serde_json` as a dependency.
        let todo_item: Todo = response.json().await?;

        println!("\nFetched Todo Item:");
        println!("  User ID: {}", todo_item.user_id);
        println!("  ID:      {}", todo_item.id);
        println!("  Title:   {}", todo_item.title);
        println!("  Done?:   {}", todo_item.completed);
    } else {
        // If the request was not successful, print the status code and response body
        eprintln!("Request failed with status: {}", response.status());
        let error_text = response.text().await?;
        eprintln!("Response body: {}", error_text);
    }

    Ok(())
}
```