In this essay, Carson Gross walks through a concrete bug fix in hyperscript to show where AI helped, where it fell short, and why keeping a knowledgeable human in the loop is what kept complexity in check.

In this essay, Carson Gross thinks about the best way for the university to prepare students in the AI era.

In this essay, Carson Gross argues that as AI makes code cheap to produce, understanding code becomes the expensive and scarce resource. He warns of the complexity that LLM code can generate and proposes the subtractive, constraining engineer as the discipline needed to keep systems comprehensible & stable.

Sung Oh demonstrates how to build interactive hypermedia UIs inside MCP Apps using Fixi, Django template partials, and FastMCP. By combining a workout DSL with AI translation and server-rendered HTML fragments, the essay shows how old-fashioned hypermedia techniques work naturally in the new MCP App environment.

In this essay, Carson Gross discusses his advice to young people interested in computer science worried about the future given the advancements in AI.

Building critical software infrastructure with htmx, and how the simplification induced by this approach is interesting for AI-assisted development.

You know, technically, I never said anything about a version four

In this interview, Leonard Richardson, creator of the Richardson Maturity Model for RESTful web services discusses the history of REST, interoperability in APIs and his impression of newer approaches such as GraphQL.

Carson Gross explores the concept of 'vendoring' in software development, where external project sources are copied directly into a project. He covers the benefits of vendoring, such as improved visibility and control over dependencies, and discusses challenges like transitive dependencies and the culture of dependency in modern software development. He also contrasts vendoring with modern dependency management tools, and considers the potential for vendor-first dependency managers to combine the strengths of both approaches. He encourages a rethinking of dependencies and promotes a more independent approach to software development.

This article features an in-depth interview with Chris Wanstrath (defunkt), the co-founder of GitHub and creator of pjax, where he discusses his journey from early web development to creating pjax, an innovative JavaScript library that helped bridge the gap between traditional web navigation and dynamic content loading.

In this interview with software engineer Makinde Adeagbo, he discusses his role in creating Primer, a hypermedia-oriented JavaScript library used at Facebook in the 2000s, and shares insights about building developer tools, Facebook's evolution, and the cyclical nature of web development approaches.

In this in-depth interview, Mike Amundsen, a leading expert on REST and hypermedia, discusses the evolution of hypermedia technologies, highlights unsung pioneers like Paul Otlet, and shares insights on the future of hypermedia in enterprise systems and machine-to-machine interactions.

In this article, Carson Gross compares several alternative libraries and frameworks to htmx that embrace a hypermedia-oriented approach to web development. Carson explores established solutions like Unpoly and Hotwire Turbo, as well as emerging projects like Triptych and htmz, providing developers with a comprehensive overview of hypermedia-driven application development options beyond htmx.

In this article, Joe Fioti describes their journey of simplifying their web application architecture by moving from a complex WebAssembly-based system to a streamlined htmx solution, resulting in significantly reduced code complexity and improved development efficiency.

In this essay, Carson Gross and Alex Petros discuss htmx's future direction and philosophy. They explain how the project aims to emulate jQuery's success through API stability, minimal feature additions, and quarterly releases while continuing to promote hypermedia-driven development and support the broader web development ecosystem.

Carson Gross explores the fascinating lore of htmx, from its playful community memes like "It's So Over/We're So Back" and "Laser Eye Horse" to humorous controversies such as the "Microsoft Purchase Rumor" and the htmx/intercooler.js feud. This essay dives into the vibrant culture, iconic moments, and lighthearted chaos surrounding htmx.

In this collection of tweets, Carson Gross explores unconventional programming principles, including favoring if statements over polymorphism, minimizing abstractions, and prioritizing practical, implementation-driven development. He challenges traditional software 01-frontend norms, advocating for simplicity, locality, and utility over complexity and abstraction.

In this article, Carson Gross discusses an alternative approach to software development that challenges the principles outlined in 'Clean Code.' Carson advocates for allowing larger functions in certain cases, preferring integration tests over unit tests, and minimizing the number of classes and interfaces. He shares examples from successful software projects that demonstrate these practices can lead to maintainable, high-quality code.

This essay by Alexander Petros explores how Web Components can be integrated seamlessly with htmx, a library that enables dynamic web pages through HTML. It discusses the flexibility of htmx in handling interactive elements like Web Components alongside traditional server-driven approaches, such as multi-page apps. By using the example of an editable carnival ride table, Alexander demonstrates how Web Components simplify functionality without the need for heavy JavaScript frameworks, highlighting their compatibility with htmx's DOM-based lifecycle. Alexander also addresses potential challenges and how htmx manages them efficiently.

In this case study, Pouria Ezzati examines how migrating a URL shortener from Next.js to htmx resulted in significant improvements in codebase size, dependencies, and developer experience while challenging assumptions about modern web frameworks.

In this essay, Sahil Lavingia, CEO of Gumroad, explains why the company decided against using htmx for its new project, Helper, in favor of React and Next.js. He shares the challenges faced with htmx, including issues with developer experience, user experience limitations, scalability, and AI tool support. While acknowledging htmx's potential for simpler projects, Lavingia emphasizes how React and Next.js offered better solutions for complex features like real-time collaboration, drag-and-drop functionality, and dynamic forms. Ultimately, Lavingia highlights the importance of selecting technologies that can grow with the project's needs.

Tony Alaribe challenges common myths about multi-page applications (MPAs) and explores how modern browser technologies can enable fast, interactive, and offline-capable web applications without relying on single-page application (SPA) frameworks. Alaribe discusses advancements in service workers, caching, and cross-document transitions, offering insights into building efficient MPAs. By debunking myths like slow page transitions and the necessity of JavaScript-heavy frameworks, Alaribe highlights how developers can leverage HTML, CSS, and minimal JavaScript to create robust, user-friendly web apps in 2024.

This guide by Alexander Petros provides essential web security best practices for building applications with htmx, focusing on safe handling of dynamic, user-generated content. It covers fundamental principles such as using only trusted routes, employing auto-escaping template engines, and securing cookies to prevent common vulnerabilities like Cross-Site Scripting (XSS) and Cross-Site Request Forgery (CSRF). Aimed at developers familiar with backend server construction, it emphasizes security techniques that are easy to implement and crucial for protecting user data in dynamic web applications.

This article provides a critical analysis of htmx, a web development library, explaining why the author believes it represents a problematic approach to modern web development due to its outdated coding practices, lack of build tools, absence of TypeScript support, and reliance on HTML-based architecture, while also questioning the professionalism of its creator.

Carson Gross give an introduction to the Model/View/Controller (MVC) 01-frontend pattern and its relevance to modern web development. He explores MVC concepts, its historical adoption in frameworks like Ruby on Rails, and practical examples of its implementation in Python with Flask. Carson explains how separating concerns with MVC can reduce code duplication, support both JSON APIs and hypermedia, and maintain flexibility in application 01-frontend.

Alexander Petros give a thoughtful exploration of htmx's relationship to traditional JavaScript frameworks, examining how its HTML-first approach and narrow focus on network requests sets it apart. He argues that while htmx exhibits framework-like qualities in how it shapes application architecture, its deep integration with HTML's native capabilities and lack of dependencies makes it a more sustainable choice for building long-lasting web applications.

In this essay, Carson Gross explores his preference for separating JSON and hypermedia APIs instead of using content negotiation, a feature in HTTP that allows clients to request different formats (e.g., HTML, JSON). He discusses the limitations of content negotiation in APIs, especially when mixing stable, versioned JSON data APIs with dynamic, UI-driven hypermedia APIs. Carson argues that by splitting these concerns into distinct APIs, developers can better maintain stability for data APIs while allowing flexibility for hypermedia APIs to evolve with user interface needs. He also highlights the challenges content negotiation introduces to API 01-frontend and scalability.

In this essay, Carson Gross examines whether Hypermedia-Driven Applications (HDAs) can effectively scale across different dimensions of software development, including system nodes, application performance, feature count, feature complexity, and team size. The analysis explores both the strengths and limitations of hypermedia in each context, ultimately demonstrating that HDAs can scale well in most scenarios while acknowledging specific challenges with complex client-side features.

In this essay, Carson Gross explores the significance of the #ViewSource affordance in preserving the open, collaborative culture of the early web. He examines the impact of digital and technical enclosure on this culture, highlights the importance of developer decisions in maintaining openness, and advocates for prioritizing #ViewSource-friendly practices in modern web development.

In this article, Carson Gross summarizes a real-world case study of Adrian McPhee porting the OpenUnited platform from React to htmx, documenting significant reductions in code complexity and development time while highlighting how content-focused web applications can benefit from a hypermedia architectural approach.

In this essay, Alexander Petros explores the reasons why the htmx JavaScript library does not include a build step, detailing the benefits of its simple, dependency-free structure. He highlights the longevity of plain JavaScript, the improved debugging experience, enforced code clarity, and the tradeoffs of avoiding tools like TypeScript or ES6. Alexander also acknowledges the potential limitations of this approach and discusses how these tradeoffs align with htmx's goals of simplicity and developer choice in web development.

These page provides some pre-written critiques of the common misuse of the term 'REST' in modern web development, contrasting it with the true REST architecture defined by Roy Fielding. Copy these ready-made responses to helpfully explain how JSON/RPC is often mislabeled as REST and highlight the role of hypermedia and API specifications in defining REST-ful systems. You will surely not make any enemies or regret posting these responses in any way.

In this essay, Carson Gross explores the concept of 'The HOWL Stack' (Hypermedia On Whatever you'd Like) and argues that using a hypermedia-driven approach for web applications allows developers to choose their preferred server-side technology, freeing them from the pressure to use JavaScript throughout their entire stack while maintaining modern web functionality through HTML and hypermedia enhancements.

Carson Gross explores the evolution of web applications and the significance of view transitions in improving user experience. He discusses the limitations of traditional web 01-frontend, where full-page refreshes create an unpleasant experience, and how modern technologies like CSS transitions and the View Transition API aim to enhance aesthetic smoothness. Carson explains how htmx leverages the View Transition API to bring seamless transitions to hypermedia-driven applications, offering an alternative to single-page applications (SPAs) and highlighting its potential once widely available in HTML.

In this essay, Carson Gross explores architectural sympathy as a software 01-frontend principle where new software adopts and conforms to the architectural patterns of existing systems. Carson examines the application of architectural sympathy in web development through htmx, its advantages and tradeoffs, and drawing parallels with medieval cathedral construction to illustrate the balance between innovation and coherent 01-frontend.

In this essay, Carson Gross explores the critical but often overlooked role of hypermedia clients in REST architectures. He explains why adding hypermedia controls to JSON APIs is insufficient for true RESTful systems without proper client implementation. Carson examines the challenges of building hypermedia clients and argues that web browsers remain the most practical choice for hypermedia-driven applications.

In this essay, Carson Gross discusses hypermedia-friendly scripting approaches for web applications, explaining how to incorporate JavaScript while maintaining REST architectural principles and HATEOAS (Hypermedia as the Engine of Application State). Carson outlines key guidelines for using scripting to enhance hypermedia-driven applications without undermining their fundamental REST-ful architecture, covering topics like client-side state management, event communication, and the islands architecture pattern.

This essay by Carson Gross explores when to use hypermedia in web development, highlighting its advantages and trade-offs. Carson discusses scenarios where hypermedia is a good fit, such as text and image-heavy UIs, CRUD applications, and nested UIs with well-defined areas. He also addresses when hypermedia may not be ideal, including situations with frequent UI state updates, offline requirements, or dynamic interdependencies. Using a 'Transitional' approach (as suggested by Rich Harris), Carson advocates for combining hypermedia with other strategies to optimize web application development, emphasizing its practical benefits and alignment with the web's architecture.

David Guillot at Contexte gave what we are calling 'The Mother of All htmx Demos' at DjangoCon 2022. This essay summarizes this real-world case study of replacing React with htmx in a SaaS product, demonstrating significant improvements in code size, performance, and development team efficiency through the adoption of a hypermedia-driven architecture.

In this essay, Carson Gross explores the concept of template fragments, a feature in server-side rendering (SSR) that allows partial rendering of content within templates. He highlights the benefits of using template fragments in hypermedia-driven applications, providing a cleaner and more maintainable approach compared to traditional template decomposition. Carson showcases the use of template fragments in the Chill templating language and discusses how this feature improves the developer experience when working with htmx and other hypermedia-oriented libraries. He also includes examples and known implementations of template fragments in various programming languages.

In this article, Carson Gross explores how the term REST (Representational State Transfer) evolved to mean nearly the opposite of its original definition in modern web development. It traces how REST, originally defined by Roy Fielding to describe the web's architecture of hypermedia-driven interactions, came to be widely misused as a term for JSON-based APIs that lack the key hypermedia constraints that define true REST architectural style.

In this guide, Carson Gross provides ten practical tips to help developers transition from Single Page Applications (SPAs) to Server-Side Rendering and Hypermedia-Driven Applications, focusing on essential mindset shifts and architectural advantages.

In this interview with Henning Koch, creator of Unpoly, he discusses his journey from managing a Rails consultancy to developing this hypermedia-oriented JavaScript library. Koch shares insights on progressive enhancement, the challenges of Single Page Applications, and why hypermedia approaches often deliver better results for typical web applications.

Carson Gross explores two different approaches to decoupling in web applications: decoupling at the application level using a JSON Data API and decoupling at the network architecture level using a hypermedia API. He discusses the trade-offs between the two methods, highlighting how a hypermedia API, despite introducing tighter coupling at the application level, offers greater resilience to change at the system level. Carson also touches on the limitations of each approach and discusses strategies like GraphQL and splitting APIs to address specific challenges in web development.

In this essay, Carson Gross explains the Hypermedia-Driven Application (HDA) architecture, which combines the simplicity of traditional Multi-Page Applications with the enhanced user experience of Single-Page Applications by extending HTML infrastructure through declarative syntax and hypermedia-based server interactions.

In this essay, Carson Gross gives an analysis of Rich Harris's talk 'Have Single-Page Apps Ruined the Web?', exploring the debate between Single-Page Applications (SPAs) and Multi-Page Applications (MPAs). Carson examines Harris's criticisms of both approaches and proposes hypermedia-oriented solutions using htmx, while discussing the broader implications for web development architecture and the future role of JavaScript in web applications.

In this essay, Carson Gross explores HATEOAS (Hypermedia as the Engine of Application State), explaining how it enables REST APIs through hypermedia responses and contrasting it with modern JSON-based APIs. Using clear HTML examples, Carson demonstrates how HATEOAS allows clients to discover available actions dynamically through hypermedia rather than requiring prior knowledge of the API interface.

If you split your API into Data and Application APIs, you should consider changing your Application API from JSON to Hypermedia (HTML) and using a hypermedia-oriented library like htmx to reap the benefits of the hypermedia model (simplicity, reliability, and flexibility).

In this essay, Carson Gross explores the fundamental differences between hypermedia APIs and data APIs, He explains how hypermedia APIs, which return HTML over HTTP, can embrace frequent changes due to their self-describing nature, while data APIs require more stability and versioning to avoid breaking client code. Carson argues that these distinct characteristics should inform different 01-frontend approaches for each type of API.

In this essay, Carson Gross presents the core concepts of REST (Representational State Transfer) explained in simple terms for beginners. He breaks down Roy Fielding's dissertation to highlight key principles like the Uniform Interface, Statelessness, Hypermedia (HATEOAS), and more, making REST easy to understand for non-academic web developers.

In this essay, Carson Gross explores the concept of a complexity budget in software development. He discusses how managing complexity across applications is a critical responsibility for architects and developers, while examining strategies for effective complexity management and the challenges that arise when attempting to reduce it.

In this essay, Carson Gross explores alternatives to Single Page Applications (SPAs), advocating for an 'HTML-Centric' development approach. He highlights the drawbacks of SPA complexity and the benefits of embracing HTML as the core medium for web development, offering a simpler, more efficient way to build applications without sacrificing interactivity. Carson discusses how tools like htmx enhance HTML's capabilities and encourages developers to reconsider the dominant SPA paradigm with technical bravery.

Carson Gross explores the Locality of Behaviour (LoB) principle, which emphasizes making the behavior of code units obvious on inspection to enhance maintainability. He discusses the tradeoffs between LoB and other software 01-frontend principles like DRY and SoC, offering insights on balancing clarity, abstraction, and maintainability in modern development.