Abstract:

In this video, the speaker embarks on an exploratory journey into building a web application using Rust's axum framework and askama templating engine, aiming to recreate elements of a previous Go-based HTMX project. The setup of the axum server, integration with tokyo for async operations, and dependency management with cargo are detailed. The core challenge revolves around askama's templating paradigm, specifically the struggle to achieve a compositional, fragment-based templating style (similar to Go's named blocks within a single file) versus askama's reliance on file-per-component or inheritance. While appreciating Rust's strong type safety and clean server code, the speaker expresses significant frustration with askama's templating workflow and the lengthy compile times, ultimately deeming the askama experiment a "fail" for his desired workflow, and plans to explore go temple or other Rust templating options next. Personal anecdotes about daily routines, fitness, and life optimizations are interwoven throughout the technical discussion.

Exploring Axum and Askama: A Rust Web Development Experiment

• 0:00 Introduction to Axum: The speaker begins an experiment with axum, a Rust web framework, aiming to build a project previously done in Go.
• 0:44 Axum's Foundation: axum is built on the Tower abstraction, a library for robust networking clients and servers, designed around a request-response pattern and protocol agnostic. It integrates with Tokyo (async runtime), Hyper (server), and Tower (middleware).
• 2:20 Setting Up Dependencies: Key Rust crates added include axum, tokyo (with "full" features), clap (for CLI arguments), serde (for serialization/deserialization), askama (templating engine), and rand.
• 4:46 Personal Routines & Life Hacks: The speaker shares details about his daily work-life balance, including his morning routine with kids, dedicated date nights with his wife, unplugging from the internet on weekends, muting social media notifications, and "life optimizations" like wearing stretchy pants suitable for both work and workouts to save time.
• 11:35 Fitness & Health: Discussion on sleep (8-8.5 hours), protein intake (200g+), and supplements. Shares views on optimal workout times for men (2-5 PM) vs. women (morning), emphasizing consistency over optimal timing.
• 12:41 Basic Axum Server: Demonstrates a "Hello World" axum setup with a router, get handler, binding to an address, and serving as a hyper service.
• 15:35 Templating Challenges with Askama: The speaker integrates askama for HTML templating, appreciating its type safety and automatic conversion of structs to HTML. However, he quickly encounters difficulties with askama's macro system and structure, desiring a more compositional approach (like Go's named template blocks within a single file) rather than askama's default of defining templates in separate files or relying on inheritance.
• 17:50 Rust's Learning Curve & Crate Ecosystem: Expresses frustration with Rust's need for explicit crate additions (e.g., rand, lazy_static) for functionalities often standard in other languages, describing it as "busy work" that can hinder teaching.
• 20:50 Server & Templating Logic: Continues to build out the axum server and askama templates, attempting to define query parameters, handlers, and render HTML.
• 32:00 Motivation for Rust & HTMX: The primary motivation for using Rust in this project is to leverage shuttle.rs for easy deployment, aiming for a "creamy smooth" website experience. He prefers HTMX's server-driven actions over client-side frameworks like React, criticizing React's rendering model and mixing of templating with data fetching.
• 38:00 Askama Macro & Inheritance Struggles: Attempts to define and reuse template "macros" or "blocks" within askama, but hits limitations with scope and the requirement for macros to be at the "top level" or imported, leading to excessive file splitting.
• 1:02:00 Shared State Management: Integrates lazy_static and tokio::sync::Mutex to manage shared, mutable state (a vector of Timing structs) within the axum application.
• 1:12:00 Successful (but unsatisfactory) Templating: Eventually achieves functional templating by breaking every small component into its own HTML file, which the speaker explicitly states is not his preferred method.
• 1:20:00 Final Verdict on Askama: The speaker concludes the askama experiment as a "fail" for his desired workflow due to its rigid templating structure that forces extensive file splitting instead of allowing multiple render fragments within a single file.
• 1:22:00 Rust Web Framework Positive: Despite askama's issues, he praises axum itself for its clean code and ease of use, making the Rust web framework part a "pass."
• 1:30:00 Future Plans: Plans to explore go temple next for its type safety and speed, and potentially other Rust templating engines like sailfish or handlebars.