javascript

OCL.js exhibits incomplete standard coverage, low adoption, and poor integration with modern frontend toolchains in SaaS modeling environments. Method: This paper proposes replacing OCL.js with JSX—a declarative JavaScript/TypeScript syntax—for model constraint specification. It introduces JSX to constraint modeling for the first time, leveraging its functional and component-based paradigm to enable inductive syntax definition, constraint-aware code generation, and dynamic querying, while natively supporting frontend-first architectures. A client-side constraint expression and execution framework is implemented atop the React ecosystem. Contribution/Results: Empirical evaluation demonstrates that JSX delivers superior expressiveness over OCL.js on representative modeling examples and significantly improves integration with contemporary frontend tools—including TypeScript, Vite, and ESLint—thereby enhancing developer productivity and tooling consistency.

This study addresses the lack of clarity regarding pain points experienced by React developers in practice. Leveraging React-related question–answer data from Stack Overflow, we conduct a multi-dimensional empirical analysis. Methodologically, we integrate exploratory text mining, manual annotation of error types, and reputation-based stratified statistical analysis—first establishing associations among eight high-frequency keywords (e.g., *code*, *link*, *vir*), error category distributions, and user community status. Results reveal that algorithmic errors constitute the largest error category; notably, medium-reputation users contribute 55.77% of all questions, underscoring their role as a critical bottleneck cohort. The study uncovers the under-recognized needs of intermediate-level developers within the React ecosystem, offering a data-driven perspective to inform community support strategies and framework design improvements.

This work addresses the weak visualization capabilities of Answer Set Programming (ASP) solvers and their poor integration with modern web-based visualization frameworks. To resolve this, we propose ASP Chef—a templated extension method that introduces a logic-agnostic, Mustache-style template system. This enables deep decoupling and dynamic coupling between ASP’s declarative models and frontend rendering, supporting formatting, sorting, and multi-stage template expansion. ASP Chef integrates Tabulator, Chart.js, and vis.js to deliver interactive tables, charts, and graph-structure visualizations. It represents the first end-to-end integration of declarative ASP modeling with contemporary web-based visual analytics within the ASP toolchain. Evaluated on real-world use cases—including VQR data analysis, graph blocking set identification, and scheduling problems—the approach significantly enhances result interpretability and interactivity, yielding a production-ready, out-of-the-box visual analytics pipeline for ASP.

To address client-side hydration-induced interactivity delays in SSR applications, this paper proposes a modular rendering and context-aware adaptive hydration architecture. The approach decomposes the UI into independently renderable and selectively hydratable modules, dynamically scheduling hydration timing and granularity based on device capabilities, network conditions, and component priority. Technically, it integrates dynamic `import()`-based code splitting, visibility detection, `requestIdleCallback`-driven idle-time scheduling, and custom adaptive React Hooks. Compared to monolithic hydration, the method significantly reduces initial JavaScript execution volume, improving core performance metrics—including First Input Delay (FID) and Time to Interactive (TTI)—without compromising interactivity richness. Its key contribution lies in the systematic integration of context-awareness into hydration orchestration, enabling fine-grained, runtime-adaptive hydration control—a novel advancement in SSR optimization.

React Hooks’ opaque semantics frequently lead to subtle UI bugs. To address this, we introduce React-tRace—the first formal semantic model targeting the core mechanisms of React Hooks. Grounded in operational semantics and definitional interpretation, our model precisely captures the execution ordering, state dependencies, and invocation constraints of Hooks within functional components. We formally prove that the model satisfies essential Hook properties—including call consistency and state persistence—and empirically validate its behavioral equivalence with the real React runtime. Leveraging this model, we develop a visualization-based debugging tool that significantly enhances developers’ understanding of Hook behavior and accelerates defect localization. This work establishes a verifiable, interpretable theoretical foundation for React Hooks while delivering practical tooling support for robust UI development.

This work addresses the challenges posed by implicit dependencies introduced by React Hooks, which often lead to anti-patterns that reduce code predictability and maintainability. To tackle this issue, we propose HookLens—the first interactive visualization system specifically designed for React Hooks—that integrates static and dynamic program analysis to explicitly reveal data flows and dependency structures across components. Through an iterative design process, HookLens provides an intuitive interface that enhances developers’ understanding of complex hook-based logic. A user study with 12 developers demonstrates that using HookLens significantly improves the accuracy of anti-pattern identification compared to conventional code editors and state-of-the-art large language model (LLM) coding assistants, thereby validating its effectiveness in supporting code comprehension and quality assurance for React Hooks.

This study addresses the limited systematic understanding of real-world defects in the TypeScript ecosystem, particularly the lack of empirical evidence on how the type system influences fault distribution. Through a large-scale analysis of 633 defect reports from 16 prominent open-source projects, we develop a fine-grained defect taxonomy and employ statistical methods to examine its relationship with project size, domain, and dependency structure. Our findings reveal that faults in TypeScript projects predominantly stem from toolchain issues, configuration errors, API misuse, and asynchronous error handling—rather than traditional logic or syntax bugs. While static typing significantly suppresses runtime and type-related errors, the locus of failures has shifted toward build systems and integration boundaries, highlighting toolchain complexity and dependency management as key drivers of modern software faults.

This work addresses the challenge of migrating monolithic backends to serverless architectures, a process typically requiring extensive manual effort. The authors propose the first automated migration pipeline that integrates lightweight static analysis with multi-agent collaboration. By constructing call graphs and identifying asynchronous behaviors, the approach orchestrates four specialized LLM agents—Architect, Developer, SAM Engineer, and Consistency Validator—to jointly generate end-to-end deployable applications compliant with AWS SAM specifications. Evaluated on six real-world benchmarks comprising over 10,000 lines of code and 76 endpoints, the method achieves a 100% deployment success rate, 66.1% end-to-end correctness, and a 98.7% F1 score for API coverage, substantially outperforming existing commercial solutions.

This work addresses the challenges in edge and embedded application development—namely, heterogeneous software stacks, multi-language runtimes, and difficult debugging—which lead to rigid deployment workflows and complex fault diagnosis. To overcome these limitations, the paper proposes a novel architecture enabling unified end-edge-cloud development. Its core components include a single programming language, a retargetable runtime system, a local recording and replay mechanism for distributed events, and a cross-platform deployment framework. This design breaks down traditional debugging barriers in edge–cloud collaborative development, facilitating seamless scalability, consistent testing, and flexible deployment across heterogeneous environments. Evaluation of the prototype system demonstrates that the proposed approach significantly simplifies deployment procedures and enhances fault diagnosis efficiency.

This work addresses the inefficiency of modern JavaScript compilers, which often waste substantial computational resources by indiscriminately applying all downlevel transformations regardless of the actual language features used. To mitigate this, the authors propose a conditional transpilation mechanism that precisely detects and dynamically tracks the set of language features employed at the script level, triggering transformations only for those features that require them. Implemented within the Google Closure Compiler, the approach integrates feature set construction, strategic pass ordering, and post-transpilation feature validation to significantly reduce unnecessary abstract syntax tree (AST) traversals. Empirical evaluation on large-scale production codebases demonstrates that the proposed method effectively decreases compilation time while reducing both memory consumption and computational overhead.