html and http

This work proposes an “HTML-first” development paradigm that reasserts the centrality of native HTML5 in modern web development, countering the prevailing overreliance on heavyweight client-side frameworks. By leveraging semantic HTML, server-side rendering, hypermedia principles, and lightweight enhancement tools such as htmx, the approach reconstructs a server-driven interaction model that preserves HTML’s inherent strengths in semantics and performance. The resulting architecture substantially reduces frontend complexity while improving maintainability, runtime efficiency, and developer productivity. Empirical validation through real-world deployments—including the Yle content platform—demonstrates the effectiveness of this paradigm for content-centric websites. The study thus offers a minimalist yet viable alternative to the dominant client-heavy framework model, reaffirming HTML’s foundational role in sustainable web engineering.

Conventional RAG systems convert HTML sources to plain text, discarding structural and semantic information (e.g., headings, tables), thereby degrading retrieval and answer generation. Method: This paper introduces a novel knowledge modeling paradigm that directly ingests raw HTML. It (i) applies lightweight HTML cleaning and compression; (ii) proposes a two-stage, semantics-aware tree pruning algorithm to retain critical structural units while suppressing noise; and (iii) systematically evaluates the impact of native LLM HTML comprehension on RAG performance—first such investigation. Results: Experiments across six QA benchmarks show consistent improvements: our method outperforms plain-text RAG baselines by 3.2–7.8 percentage points in accuracy, with marked gains in answer correctness and robustness. These results empirically validate HTML’s efficacy, generalizability, and practicality as a structured knowledge representation for RAG.

To address the error-prone and inefficient manual rewriting of data transformation logic upon JSON Schema evolution, this paper proposes a type-directed, top-down program synthesis approach for automatically generating semantics-preserving JSON Schema converters. Our method integrates type inference, semantic constraint modeling, a rewrite system, and intermediate representation (IR)-driven code generation to guarantee lossless data transformation and formal verifiability. It natively supports complex nested schemas and synthesizes correct, efficient, and human-readable Python and JavaScript conversion code. We evaluate our approach on real-world API configuration schemas and healthcare data integration scenarios, demonstrating its safety—via formal guarantees and empirical validation—its practical utility in industrial settings, and its generalizability across diverse schema evolution patterns. Experimental results confirm high accuracy, robustness to structural changes (e.g., field additions, type refinements, nested object restructuring), and scalability to large, deeply nested schemas.

Existing object serialization formats (e.g., Protobuf, JSON, XML) exhibit poor readability and limited auditability in source-embedded contexts such as test cases. This paper introduces ProDJ—the first pure-code serialization technique for Java—that converts runtime objects directly into syntactically valid, executable, and highly readable Java source code expressions. Its core innovation lies in leveraging the target language’s native syntax for serialization, integrating reflective introspection, abstract syntax tree (AST) generation, and cycle-aware object graph traversal to simultaneously ensure readability, executability, and maintainability. Evaluation demonstrates that ProDJ successfully serializes over 174,000 real-world objects with negligible runtime overhead. A user study confirms that developers significantly prefer ProDJ-generated Java code over JSON or XML—particularly for development tasks requiring human involvement, such as test generation.

To address two key challenges in automated HTML generation from UI design mockups—(1) difficulty in modeling hierarchical HTML structure and (2) weak cross-modal alignment between visual and textual representations—this paper proposes a structure-aware attention mechanism and a cross-modal contrastive fine-tuning strategy. Within a large language model (LLM) framework, our approach jointly optimizes syntactic correctness, visual fidelity, and semantic consistency for the first time. Specifically, it integrates tree-structured HTML encoding with image–text contrastive learning and introduces a new benchmark, WebSight-Test. Experimental results demonstrate significant improvements: +9.00 percentage points in HTML matching rate, +0.0982 in CW-SSIM, +32.99 in CLIP similarity, and +27.12 percentage points in LLEM score on both WebSight-Test and Design2Code—outperforming state-of-the-art methods by a substantial margin.

Current web agents rely on low-level operations such as clicking and typing, resulting in task execution that is fragile, inefficient, and difficult to verify. This work proposes Web Verbs—the first semantic action layer for “agent-native” web interaction—that unifies browser-based actions and API calls through typed verb abstractions equipped with preconditions, postconditions, policy tags, and execution logs. By integrating large language models, semantic document representations, and functional interfaces, the approach enables agents to automatically discover, compose, and generate reliable, auditable workflows. Case studies demonstrate that Web Verbs can compress multi-step interactions—often involving dozens of primitive actions—into a small number of high-level function calls, substantially improving the reliability, efficiency, and verifiability of task execution.

This work proposes an intelligent web crawling approach based on multimodal large language models (MLLMs) to overcome the limitations of traditional crawlers, which struggle with dynamic, interactive websites and rely heavily on static HTML parsing and manual customization. The method integrates a specialized toolchain for web interaction and data extraction with a structured five-stage prompting mechanism, enabling fully automated, structured data collection from “index–content” architecture websites. By deeply coupling MLLMs with purpose-built tools, the system autonomously navigates complex user interfaces without human intervention. Experimental results demonstrate that the proposed approach significantly outperforms the Anthropic Computer Use baseline across six news websites and exhibits strong generalization capabilities in e-commerce scenarios.

Existing large language models generate HTML pages that render well statically but often fail under user interactions such as scrolling, clicking, or window resizing—issues largely undetectable by conventional screenshot-based evaluation. This work proposes HTMLCure, a novel framework that leverages browser interaction trajectories as the basis for both assessment and repair. By executing pages across multiple viewports and interactive states, recording deterministic behavioral evidence, and employing a vision-language model to analyze key-frame trajectories, HTMLCure drives a state-aware, closed-loop repair engine. The approach substantially enhances the interactive robustness and usability of generated web pages. Built upon 97K raw prompts, the authors curate a high-quality supervised fine-tuning dataset of 40K samples. The refined HTMLCure-27B-Refined model achieves a score of 50.6 on HTMLBench-400 (with a 45.2% deterministic test pass rate) and 81.2 on MiniAppBench, outperforming baselines by 15.3 points on average.

This work addresses the poor accessibility and lack of semantic structure in math-intensive academic papers on arXiv when rendered as PDFs by proposing an automated method to convert TeX/LaTeX source code into high-quality HTML5. The key innovation lies in the first large-scale integration of MathML 4 Intent annotations within an academic publishing platform, substantially enhancing both accessibility and semantic expressiveness of mathematical content. The system employs a Rust-based rewrite of the conversion engine, combined with LaTeXML, a community-driven error feedback mechanism, and an automated pipeline. This approach achieves a 75% error-free conversion rate (with a target of 90%), resolves approximately half of user-reported issues, and reduces computational overhead while accelerating preview generation.

This study addresses the lack of empirical analysis on the effectiveness of simple in-memory caching in small-scale web applications. By comparing server configurations with and without a fixed time-to-live (TTL) in-memory cache within a lightweight web framework, the authors systematically evaluate performance gains through measurements of response times for repeated HTTP requests. The results demonstrate that incorporating a basic server-side cache significantly reduces response latency, confirming its efficacy in resource-constrained environments. This work fills an empirical gap in the understanding of caching mechanisms for lightweight applications and underscores the practical value of simplicity and reproducibility in educational contexts and small-scale deployments.