Get AI summaries of any video or article — Sign up free
So I Talked With Creator HTMX thumbnail

So I Talked With Creator HTMX

The PrimeTime·
5 min read

Based on The PrimeTime's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

HTMX’s design is built around event-driven requests that replace page fragments, with attribute-based configuration inspired by Angular.

Briefing

HTMX’s creator, Carson Gross, credits the project’s rise to a simple core idea—event-driven requests that replace only parts of the page—combined with a deliberate anti-complexity philosophy. He describes HTMX (and its earlier predecessor Intercooler) as “intercooler 2.0,” built from two ingredients: the “event request replace” mechanism and the use of attributes borrowed from Angular. The result is a web approach that reduces the need for heavy client-side frameworks for many applications, making it easier to ship features without drowning in architectural ceremony.

Gross also argues that software engineering education and practice often get stuck in idealized debates that don’t match real performance and real-world tradeoffs. In his view, claims that server-side HTML generation “costs more” are usually one-dimensional: database access and network round trips dominate latency, while template rendering and string interpolation are often rounding errors. He pushes for more empirical, “ugly, grony” studies—using GitHub codebases and real measurements—rather than first-principles reasoning or aesthetic rules. He contrasts this with common software-engineering platitudes such as “refactor whenever functions exceed 4–6 lines,” saying large functions can be fine when they represent a coherent unit of work, and pointing to an IBM study that suggested function lengths up to around 100 lines correlated with fewer bugs than excessive fragmentation.

His teaching approach reflects that same bias toward practicality. Gross teaches multiple computer science and software engineering courses at Montana State University, including databases, compilers, systems programming (C/assembly), and software engineering. While he acknowledges UML’s academic role, he downplays it in favor of classic papers and hands-on refactoring exercises. In his compiler course, students write recursive descent parsers and then produce process diagrams instead of UML diagrams, because the project’s structure makes UML a poor fit for documenting how the compiler actually works.

Gross’s career path also shaped his stance. After dropping out of computer science at Berkeley and switching to industrial engineering, he later returned for a master’s at Stanford, and eventually moved to Montana State University after a startup in Sacramento (Lead Dino) ended amid co-founder conflicts. He frames his contrarian streak as both a strength and a liability—sometimes costly financially and professionally—but says the bigger lesson is learning when to “pick your battles.” He describes a shift from arguing constantly to letting others win smaller points to preserve momentum for bigger decisions.

On the human side, Gross links his technical worldview to communication and culture. He emphasizes debugging habits (using breakpoints and understanding system state), coding volume, and humor to de-escalate confusion. He also treats online negativity as something that can be metabolized: even harsh criticism can be turned into perspective, and sustained positivity helps keep projects and teams moving. Overall, his message ties together engineering, education, and community: build simpler systems where it matters, measure what actually affects users, and keep learning without turning every disagreement into a fight.

Cornell Notes

Carson Gross, creator of HTMX, traces the library’s design to a simple mechanism: event-driven requests that replace page fragments, paired with attribute-based configuration inspired by Angular. He argues that software engineering debates—especially around performance and code aesthetics—often rely on idealized assumptions instead of measurements, since database and network latency usually dwarf server-side rendering costs. In teaching, he favors classic research papers and hands-on refactoring over heavy UML-driven “academic” modeling, and he adapts documentation requirements to fit how compiler projects actually work. Gross also stresses practical learning habits (debuggers, coding a lot, staying okay when confused) and a life lesson about picking battles rather than winning every argument.

What core idea does Gross say HTMX (and Intercooler) builds on, and why does that matter?

Gross credits a “flash of insight” from Intercooler: event request → replace. That mechanism lets the browser ask the server for updates and then swap in returned HTML fragments, avoiding full page reloads. He also says he used attributes (borrowed from Angular) to express behavior declaratively. Together, those choices aim to reduce complexity for common web app interactions—so developers can ship features without building large client-side systems.

Why does Gross push back on performance arguments that blame server-side HTML generation?

He calls out “one-dimensional” reasoning: generating HTML on the server may add CPU work, but real latency is usually dominated by datastore access and network round trips. Even if server rendering adds a fraction of a millisecond, a typical database round trip can be ~120 ms, making the CPU delta effectively irrelevant to user-perceived speed. He wants empirical comparisons (including correct benchmarking setups) rather than first-principles claims.

How does Gross think about code structure—especially function size—compared with popular style rules?

Gross rejects strict aesthetic rules like “refactor whenever a function exceeds 4–6 lines.” He prefers fewer files over excessive decomposition: he’d rather see one function that does one thing clearly than a thousand tiny functions scattered across many files. He also cites an IBM study on ideal function length and bug rates, claiming function lengths up to around 100 lines correlated with fewer bugs than lots of small functions—though he notes relevance may vary with modern languages and tooling.

What does Gross do differently when teaching software engineering and related courses?

He says he doesn’t emphasize UML much in software engineering, calling UML an academic perspective. Instead, he assigns classic papers (including “Worse is Better”) and uses small, concrete refactoring exercises—like cleaning up an ugly function—rather than only teaching big conceptual diagrams. In his compiler class, students still create diagrams, but he swaps UML for process diagrams to better document recursive descent parsing and the project’s existing data infrastructure.

How does Gross connect his contrarian tendencies to practical decision-making?

Gross describes contrarianism as sometimes costly—financially and professionally—and says the key evolution is learning to “pick your battles.” He argues that not every disagreement is worth escalating; letting others win smaller points can preserve relationships and momentum for larger system changes. He also observes that teams can survive losing individuals when the organization’s broader forces carry on, which reduces the urge to treat every critique as existential.

What learning and classroom habits does Gross emphasize for students?

He stresses coding volume—students must write lots of code to get good. He also normalizes not understanding at first: keep returning to the material and keep going. Debugging is central: he wants students to arrive with breakpoints set at their confusion points so they can inspect state and build a mental model of how the program behaves. Humor (“grug brain” style) is used to de-escalate confusion and keep learning productive.

Review Questions

  1. How do Gross’s HTMX design principles (event request/replace and attributes) aim to reduce complexity compared with typical SPA-heavy approaches?
  2. What kinds of evidence does Gross think software engineering should rely on when arguing about performance or code quality?
  3. In Gross’s teaching, how do course requirements (like UML vs process diagrams) change based on what students actually build?

Key Points

  1. 1

    HTMX’s design is built around event-driven requests that replace page fragments, with attribute-based configuration inspired by Angular.

  2. 2

    Gross argues that performance debates should prioritize measurements because database and network latency usually dominate over server-side HTML rendering CPU costs.

  3. 3

    He favors empirical software engineering research using real codebases (e.g., via GitHub) rather than first-principles or purely aesthetic rules.

  4. 4

    In his teaching, Gross de-emphasizes UML in software engineering and uses classic papers plus small refactoring exercises to build practical judgment.

  5. 5

    His compiler course adapts documentation requirements: students produce process diagrams instead of UML when UML doesn’t map well to recursive descent behavior.

  6. 6

    Gross’s contrarian streak is tempered by a “pick your battles” mindset—letting others win smaller points to preserve progress on bigger decisions.

  7. 7

    He emphasizes student success habits: code a lot, stay okay when confused, and use debuggers (breakpoints and state inspection) to form accurate mental models.

Highlights

HTMX is described as “intercooler 2.0,” combining an event request/replace mechanism with Angular-style attributes to keep web interactions simple.
Gross says server-side HTML generation cost is often a rounding error compared with datastore round trips—so performance claims need real benchmarks.
He rejects strict function-length aesthetics and points to an IBM study suggesting functions up to ~100 lines may correlate with fewer bugs than excessive fragmentation.
His teaching approach favors hands-on refactoring and debugger-driven learning over UML-heavy academic modeling.
Gross frames long-term success as sticking with an idea and staying positive, even when criticism arrives harshly.

Topics

  • HTMX Design
  • Software Engineering Education
  • Empirical Performance
  • Function Size
  • Debugging Habits

Mentioned