Why we think this paper is great for you:
This paper introduces a novel language for choreographic programming, which directly aligns with your interest in programming language design and exploring new programming paradigms. You will find its approach to robust distributed applications particularly insightful.

Abstract
We built Chorex, a language that brings choreographic programming to Elixir as a path toward robust distributed applications. Chorex is unique among choreographic languages because it tolerates failure among actors: when an actor crashes, Chorex spawns a new process, restores state using a checkpoint, and updates the network configuration for all actors. Chorex also proves that full-featured choreographies can be implemented via metaprogramming, and that doing so achieves tight integration with the host language. For example, mismatches between choreography requirements and an actor implementation are reported statically and in terms of source code rather than macro-expanded code. This paper illustrates Chorex on several examples, ranging from a higher-order bookseller to a secure remote password protocol, details its implementation, and measures the overhead of checkpointing. We conjecture that Chorex's projection strategy, which outputs sets of stateless functions, is a viable approach for other languages to support restartable actors.

AI Summary

• Choreographic Programming: A paradigm where a global program describes interactions among actors in a system, which is then projected to a set of local programs for each actor. [3]
• Delivery Notation (~>): A domain-specific notation in Chorex that describes communication between two actors, specifying a sender's expression and a receiver's variable binding. [3]
• Chorex uniquely enables restartable actors in choreographic programming by tolerating actor failures through automated process spawning, state restoration from checkpoints, and network configuration updates. [2]
• The language leverages Elixir's metaprogramming capabilities to achieve tight host-language integration, providing static compile-time error reporting (e.g., for mismatched choreography requirements or missing knowledge-of-choice) directly in terms of source code. [2]
• Chorex introduces `checkpoint`/`rescue` blocks, allowing programmers to explicitly define recovery behavior, which the compiler translates into actor-specific state checkpointing and mechanisms to prevent advancement into unrecoverable states. [2]
• Its novel projection strategy translates choreographies into sets of stateless GenServer functions, managing custom control stacks and mailboxes to facilitate out-of-order message receives and robust recovery from crashes. [2]
• The system integrates with Elixir's supervision trees, employing a `RuntimeMonitor` to detect actor crashes, orchestrate restarts, restore checkpointed state, and broadcast network configuration updates to all participants. [2]
• Chorex's approach of projecting to GenServers, coupled with custom stack/mailbox management and live variable analysis, is conjectured to be a viable strategy for other languages to implement restartable actors. [2]
• The performance overhead of Chorex's checkpointing mechanism is generally low, with memory usage for actor stacks growing logarithmically due to delta saving, making the restartability feature practical for many applications. [2]
• Located Expressions: Variables and expressions explicitly associated with a specific actor (e.g., `Alice.e`), ensuring that actors only access information explicitly sent to them. [1]

Why we think this paper is great for you:
This work explores agent-oriented visual programming, offering a distinct programming paradigm and a unique approach to language design. You will appreciate its discussion contrasting with procedural programming.

Abstract
In this paper we introduce and discuss an approach for multi-agent-oriented visual programming. This aims at enabling individuals without programming experience but with knowledge in specific target domains to design and (re)configure autonomous software. We argue that, compared to procedural programming, it should be simpler for users to create programs when agent abstractions are employed. The underlying rationale is that these abstractions, and specifically the belief-desire-intention architecture that is aligned with human practical reasoning, match more closely with people's everyday experience in interacting with other agents and artifacts in the real world. On top of this, we designed and implemented a visual programming system for agents that hides the technicalities of agent-oriented programming using a blocks-based visual development environment that is built on the JaCaMo platform. To further validate the proposed solution, we integrate the Web of Things (WoT) to let users create autonomous behaviour on top of physical mashups of devices, following the trends in industrial end-user programming. Finally, we report on a pilot user study where we verified that novice users are indeed able to make use of this development environment to create multi-agent systems to solve simple automation tasks.

Why we think this paper is great for you:
This paper delves into raising abstraction for FPGA programming, touching upon principles of high-level language design and how new paradigms can improve productivity. You might find the discussion on managing low-level details within a high-level framework very relevant.

Abstract
Hardware design faces a fundamental challenge: raising abstraction to improve productivity while maintaining control over low-level details like cycle accuracy. Traditional RTL design in languages like SystemVerilog composes modules through wiring-style connections that provide weak guarantees for behavioral correctness. While high-level synthesis (HLS) and emerging abstractions attempt to address this, they either introduce unpredictable overhead or restrict design generality. Although transactional HDLs provide a promising foundation by lifting design abstraction to atomic and composable rules, they solely model intra-cycle behavior and do not reflect the native temporal design characteristics, hindering applicability and productivity for FPGA programming scenarios. We propose temporal hardware transactions, a new abstraction that brings cycle-level timing awareness to designers at the transactional language level. Our approach models temporal relationships between rules and supports the description of rules whose actions span multiple clock cycles, providing intuitive abstraction to describe multi-cycle architectural behavior. We implement this in Cement2, a transactional HDL embedded in Rust, enabling programming hardware constructors to build both intra-cycle and temporal transactions. Cement2's synthesis framework lowers description abstraction through multiple analysis and optimization phases, generating efficient hardware. With Cement2's abstraction, we program a RISC-V soft-core processor, custom CPU instructions, linear algebra kernels, and systolic array accelerators, leveraging the high-level abstraction for boosted productivity. Evaluation shows that Cement2 does not sacrifice performance and resources compared to hand-coded RTL designs, demonstrating the high applicability for general FPGA design tasks.

Why we think this paper is great for you:
This paper discusses a 'paradigm of software automation,' which, while not a programming paradigm in the traditional sense, explores a significant shift in software development approaches. You may find its perspective on the future of software creation thought-provoking.

Abstract
Software development automation is a long-term goal in software engineering. With the development of artificial intelligence (AI), more and more researchers are exploring approaches to software automation. They view AI systems as tools or assistants in software development, still requiring significant human involvement. Another initiative is ``vibe coding'', where AI systems write and repeatedly revise most (or even all) of the code. We foresee these two development paths will converge towards the same destination: AI systems participate in throughout the software development lifecycle, expanding boundaries of full-stack software development. In this paper, we present a vision of an iterative end-to-end automated software development paradigm AutoSW. It operates in an analyze-plan-implement-deliver loop, where AI systems as human partners become first-class actors, translating human intentions expressed in natural language into executable software. We explore a lightweight prototype across the paradigm and initially execute various representative cases. The results indicate that AutoSW can successfully deliver executable software, providing a feasible direction for truly end-to-end automated software development.

Why we think this paper is great for you:
This paper focuses on improving introductory programming education, which can offer insights into the practical application and understanding of different programming concepts and paradigms. You might find value in its approach to making programming more accessible.

Abstract
Although CS programs are booming, introductory courses like CS1 still adopt a one-size-fits-all formats that can exacerbate cognitive load and discourage learners with autism, ADHD, dyslexia and other neurological conditions. These call for compassionate pedagogies and Universal Design For Learning (UDL) to create learning environments and materials where cognitive diversity is welcomed. To address this, we introduce DiverseClaire a pilot study, which simulates students including neurodiverse profiles using LLMs and diverse personas. By leveraging Bloom's Taxonomy and UDL, DiverseClaire compared UDL-transformed lecture slides with traditional formats. To evaluate DiverseClaire controlled experiments, we used the evaluation metric the average score. The findings revealed that the simulated neurodiverse students struggled with learning due to lecture slides that were in inaccessible formats. These results highlight the need to provide course materials in multiple formats for diverse learner preferences. Data from our pilot study will be made available to assist future CS1 instructors.

Why we think this paper is great for you:
This paper explores the motivations and challenges within software engineering, providing a broader context for the field you are interested in. You may find it interesting to understand the human factors influencing programming practice.

Abstract
Motivations and challenges jointly shape how individuals enter, persist, and evolve within software engineering (SE), yet their interplay remains underexplored across the transition from education to professional practice. We conducted 15 semi-structured interviews and employed the Gioia Methodology, an adapted grounded theory methodology from organizational behavior, to inductively derive taxonomies of motivations and challenges, and build the Exposure-Pursuit-Evaluation (EPE) Process Model. Our findings reveal that impactful early exposure triggers intrinsic motivations, while non-impactful exposure requires an extrinsic push (e.g., career/ personal goals, external validation). We identify curiosity and avoiding alternatives as a distinct educational drivers, and barriers to belonging as the only challenge persisting across education and career. Our findings show that career progression challenges (e.g., navigating the corporate world) constrain extrinsic fulfillment while technical training challenges, barriers to belonging and threats to motivation constrain intrinsic fulfillment. The theory shows how unmet motivations and recurring challenges influence persistence, career shifts, or departure from the field. Our results provide a grounded model for designing interventions that strengthen intrinsic fulfillment and reduce systemic barriers in SE education and practice.

Why we think this paper is great for you:
This paper introduces a tool for exploring relationships across data sources, which, while not directly about programming paradigms, might touch upon data flow concepts. You may find its approach to data organization and retrieval useful.

Abstract
Exploring relationships across data sources is a crucial optimization for entities recognition. Since databases can store big amount of information with synthetic and organic data, serving all quantity of objects correctly is an important task to deal with. However, the decision of how to construct entity relationship model is associated with human factor. In this paper, we present flow-oriented entity-relationship tool. This is first and unique end-to-end solution that eliminates routine and resource-intensive problems of processing, creating and visualizing both of explicit and implicit dependencies for prominent SQL dialects on-the-fly. Once launched, FLOWER automatically detects built-in constraints and starting to create own correct and necessary one using dynamic sampling and robust data analysis techniques. This approach applies to improve entity-relationship model and data storytelling to better understand the foundation of data and get unseen insights from DB sources using SQL or natural language. Evaluated on state-of-the-art STATS benchmark, experiments show that FLOWER is superior to reservoir sampling by 2.4x for distribution representation and 2.6x for constraint learning with 2.15x acceleration. For data storytelling, our tool archives 1.19x for accuracy enhance with 1.86x context decrease compare to LLM. Presented tool is also support 23 languages and compatible with both of CPU and GPU. Those results show that FLOWER can manage with real-world data a way better to ensure with quality, scalability and applicability for different use-cases.