## Day 1: First Encounter with Hyperlane\n\nI stumbled upon the Hyperlane Rust HTTP framework on GitHub and was immediately captivated by its performance metrics. The official documentation states:\n\n> \"Hyperlane is a high-performance and lightweight Rust HTTP framework designed to simplify the development of modern web services while balancing flexibility and performance.\"\n\nI decided to use it for my distributed systems course project. I started with the `Cargo.toml` file:\n\n```toml\n[dependencies]\nhyperlane = \"5.25.1\"\n```\n\n## Day 3: The Magic of Context Abstraction\n\nToday, I delved into the design of Hyperlane's `Context`. In traditional frameworks, you would retrieve the request method like this:\n\n```rust\nlet method = ctx.get_request().await.get_method();\n```\n\nBut Hyperlane offers a more elegant approach:\n\n```rust\nlet method = ctx.get_request_method().await;\n```\n\n**My Understanding**:\n\nThis kind of chained call simplification is akin to Rust's `?` operator—it flattens nested calls and significantly enhances code readability. Hyperlane cleverly auto-generates getter/setter methods, mapping `request.method` to `get_request_method()`.\n\n## Day 5: Routing and HTTP Method Macros\n\nWhile attempting to implement RESTful APIs, I discovered Hyperlane's method macros:\n\n```rust\n#[methods(get, post)]\nasync fn user_api(ctx: Context) {\n // Handle GET/POST requests\n}\n\n#[delete]\nasync fn delete_user(ctx: Context) {\n // Handle DELETE requests\n}\n```\n\n**Encountered Issue**:\n\nAt first, I forgot to add the `async` keyword to my route functions, which led to a half-hour of confusion due to compiler errors. Rust's asynchronous programming truly demands constant attention to detail!\n\n## Day 7: Response Handling Exploration\n\nI spent the entire day studying the response APIs and created a comparison table to aid my understanding:\n\n| Operation Type | Example Code | Purpose |\n| ----------------- | ------------------------------------------------- | ------------------------------------- |\n| Retrieve Response | `let res: Response = ctx.get_response().await;` | Obtain the complete response object |\n| Set Status Code | `ctx.set_response_status_code(404).await;` | Set a 404 status |\n| Send Response | `ctx.set_response_body(\"Data\").send().await;` | Send while maintaining the connection |\n| Close Immediately | `ctx.set_response_body(\"Bye\").send_once().await;` | Send and immediately close |\n\n**Important Discovery**:\n\nThe difference between `send()` and `send_once()` lies in the maintenance of the TCP connection, which is crucial for long-lived connections.\n\n## Day 10: Middleware Onion Model\n\nThrough the diagrams in the documentation, I understood the middleware workflow:\n\n```mermaid\ngraph LR\n A[Request] --> B[Middleware 1]\n B --> C[Middleware 2]\n C --> D[Controller]\n D --> E[Middleware 3]\n E --> F[Middleware 4]\n F --> G[Response]\n```\n\n**My Implementation**:\n\nI wrote a simple logging middleware:\n\n```rust\nasync fn log_middleware(ctx: Context, next: Next) {\n let start = Instant::now();\n println!(\"-> {} {}\", ctx.get_request_method().await, ctx.get_request_path().await);\n\n next.run(ctx).await; // Call the next middleware\n\n println!(\"<- {}ms\", start.elapsed().as_millis());\n}\n```\n\n## Day 14: Practical Route Parameters\n\nToday, I implemented a dynamic user interface:\n\n```rust\n// Register route\nserver.route(\"/user/{id}\", user_handler).await;\n\n// Handler function\nasync fn user_handler(ctx: Context) {\n let user_id = ctx.get_route_param(\"id\").await;\n let user = db.find_user(user_id).await;\n ctx.set_response_body_json(&user).await.send().await;\n}\n```\n\n**Pitfall Record**:\n\nWhen initially attempting to use a regex route like `/user/{id:\d+}`, I forgot to escape the backslash, leading to a compilation error. Rust's raw string literals came to the rescue:\n\n```rust\nserver.route(r\"/user/{id:\d+}\", user_handler).await;\n```\n\n## Day 20: Performance Test Surprise\n\nI ran a wrk test on an AWS t2.micro instance:\n\n```bash\nwrk -c360 -d60s http://localhost:8000/\n```\n\nThe results were astonishing (compared to other frameworks I learned in class):\n\n| Framework | QPS |\n| --------- | ------- |\n| Hyperlane | 324,323 |\n| Rocket | 298,945 |\n| Gin (Go) | 242,570 |\n| Express | 139,412 |\n\n**Analysis**:\n\nHyperlane's performance is only 5% lower than pure Tokio, yet it provides a complete web framework functionality. Rust's garbage collector-free nature combined with its asynchronous runtime is truly a powerful performance tool!\n\n## Day 25: Version Compatibility Challenge\n\nWhen upgrading to v4.89+, I encountered lifecycle changes:\n\n```rust\n// Recommended way to abort a request\nif should_abort {\n ctx.aborted().await; // New API in v4.89+\n return;\n}\n```\n\n**Lesson Learned**:\n\nIt's crucial to pin version numbers in projects! The execution order of middleware can be entirely different across versions. I found this evolution diagram on GitHub:\n\n```mermaid\ngraph TD\n v3[3.0.0] -->|Middleware before routing| v4[4.0.0]\n v4 -->|Separate request/response middleware| v4_22[4.22.0]\n v4_22 -->|Add aborted| v4_89[4.89.0]\n v4_89 -->|Add closed| v5_25[5.25.1]\n```\n\n## Final Course Project Architecture\n\n```mermaid\ngraph TB\n A[Client] --> B[Nginx]\n B --> C[Hyperlane Gateway]\n C --> D[Authentication Middleware]\n D --> E[Route Distribution]\n E --> F[User Service]\n E --> G[Order Service]\n F --> H[Database]\n G --> H\n```\n\n## Learning Summary\n\n1. **API Design Philosophy**: Hyperlane's chained call design maintains Rust's elegance.\n2. **Performance Secret**: Built on Tokio's asynchronous architecture and zero-copy processing.\n3. **Middleware System**: The onion model provides clear extension points.\n4. **Routing Flexibility**: A balance between simple parameters and regular expressions.\n5. **Version Management**: Carefully read the CHANGELOG to avoid compatibility issues.\n\nThis exploration has given me a deep appreciation for Rust's potential in the web domain. Although Hyperlane is not as feature-rich as frameworks like Django, it is definitely a secret weapon in scenarios where extreme performance is required! Next, I plan to use its WebSocket capabilities to implement a real-time logging system.\n