Abstract
Programming languages tend to evolve over time to use more and more concepts from theoretical computer science. Still, there is a gap between programming and pure mathematics. Not all theoretical results have realized their promising applications. The algebraic decomposition of finite state automata (Krohn-Rhodes Theory) constructs an emulating hierarchical structure from simpler components for any computing device. These decompositions provide ways to understand and control computational processes, but so far the applications were limited to theoretical investigations. Here, we study how to apply algebraic decompositions to programming languages. We use recent results on generalizing the algebraic theory to the categorical level (from semigroups to semigroupoids) and work with the special class of concatenative functional programming languages. As a first application of semigroupoid decompositions, we start to design a family of programming languages with an explicit semigroupoid representation.

AI Insights

• Stack effects serve as type constructors, linking program flow to semigroupoid objects.
• Infinite semigroupoid structures are compressed into finite automata, enabling tractable analysis.
• Categorical semantics from semigroupoid composition yield a compositional proof system for correctness.
• The proposed language family maps each primitive to a semigroupoid morphism, making code self‑documenting.
• Krohn‑Rhodes theory is adapted to functional programming, hinting at optimizations via prime decomposition.
• For background, read “Algebraic Theory of Machines. I. Prime Decomposition Theorem for Finite Semigroups and Machines.”
• A gentle categorical primer is “Category Theory” by Borceux, which explains semigroupoids.

Abstract
Distributed system theory literature often argues for correctness using an informal, Hoare-like style of reasoning. While these arguments are intuitive, they have not all been foolproof, and whether they directly correspond to formal proofs is in question. We formally ground this kind of reasoning and connect it to standard formal approaches through language design and meta-analysis, which leads to a functional style of compositional formal reasoning for a class of distributed systems, including cases involving Byzantine faults. The core of our approach is twin languages: Sync and Async, which formalize the insight from distributed system theory that an asynchronous system can be reduced to a synchronous system for more straightforward reasoning under certain conditions. Sync describes a distributed system as a single, synchronous, data-parallel program. It restricts programs syntactically and has a functional denotational semantics suitable for Hoare-style formal reasoning. Async models a distributed system as a collection of interacting monadic programs, one for each non-faulty node in the system. It has a standard trace-based operational semantics, modeling asynchrony with interleaving. Sync compiles to Async and can then be extracted to yield executable code. We prove that any safety property proven for a Sync program in its denotational semantics is preserved in the operational semantics of its compiled Async programs. We implement the twin languages in Rocq and verify the safety properties of two fault-tolerant consensus protocols: BOSCO and SeqPaxos.

Abstract
I here conduct an exploration of programming language extensibility, making an argument for an often overlooked component of conventional language design. Now, this is not a technical detailing of these components, rather, I attempt to provide an overview as I myself have lacked during my time investigating programming languages. Thus, read this as an introduction to the magical world of extensibility. Through a literature review, I identify key extensibility themes - Macros, Modules, Types, and Reflection - highlighting diverse strategies for fostering extensibility. The analysis extends to cross-theme properties such as Parametricism and First-class citizen behaviour, introducing layers of complexity by highlighting the importance of customizability and flexibility in programming language constructs. By outlining these facets of existing programming languages and research, I aim to inspire future language designers to assess and consider the extensibility of their creations critically.

AI Insights

• The review sifted 1,200+ papers by title, abstract, and conclusion using a custom dblp‑based service.
• A Zotero library curated article quality for reproducible selection.
• Findings confirm abstraction, parameterization, polymorphism, reflection, and generics as core to extensible design.
• Suggested readings: Scott’s “Programming Language Pragmatics” and Harper’s “Language Definition and Implementation.”
• The study notes possible omissions: filtering thresholds may miss niche work, and dblp coverage is not exhaustive.
• These results encourage treating extensibility as a first‑class design pillar, not an afterthought.

Abstract
Most large language models (LLMs) today excel at generating raw, sequential code with minimal abstractions and custom structures. However, there has been little work on graph-based abstract code generation, where significant logic is encapsulated in predefined nodes and execution flow is determined by edges. This is relevant for visual programming languages, and in cases where raw source code is inaccessible to users and LLM training sets. In this work, we propose and evaluate JSON representations for graphs to enable high accuracy graph-based abstract code generation. We evaluate these representations on ScratchTest, a mini-benchmark based on our custom Python re-implementation of Scratch, which tests the LLM in code graph space. Our findings demonstrate that LLMs can indeed perform the aforementioned generation task in a single pass without relying on specialized or complex pipelines, given the correct graph representations. We also show that different representations induce significantly different accuracies, highlighting the instrumental role of representations in this generation task. All in all, this work establishes the first steps towards representation learning for graph-based abstract code generation.

AI Insights

• The proposed model beats the RNN baseline on all ScratchTest runs, achieving the lowest error rates.
• Ablations show node representation choice matters more than output format, making representation design critical.
• Qwen3‑32B fails on both reference and output graph ablations, proving large LLMs need tailored graph encodings.
• DeepSeek‑R1‑Distill‑Llama‑70B excels in some runs, showing distilled models can capture graph semantics.
• Llama‑3.3‑70B‑Versatile matches the proposed model in most trials, hinting versatile transformers can approximate specialized graph generators.
• Recommended literature includes Graph Attention Networks and BERT‑style pre‑training for advancing graph‑based code generation.
• Core definitions: Graph Neural Networks process graph data; Attention Mechanisms focus on key input parts.

Abstract
The \emph{Dominating $H$-Pattern} problem generalizes the classical $k$-Dominating Set problem: for a fixed \emph{pattern} $H$ and a given graph $G$, the goal is to find an induced subgraph $S$ of $G$ such that (1) $S$ is isomorphic to $H$, and (2) $S$ forms a dominating set in $G$. Fine-grained complexity results show that on worst-case inputs, any significant improvement over the naive brute-force algorithm is unlikely, as this would refute the Strong Exponential Time Hypothesis. Nevertheless, a recent work by Dransfeld et al. (ESA 2025) reveals some significant improvement potential particularly in \emph{sparse} graphs. We ask: Can algorithms with conditionally almost-optimal worst-case performance solve the Dominating $H$-Pattern, for selected patterns $H$, efficiently on practical inputs? We develop and experimentally evaluate several approaches on a large benchmark of diverse datasets, including baseline approaches using the Glasgow Subgraph Solver (GSS), the SAT solver Kissat, and the ILP solver Gurobi. Notably, while a straightforward implementation of the algorithms -- with conditionally close-to-optimal worst-case guarantee -- performs comparably to existing solvers, we propose a tailored Branch-\&-Bound approach -- supplemented with careful pruning techniques -- that achieves improvements of up to two orders of magnitude on our test instances.

Abstract
Recent advancements in generative artificial intelligence (GenAI), particularly large language models, have introduced new possibilities for software development practices. In our paper we investigate the emerging Vibe Coding (VC) paradigm that emphasizes intuitive, affect-driven, and improvisational interactions between developers and AI systems. Building upon the discourse of End-User Development (EUD), we explore how VC diverges from conventional programming approaches such as those supported by tools like GitHub Copilot. Through five semi-structured interview sessions with ten experienced software practitioners, we identify five thematic dimensions: creativity, sustainability, the future of programming, collaboration, and criticism. Our analysis conceptualizes VC within the metaphor of co-drifting, contrasting it with the prevalent co-piloting perspective of AI-assisted development. We argue that VC reconfigures the developers role, blurring boundaries between professional and non-developers. While VC enables novel forms of expression and rapid prototyping, it also introduces challenges regarding reproducibility, scalability, and inclusivity. We propose that VC represents a meaningful shift in programming culture, warranting further investigation within human-computer interaction (HCI) and software engineering research.

AI Insights

• Interviews with 15 CS experts reveal vibe coding lowers the technical entry barrier, inviting non‑developers to prototype quickly.
• Participants compared vibe coding’s flow to musical improvisation, suggesting a new cognitive model for code generation.
• The study highlights a need for structured training, as users report gaps in mastering affect‑driven coding.
• Compared to Agentic AI, vibe coding prioritizes human intuition over autonomous decision‑making, reshaping the developer–AI partnership.
• Appropriation infrastructure, per Stevens et al., is essential for customizing vibe coding workflows across domains.
• Key readings: “End‑User Development: An Emerging Paradigm” (Lieberman et al.) and “Vibe Coding vs. Agentic Coding” (Sapkota et al.).