So I Talked With Creator HTMX
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.
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?
Why does Gross push back on performance arguments that blame server-side HTML generation?
How does Gross think about code structure—especially function size—compared with popular style rules?
What does Gross do differently when teaching software engineering and related courses?
How does Gross connect his contrarian tendencies to practical decision-making?
What learning and classroom habits does Gross emphasize for students?
Review Questions
- How do Gross’s HTMX design principles (event request/replace and attributes) aim to reduce complexity compared with typical SPA-heavy approaches?
- What kinds of evidence does Gross think software engineering should rely on when arguing about performance or code quality?
- In Gross’s teaching, how do course requirements (like UML vs process diagrams) change based on what students actually build?
Key Points
- 1
HTMX’s design is built around event-driven requests that replace page fragments, with attribute-based configuration inspired by Angular.
- 2
Gross argues that performance debates should prioritize measurements because database and network latency usually dominate over server-side HTML rendering CPU costs.
- 3
He favors empirical software engineering research using real codebases (e.g., via GitHub) rather than first-principles or purely aesthetic rules.
- 4
In his teaching, Gross de-emphasizes UML in software engineering and uses classic papers plus small refactoring exercises to build practical judgment.
- 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
Gross’s contrarian streak is tempered by a “pick your battles” mindset—letting others win smaller points to preserve progress on bigger decisions.
- 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.