plugin architecture design

Current micro-frontend architectures heavily rely on specific bundlers (e.g., Webpack), leading to inflexible module composition, constrained cross-team collaboration, and bottlenecks in error detection, runtime observability, and loading performance. To address these limitations, we propose Bundler-Independent Module Federation (BIMF)—the first runtime module federation framework decoupled from build-time bundlers. BIMF enables dynamic module loading, type-safe inter-module collaboration, and cross-team dependency sharing. It integrates runtime dependency resolution, distributed tracing, server-side rendering (SSR), and intelligent prefetching to significantly enhance observability and first-contentful-paint (FCP) performance. Experimental evaluation of a prototype implementation demonstrates: (1) full preservation of TypeScript type contracts across modules; (2) 100% dependency deduplication; (3) a 37% reduction in average module loading latency; and (4) a 42% improvement in parallel development efficiency across distributed teams.

Current tool-augmented large language model (LLM) ecosystems suffer from fragmentation—characterized by coexisting heterogeneous protocols (e.g., OpenAI Function Calling, Toolformer), manual schema definition, and complex execution orchestration—leading to low development efficiency and high integration overhead. To address this, we propose a protocol-agnostic unified tool integration framework. Our approach introduces an abstract protocol layer for cross-standard compatibility, an automated schema inference mechanism to eliminate manual specification, and a dual-mode concurrent scheduler enabling seamless synchronous and asynchronous tool execution. Experimental evaluation demonstrates that, compared to baseline approaches, our framework reduces implementation code volume by 60–80%, achieves up to 3.1× improvement in end-to-end execution latency, and maintains full backward compatibility with mainstream LLM tool-calling ecosystems.

This work addresses the challenge of seamlessly integrating logic programming paradigms into existing statically typed functional languages without compromising type safety. To this end, it proposes a novel approach that combines extensible types, a generic unification algorithm, and an embedded domain-specific language (DSL), enabling host-language values to naturally incorporate logic variables while supporting polymorphism and higher-order functions. The approach is implemented in Haskell, demonstrating its technical feasibility and practical utility. This study presents the first unified framework that cohesively integrates these mechanisms, significantly enhancing the expressiveness and integration depth of logic programming within typed functional languages—all while preserving the integrity of the underlying type system.

This work addresses the limitations of existing join pattern implementations, which often rely on domain-specific languages and exhibit rigid, inflexible matching algorithms that hinder integration into general-purpose programming ecosystems. To overcome these challenges, we propose and implement JoinActors—a modular and extensible join pattern matching library built on Scala 3. JoinActors is the first library to support join patterns natively within a general-purpose language, offering an intuitive API powered by metaprogramming and incorporating fair join semantics. Its key innovation lies in enabling plug-and-play support for multiple matching algorithms, facilitating direct performance comparisons. Experimental results demonstrate that the new implementation significantly improves performance while preserving matching correctness, thereby providing an efficient coordination mechanism for complex message-passing systems and establishing a reusable experimental platform for future research on join patterns.

This work addresses the challenges of ensuring termination, semantic reliability, and completeness for user-defined modules in algebraic simplification libraries. We propose a generic algebraic modeling paradigm based on dependent types, formalizing algebraic structures via free algebras (fral) and variable extensions (frex), and enforcing simplification rules at the type level using dependently typed languages (Idris2/Agda). This guarantees strong normalization, semantic soundness, and completeness under a given equational theory for both built-in and user-defined modules. We introduce a novel “interface–implementation” separation, enabling dual modularity: reuse of foundational infrastructure (term representation, reflection, certification) and compositional nesting of existing simplification modules. We experimentally implement verified simplifiers for monoids and their variants (commutative, involutive), demonstrating feasibility, scalability, and high reusability within real-world theorem-proving environments.

This study addresses the unique challenges faced by non-developer-led knowledge communities—such as Obsidian—in maintaining sustainable plugin ecosystems, a domain lacking systematic understanding. Through an empirical investigation of 396 plugins, combining repository mining, large language model–driven topic modeling, and pull request analysis, this work presents the first systematic characterization of such ecosystems. It identifies six functional theme categories and reveals active software evolution patterns. Furthermore, the research proposes an analytical framework tailored for plugin maintenance in mixed-skill communities, articulating three strategic directions and six key research questions. The findings demonstrate that even non-developer communities can cultivate plugin ecosystems with discernible engineering structure and long-term sustainability.

Modular control-flow handling in abstract interpretation and supporting multiple analysis strategies—such as path- vs. flow-sensitivity, forward vs. backward directionality, and upper vs. lower approximations—traditionally relies on complex monad transformers, leading to implementation brittleness and poor composability. Method: This paper introduces the *cumulative abstract semantics* framework, the first to incorporate *scoped effects* into abstract interpretation. It decouples syntactic structure from semantic behavior via two classes of effect handlers: *syntax-resolving* and *domain-semantics-introducing*. A single syntax-driven interpreter suffices to generate diverse dynamic evaluators and static analyzers. Contribution/Results: The framework eliminates heavyweight data structures, preserving expressiveness while drastically reducing implementation complexity for multi-strategy analyses. It enhances maintainability, composability, and modularity—providing a concise, unified, and extensible theoretical and practical foundation for modular program analysis.

This work addresses the lack of a modular desktop framework in scientific computing and engineering that supports orthogonal decoupling of 2D/3D visualization and simulation components. We propose and implement a modular multi-document interface framework tailored for the JVM ecosystem, which achieves architectural flexibility and long-term maintainability by decoupling the visualization layer, simulation engine, and an optional hardware-accelerated 3D rendering module. This design prevents 2D applications from incurring unnecessary 3D dependencies while enabling efficient synchronization between multiple views and simulations. Built on Java with a modular architecture and multithreaded model, the framework has been successfully integrated with a real-time 3D gas expansion simulation alongside synchronized 2D entropy map rendering. The implementation is publicly available on Maven Central, providing foundational support for the sustainable evolution of scientific software.

To address the challenges of insufficient modularity, poor reusability, and low efficiency in type-system generation for multilingual, multi-editor (L×E) editing support development, this paper introduces the Typelang language family and the variant-oriented programming paradigm, establishing a cross-component coordination layer to enable modular language-server generation and fully automated LSP plugin construction. Leveraging domain-specific language modeling, Neverlang-driven modular compilation, and a composable type-system design, the approach reduces language–editor integration complexity from O(L×E) to O(N×1), where N denotes the number of reusable language components. Experimental evaluation demonstrates a 93.48% reduction in type-system implementation code and complete automation of LSP plugin generation; in language-component reuse scenarios, development effort is significantly reduced. The core contribution is the first framework enabling one-click, type-driven, highly reusable, cross-editor language-server generation.

Modern software systems suffer performance degradation and increased operational costs due to suboptimal parameter configurations across multi-layer runtime stacks—including virtualization, storage, and trusted execution environments (TEEs). Existing tuning tools are typically domain-specific, single-layer, or constrained to fixed optimization objectives, rendering them ill-suited for startups and innovative ventures (SIVs) with resource constraints, customized technology stacks, and limited expert expertise. This paper introduces the first general-purpose, cross-layer, cross-domain, multi-objective parameter tuning framework. It requires no prior knowledge, supports black-box evaluation and incremental optimization, and synergistically integrates Bayesian optimization, multi-objective evolutionary algorithms, and meta-learning to dynamically model parameter–performance relationships in heterogeneous environments. Evaluated on real-world deployments and standard benchmarks, the framework consistently improves performance, reduces resource consumption, and demonstrates strong generalizability and deployment robustness.