Developing editing support for \(\mathbf{L}\) languages in \(\mathbf{E}\) editors is complex and time-consuming. Some languages do not provide dedicated editors, while others offer a single native editor. The \(\textit{language server protocol}\) (LSP) reduces the language-editor combinations \(\mathbf{L} \times \mathbf{E}\) to \(\mathbf{L} + \mathbf{E}\), where a single language server communicates with editors via LSP plugins. However, overlapping implementations of linguistic components remain an issue. Existing language workbenches struggle with modularity, reusability, and leveraging type systems for language server generation. In this work, we propose: (i) Typelang, a family of domain-specific languages for modular, composable, and reusable type system implementation, (ii) a modular language server generation process, producing servers for languages built in a modular workbench, (iii) the variant-oriented programming paradigm and a cross-artifact coordination layer to manage interdependent software variants, and (iv) an LSP plugin generator, reducing \(\mathbf{E}\) to \(\mathbf{1}\) by automating plugin creation for multiple editors. To simplify editing support for language families, each language artifact integrates its own Typelang variant, used to generate language servers. This reduces combinations to \(\mathbf{T} \times \mathbf{1}\), where \(\mathbf{T} = \mathbf{L}\) represents the number of type systems. Further reuse of language artifacts across languages lowers this to \(\mathbf{N} \times \mathbf{1}\), where \(\mathbf{N} << \mathbf{T}\), representing unique type systems. We implement Typelang in Neverlang, generating language servers for each artifact and LSP plugins for three editors. Empirical evaluation shows a 93.48% reduction in characters needed for type system implementation and 100% automation of LSP plugin generation, significantly lowering effort for editing support in language families, especially when artifacts are reused.

Modern programming languages, most notably Rust, offer advanced linguistic constructs for building highly configurable software systems as aggregation of features---identified by a configuration. However, they pose substantial challenges for program analysis, optimization, and testing, as the combinatorial explosion of configurations often makes exhaustive exploration infeasible. In this manuscript, we present the first compiler-based method for prioritizing configurations. Our approach consists of four main steps: (1) extracting a tailored intermediate representation from the Rust compiler, (2) constructing two complementary graph-based data structures, (3) using centrality measures to rank features, and (4) refining the ranking by considering the extent of code they impact. A fixed number of most relevant configurations are generated based on the achieved feature ranking. The validity of the generated configurations is guaranteed by using a SAT solver that takes a representation of this graph in conjunctive normal form. We formalized this approach and implemented it in a prototype, RustyEx, by instrumenting the Rust compiler. An empirical evaluation on higher-ranked open source Rust projects shows that RustyEx efficiently generates user-specified sets of configurations within bounded resources, while ensuring soundness by construction. The results demonstrate that centrality-guided configuration prioritization enables effective and practical exploration of large configuration spaces, paving the way for future research in configuration-aware analysis and optimization.

Real-time automatic speech recognition systems are increasingly integrated into interactive applications, from voice assistants to live transcription services. However, scaling these systems to support multiple concurrent clients while maintaining low latency and high accuracy remains a major challenge. In this work, we present SWIM, a novel real-time ASR system built on top of OpenAI's Whisper model that enables true model-level parallelization for scalable, multilingual transcription. SWIM supports multiple concurrent audio streams without modifying the underlying model. It introduces a buffer merging strategy that maintains transcription fidelity while ensuring efficient resource usage. We evaluate SWIM in multi-client settings---scaling up to 20 concurrent users---and show that it delivers accurate real-time transcriptions in English, Italian, and Spanish, while maintaining low latency and high throughput. While Whisper-Streaming achieves a word error rate of approximately 8.2% with an average delay of approximately 3.4,s in a single-client, English-only setting, SWIM extends this capability to multilingual, multi-client environments. It maintains comparable accuracy with significantly lower delay---around 2.4,s with 5 clients---and continues to scale effectively up to 20 concurrent clients without degrading transcription quality and increasing overall throughput. Our approach advances scalable ASR by improving robustness and efficiency in dynamic, multi-user environments.

Optimizing compilers exhibit limitations when handling multiple recursive functions (e.g., Fibonacci). While single recursion is optimized via Tail-Call Optimization into efficient iteration, multiple recursion often forces the compiler to retain a partial, performance-limiting recursive structure. Analyzing the optimized LLVM IR reveals that even state-of-the-art compilers fail to achieve complete incrementalization for this pattern. We argue that the automatic, general-setting iterative transformation of multiple recursive functions remains an unsolved and critical challenge for compiler technology.