Tootfinder

from my link log —
Exploit a binary with sigreturn oriented programming (SROP).
https://rog3rsm1th.github.io/posts/sigreturn-oriented-programming/
saved 2021-06-22

Well, here we go. After well over two years, here's a new version of my programming languages book, PLAI (v3.2.5). As always, free of cost! Can't thank enough all the people named in the acknowledgments. Enjoy!
https://www.plai.org/

The Effects of GitHub Copilot on Computing Students' Programming Effectiveness, Efficiency, and Processes in Brownfield Programming Tasks
Md Istiak Hossain Shihab, Christopher Hundhausen, Ahsun Tariq, Summit Haque, Yunhan Qiao, Brian Mulanda
https://arxiv.org/abs/2506.10051

The Effects of GitHub Copilot on Computing Students' Programming Effectiveness, Efficiency, and Processes in Brownfield Programming Tasks
When graduates of computing degree programs enter the software industry, they will most likely join teams working on legacy code bases developed by people other than themselves. In these so-called brownfield software development settings, generative artificial intelligence (GenAI) coding assistants like GitHub Copilot are rapidly transforming software development practices, yet the impact of GenAI on student programmers performing brownfield development tasks remains underexplored. This paper i…

Seriously, who decided that "request," "response," and "result" should all begin with the same two letters? Damnit, English, could you spare *one* second for folks trying to write HTTP handling logic?
#Programming #PHP

Paramount DTC Chair Cindy Holland says Paramount is now open to buying third party content, reminiscent of Holland's strategy when she was at Netflix (Nellie Andreeva/Deadline)
https://deadline.com/2025/08/paramount-plus-outside-studios-releas…

Paramount+ Opening Up To Outside Studios, May Experiment With Release Patterns, Won’t Try To Replicate CBS-Style Programming
Paramount+ is opening up to outside studios, may experiment with release patterns & won't try to replicate CBS-style programming, Cindy Holland says.

Multi-timescale Stochastic Programming with Applications in Power Systems
Yihang Zhang, Suvrajeet Sen
https://arxiv.org/abs/2508.08520 https://arxiv.org/pd…

Multi-timescale Stochastic Programming with Applications in Power Systems
This paper introduces a multi-timescale stochastic programming framework designed to address decision-making challenges in power systems, particularly those with high renewable energy penetration. The framework models interactions across different timescales using aggregated state variables to coordinate decisions. In addition to Multi-timescale uncertainty modeled via multihorizon trees, we also introduce a "synchronized state approximation," which periodically aligns states across timescales …

I really like the ideas. So far this is my set of 🤓 nerdy cards (although Agile Poker is not really a game).
Especially the "Exploding Git Commits" is nice, since I'm an Exploding Kittens fan. 💥🐱
Cash you recommend other games?
#programming #programmers

An Efficient Application of Goal Programming to Tackle Multiobjective Problems with Recurring Fitness Landscapes
Rodrigo Lankaites Pinheiro, Dario Landa-Silva, Wasakorn Laesanklang, Ademir Aparecido Constantino
https://arxiv.org/abs/2508.08297

An Efficient Application of Goal Programming to Tackle Multiobjective Problems with Recurring Fitness Landscapes
Many real-world applications require decision-makers to assess the quality of solutions while considering multiple conflicting objectives. Obtaining good approximation sets for highly constrained many-objective problems is often a difficult task even for modern multiobjective algorithms. In some cases, multiple instances of the problem scenario present similarities in their fitness landscapes. That is, there are recurring features in the fitness landscapes when searching for solutions to differ…

Teaching Introduction to Programming in the times of AI: A case study of a course re-design
Nikolaos Avouris, Kyriakos Sgarbas, George Caridakis, Christos Sintoris
https://arxiv.org/abs/2508.06572

Teaching Introduction to Programming in the times of AI: A case study of a course re-design
The integration of AI tools into programming education has become increasingly prevalent in recent years, transforming the way programming is taught and learned. This paper provides a review of the state-of-the-art AI tools available for teaching and learning programming, particularly in the context of introductory courses. It highlights the challenges on course design, learning objectives, course delivery and formative and summative assessment, as well as the misuse of such tools by the studen…

It’s always “AI is great for generating boilerplate code” and never “why do we even need boilerplate code, maybe programming is broken”

Singapore-based Augmentus, which is developing a no-code interface for factory engineers to deploy autonomous robotic surface finishing systems, raised $11M (Duncan Riley/SiliconANGLE)
https://siliconangle.com/2025/07/09/augmentus-lands-11m…

A lot of the design work that goes into programming languages and tools is about prompting developers to •think about meaning•: tests, types, scope, compile errors, runtime errors — all about •preventing code from running• in the presence of an expectation/reality mismatch.
I’m always on high alert for tools that promise to speed development by letting developers skip the thinking.
5/

Choreographic Quick Changes: First-Class Location (Set) Polymorphism
Ashley Samuelson, Andrew K. Hirsch, Ethan Cecchetti
https://arxiv.org/abs/2506.10913 h…

Choreographic Quick Changes: First-Class Location (Set) Polymorphism
Choreographic programming is a promising new paradigm for programming concurrent systems where a developer writes a single centralized program that compiles to individual programs for each node. Existing choreographic languages, however, lack critical features integral to modern systems, like the ability of one node to dynamically compute who should perform a computation and send that decision to others. This work addresses this gap with $λ_{QC}$, the first typed choreographic language with \e…

Inside every developer there are two wolves.
One wolf worries about cache invalidation.
The other wolf ponders deeply about the naming of things.
The third wolf makes off-by-one errors.
#programming #humor

Someone had too much fun making this: https://github.com/W1LDN16H7/JPL

GitHub - W1LDN16H7/JPL: The JSON Programming Language
The JSON Programming Language. Contribute to W1LDN16H7/JPL development by creating an account on GitHub.

TIFF Pulls Invite For October 7th Documentary 'The Road Between Us'; Filmmakers Say Fest Has "Censored Its Own Programming" (Anthony D'Alessandro/Deadline)
https://deadline.com/2025/08/tiff-pulls-october-7-documentary-from-lineup-1236484968/
http://www.memeorandum.com/250813/p100#a250813p100

Has anybody seen #RFC9727
(api-catalog: A Well-Known URI and Link Relation to Help Discovery of APIs) implemented anywhere on the internet yet?
https://www.rfc-editor.org/rfc/rfc9727.html

Efficient Task Graph Scheduling for Parallel QR Factorization in SLSQP
Soumyajit Chatterjee, Rahul Utkoor, Uppu Eshwar, Sathya Peri, V. Krishna Nandivada
https://arxiv.org/abs/2506.09463

Efficient Task Graph Scheduling for Parallel QR Factorization in SLSQP
Efficient task scheduling is paramount in parallel programming on multi-core architectures, where tasks are fundamental computational units. QR factorization is a critical sub-routine in Sequential Least Squares Quadratic Programming (SLSQP) for solving non-linear programming (NLP) problems. QR factorization decomposes a matrix into an orthogonal matrix Q and an upper triangular matrix R, which are essential for solving systems of linear equations arising from optimization problems. SLSQP uses …

I've learned to use two new tools in the last weeks: https://bevy.org (a well-known game programming framework) and https://hax.cryspen.com

Bevy Engine
Bevy is a refreshingly simple data-driven game engine built in Rust. It is free and open-source forever!

Causal Graph Recovery in Neuroimaging through Answer Set Programming
Mohammadsajad Abavisani, Kseniya Solovyeva, David Danks, Vince Calhoun, Sergey Plis
https://arxiv.org/abs/2506.09286

Causal Graph Recovery in Neuroimaging through Answer Set Programming
Learning graphical causal structures from time series data presents significant challenges, especially when the measurement frequency does not match the causal timescale of the system. This often leads to a set of equally possible underlying causal graphs due to information loss from sub-sampling (i.e., not observing all possible states of the system throughout time). Our research addresses this challenge by incorporating the effects of sub-sampling in the derivation of causal graphs, resulting…

Towards General-Purpose Data Discovery: A Programming Languages Approach
Andrew Kang, Yashnil Saha, Sainyam Galhotra
https://arxiv.org/abs/2508.08074 https://

Towards General-Purpose Data Discovery: A Programming Languages Approach
Efficient and effective data discovery is critical for many modern applications in machine learning and data science. One major bottleneck to the development of a general-purpose data discovery tool is the absence of an expressive formal language, and corresponding implementation, for characterizing and solving generic discovery queries. To this end, we present TQL, a domain-specific language for data discovery well-designed to leverage and exploit the results of programming languages research …

'Beyoncé Bowl' Christmas Ravens-Texans halftime show wins Emmy https://www.espn.com/nfl/story/_/id/45959699/beyonce-bowl-emmy-award-win-christmas-day-ravens-texans

Heterogeneous Dynamic Logic: Provability Modulo Program Theories
Samuel Teuber, Mattias Ulbrich, Andr\'e Platzer, Bernhard Beckert
https://arxiv.org/abs/2507.08581

Heterogeneous Dynamic Logic: Provability Modulo Program Theories
Formally specifying, let alone verifying, properties of systems involving multiple programming languages is inherently challenging. We introduce Heterogeneous Dynamic Logic (HDL), a framework for combining reasoning principles from distinct (dynamic) program logics in a modular and compositional way. HDL mirrors the architecture of satisfiability modulo theories (SMT): Individual dynamic logics, along with their calculi, are treated as dynamic theories that can be flexibly combined to reason ab…

Tailored First-order and Interior-point methods and a new semidefinite programming hierarchy for entanglement detection
Javier Pena, Vikesh Siddhu, Sridhar Tayur
https://arxiv.org/abs/2508.05854

Tailored First-order and Interior-point methods and a new semidefinite programming hierarchy for entanglement detection
Quantum entanglement lies at the heart of quantum information science, yet its reliable detection in high-dimensional or noisy systems remains a fundamental computational challenge. Semidefinite programming (SDP) hierarchies, such as the Doherty-Parrilo-Spedalieri (DPS) and Extension (EXT) hierarchies, offer complete methods for entanglement detection, but their practical use is limited by exponential growth in problem size. In this paper, we introduce a new SDP hierarchy, PST, that is sandwich…

google_web: Old Google web graph (2002)
A web graph representing a crawl of a portion of the general WWW, from a 2002 Google Programming contest.
This network has 916428 nodes and 5105039 edges.
Tags: Informational, Web graph, Unweighted
https://networks.skewed.de/net/google_web

Energy-Aware Code Generation with LLMs: Benchmarking Small vs. Large Language Models for Sustainable AI Programming
Humza Ashraf, Syed Muhammad Danish, Aris Leivadeas, Yazan Otoum, Zeeshan Sattar
https://arxiv.org/abs/2508.08332

Energy-Aware Code Generation with LLMs: Benchmarking Small vs. Large Language Models for Sustainable AI Programming
Large Language Models (LLMs) are widely used for code generation. However, commercial models like ChatGPT require significant computing power, which leads to high energy use and carbon emissions. This has raised concerns about their environmental impact. In this study, we evaluate open-source Small Language Models (SLMs) trained explicitly for code generation and compare their performance and energy efficiency against large LLMs and efficient human-written Python code. The goal is to investigat…

Hazel Deriver: A Live Editor for Constructing Rule-Based Derivations
Zhiyao Zhong, Cyrus Omar
https://arxiv.org/abs/2506.10781 https://

Hazel Deriver: A Live Editor for Constructing Rule-Based Derivations
Students in programming languages and formal logic courses often struggle with constructing rule-based derivation trees due to the complexity of applying inference rules, the lack of immediate feedback, and the manual effort required for handwritten proofs. We present Hazel Deriver, a live, web-based editor designed to scaffold derivation construction through multiple layers of support. Built on the Hazel live programming environment, it provides a structured, interactive experience that encour…

AutoCodeBench: Large Language Models are Automatic Code Benchmark Generators
Jason Chou, Ao Liu, Yuchi Deng, Zhiying Zeng, Tao Zhang, Haotian Zhu, Jianwei Cai, Yue Mao, Chenchen Zhang, Lingyun Tan, Ziyan Xu, Bohui Zhai, Hengyi Liu, Speed Zhu, Wiggin Zhou, Fengzong Lian
https://arxiv.org/abs/2508.09101

AutoCodeBench: Large Language Models are Automatic Code Benchmark Generators
Large Language Models (LLMs) have demonstrated remarkable capabilities across various domains, with code generation emerging as a key area of focus. While numerous benchmarks have been proposed to evaluate their code generation abilities, these benchmarks face several critical limitations. First, they often rely on manual annotations, which are time-consuming and difficult to scale across different programming languages and problem complexities. Second, most existing benchmarks focus primarily …

Dredging up recollections of my experience as R6RS editor for my PLSS talk tomorrow.
https://2025.ecoop.org/details/plss-2025-papers/8/Do-Programming-Languages-Fulfill-Requirements-Should-They-

Yup, the hard part isn’t writing code.
I’m always a bit cautious of the argument that the barriers are a good thing. That easily slips into harmful gatekeeping if we aren’t careful. It’s not good when programming is inaccessible or unwelcoming.
What •is• good is that writing code slows you down and (if you’re good) makes you •think• about what the heck you’re doing — the work @… is talking about — with a depth and detail that no amount of chin-stroking and up-front design work can match. Skipping that work, however you skip it, is a false gain.
https://infosec.exchange/@saraislet/114851365996475798

Koopman Operator Based Linear Model Predictive Control for Quadruped Trotting
Chun-Ming Yang, Pranav A. Bhounsule
https://arxiv.org/abs/2508.08259 https://…

Koopman Operator Based Linear Model Predictive Control for Quadruped Trotting
Online optimal control of quadruped robots would enable them to adapt to varying inputs and changing conditions in real time. A common way of achieving this is linear model predictive control (LMPC), where a quadratic programming (QP) problem is formulated over a finite horizon with a quadratic cost and linear constraints obtained by linearizing the equations of motion and solved on the fly. However, the model linearization may lead to model inaccuracies. In this paper, we use the Koopman opera…

"The destruction of the climate by industrial processes is a real-world problem. If programming language selection has no impact on it, then maybe we’re all just wasting our time, creating shiny consumer distractions to make the last few years of humanity that little more palatable for the richest 1% of the world’s human population."

Augmentation approaches for Mixed Integer Programming
Justo Puerto, Jose A. Ruiz-Alba
https://arxiv.org/abs/2507.08525 https://arxiv.…

Augmentation approaches for Mixed Integer Programming
We are interested in studying the structure of the feasible sets of MIPs and its relation with the existence of a finite cardinality test set which can be applied in augmentation algorithms. This paper characterizes a computable, finite test set for MIP which can be embedded in an augmentation algorithm. Several examples illustrate the structure of this set and its relationship with previous approaches in the literature.

Arabic news channel Alhurra has replaced its programming with an image accusing the USAGM of illegally withholding Congress-approved funding for its parent MBN (Matthew Keys/The Desk)
https://thedesk.net/2025/06/alhurra-calls-out-usagm-funding-cuts/

Alhurra calls out U.S. Agency for Global Media over funding cuts
The Arabic-language satellite TV channel said the federal agency is "illegally withholding" Congressionally-approved funds for its broadcast operations.

Empowering Children to Create AI-Enabled Augmented Reality Experiences
Lei Zhang, Shuyao Zhou, Amna Liaqat, Tinney Mak, Brian Berengard, Emily Qian, Andr\'es Monroy-Hern\'andez
https://arxiv.org/abs/2508.08467

Empowering Children to Create AI-Enabled Augmented Reality Experiences
Despite their potential to enhance children's learning experiences, AI-enabled AR technologies are predominantly used in ways that position children as consumers rather than creators. We introduce Capybara, an AR-based and AI-powered visual programming environment that empowers children to create, customize, and program 3D characters overlaid onto the physical world. Capybara enables children to create virtual characters and accessories using text-to-3D generative AI models, and to animate thes…

Programming as Theory Building: Why Senior Developers Are More Valuable Than Ever
https://cekrem.github.io/posts/programming-as-theory-building-naur/

Symmetry breaking for inductive logic programming
Andrew Cropper, David M. Cerna, Matti J\"arvisalo
https://arxiv.org/abs/2508.06263 https://arxiv.org…

Symmetry breaking for inductive logic programming
The goal of inductive logic programming is to search for a hypothesis that generalises training data and background knowledge. The challenge is searching vast hypothesis spaces, which is exacerbated because many logically equivalent hypotheses exist. To address this challenge, we introduce a method to break symmetries in the hypothesis space. We implement our idea in answer set programming. Our experiments on multiple domains, including visual reasoning and game playing, show that our approach …

Between Tool and Trouble: Student Attitudes Toward AI in Programming Education
Sergio Rojas-Galeano, Julian Tejada, Fernando Marmolejo-Ramos
https://arxiv.org/abs/2508.05999 htt…

Between Tool and Trouble: Student Attitudes Toward AI in Programming Education
This study examines how AI code assistants shape novice programmers experiences during a two-part exam in an introductory programming course. In the first part, students completed a programming task with access to AI support; in the second, they extended their solutions without AI. We collected Likert-scale and open-ended responses from 20 students to evaluate their perceptions and challenges. Findings suggest that AI tools were perceived as helpful for understanding code and increasing confide…

Being rather frustrated with programming Clojure in IntelliJ, (mainly because Cursive and IdeaVim don't like each other) I tried to set up Neovim with the Conjure plugin and it 's an absolute blast to use the REPL with it.
Also I discovered that there is a Lisp on top of Lua called Fennel, which I'm looking forward to play with
#Programming

Letzter Feinschliff an meinem Vortrag „So helfen uns LLMs beim Programmieren“ beim Tübix heute um 14 Uhr in V2:
https://slides.cusy.io/ai/how-llms-help-us-with-programming.slides.html

CLAPP: The CLASS LLM Agent for Pair Programming
Santiago Casas, Christian Fidler, Boris Bolliet, Francisco Villaescusa-Navarro, Julien Lesgourgues
https://arxiv.org/abs/2508.05728

CLAPP: The CLASS LLM Agent for Pair Programming
We introduce CLAPP (CLASS LLM Agent for Pair Programming), an interactive AI assistant designed to support researchers working with the Einstein-Boltzmann solver CLASS. CLAPP leverages large language models (LLMs) and domain-specific retrieval to provide conversational coding support for CLASS-answering questions, generating code, debugging errors, and producing plots. Its architecture combines multi-agent LLM orchestration, semantic search across CLASS documentation, and a live Python executio…

Sum Rate Maximization for Pinching Antennas Assisted RSMA System With Multiple Waveguides
Peiyu Wang, Hong Wang, Rongfang Song
https://arxiv.org/abs/2506.10596

Sum Rate Maximization for Pinching Antennas Assisted RSMA System With Multiple Waveguides
In this letter, a pinching antennas (PAs) assisted rate splitting multiple access (RSMA) system with multiple waveguides is investigated to maximize sum rate. A two-step algorithm is proposed to determine PA activation scheme and optimize the waveguide beamforming. Specifically, a low complexity spatial correlation and distance based method is proposed for PA activation selection. After determining the PA activation status, a semi-definite programming (SDP) based successive convex approximation…

So, making slow progress as I learn `rust` things. Instead of going with my usual `union`/`struct` combination in C, I'm resorting to not overflowing/underflowing primitive types and doing things more safely. This snippet of code took far longer than it should've, but it gets the job done.
#programming

Fractional Programming for Stochastic Precoding over Generalized Fading Channels
Wenyu Wang, Kaiming Shen
https://arxiv.org/abs/2507.06944 https://

Fractional Programming for Stochastic Precoding over Generalized Fading Channels
This paper seeks an efficient algorithm for stochastic precoding to maximize the long-term average weighted sum rates throughout a multiple-input multiple-output (MIMO) network. Unlike many existing works that assume a particular probability distribution model for fading channels (which is typically Gaussian), our approach merely relies on the first and second moments of fading channels. For the stochastic precoding problem, a naive idea is to directly apply the fractional programming (FP) meth…

Should we teach vibe coding? Here's why not.
Should AI coding be taught in undergrad CS education?
1/2
I teach undergraduate computer science labs, including for intro and more-advanced core courses. I don't publish (non-negligible) scholarly work in the area, but I've got years of craft expertise in course design, and I do follow the academic literature to some degree. In other words, In not the world's leading expert, but I have spent a lot of time thinking about course design, and consider myself competent at it, with plenty of direct experience in what knowledge & skills I can expect from students as they move through the curriculum.
I'm also strongly against most uses of what's called "AI" these days (specifically, generative deep neutral networks as supplied by our current cadre of techbro). There are a surprising number of completely orthogonal reasons to oppose the use of these systems, and a very limited number of reasonable exceptions (overcoming accessibility barriers is an example). On the grounds of environmental and digital-commons-pollution costs alone, using specifically the largest/newest models is unethical in most cases.
But as any good teacher should, I constantly question these evaluations, because I worry about the impact on my students should I eschew teaching relevant tech for bad reasons (and even for his reasons). I also want to make my reasoning clear to students, who should absolutely question me on this. That inspired me to ask a simple question: ignoring for one moment the ethical objections (which we shouldn't, of course; they're very stark), at what level in the CS major could I expect to teach a course about programming with AI assistance, and expect students to succeed at a more technically demanding final project than a course at the same level where students were banned from using AI? In other words, at what level would I expect students to actually benefit from AI coding "assistance?"
To be clear, I'm assuming that students aren't using AI in other aspects of coursework: the topic of using AI to "help you study" is a separate one (TL;DR it's gross value is not negative, but it's mostly not worth the harm to your metacognitive abilities, which AI-induced changes to the digital commons are making more important than ever).
So what's my answer to this question?
If I'm being incredibly optimistic, senior year. Slightly less optimistic, second year of a masters program. Realistic? Maybe never.
The interesting bit for you-the-reader is: why is this my answer? (Especially given that students would probably self-report significant gains at lower levels.) To start with, [this paper where experienced developers thought that AI assistance sped up their work on real tasks when in fact it slowed it down] (https://arxiv.org/abs/2507.09089) is informative. There are a lot of differences in task between experienced devs solving real bugs and students working on a class project, but it's important to understand that we shouldn't have a baseline expectation that AI coding "assistants" will speed things up in the best of circumstances, and we shouldn't trust self-reports of productivity (or the AI hype machine in general).
Now we might imagine that coding assistants will be better at helping with a student project than at helping with fixing bugs in open-source software, since it's a much easier task. For many programming assignments that have a fixed answer, we know that many AI assistants can just spit out a solution based on prompting them with the problem description (there's another elephant in the room here to do with learning outcomes regardless of project success, but we'll ignore this over too, my focus here is on project complexity reach, not learning outcomes). My question is about more open-ended projects, not assignments with an expected answer. Here's a second study (by one of my colleagues) about novices using AI assistance for programming tasks. It showcases how difficult it is to use AI tools well, and some of these stumbling blocks that novices in particular face.
But what about intermediate students? Might there be some level where the AI is helpful because the task is still relatively simple and the students are good enough to handle it? The problem with this is that as task complexity increases, so does the likelihood of the AI generating (or copying) code that uses more complex constructs which a student doesn't understand. Let's say I have second year students writing interactive websites with JavaScript. Without a lot of care that those students don't know how to deploy, the AI is likely to suggest code that depends on several different frameworks, from React to JQuery, without actually setting up or including those frameworks, and of course three students would be way out of their depth trying to do that. This is a general problem: each programming class carefully limits the specific code frameworks and constructs it expects students to know based on the material it covers. There is no feasible way to limit an AI assistant to a fixed set of constructs or frameworks, using current designs. There are alternate designs where this would be possible (like AI search through adaptation from a controlled library of snippets) but those would be entirely different tools.
So what happens on a sizeable class project where the AI has dropped in buggy code, especially if it uses code constructs the students don't understand? Best case, they understand that they don't understand and re-prompt, or ask for help from an instructor or TA quickly who helps them get rid of the stuff they don't understand and re-prompt or manually add stuff they do. Average case: they waste several hours and/or sweep the bugs partly under the rug, resulting in a project with significant defects. Students in their second and even third years of a CS major still have a lot to learn about debugging, and usually have significant gaps in their knowledge of even their most comfortable programming language. I do think regardless of AI we as teachers need to get better at teaching debugging skills, but the knowledge gaps are inevitable because there's just too much to know. In Python, for example, the LLM is going to spit out yields, async functions, try/finally, maybe even something like a while/else, or with recent training data, the walrus operator. I can't expect even a fraction of 3rd year students who have worked with Python since their first year to know about all these things, and based on how students approach projects where they have studied all the relevant constructs but have forgotten some, I'm not optimistic seeing these things will magically become learning opportunities. Student projects are better off working with a limited subset of full programming languages that the students have actually learned, and using AI coding assistants as currently designed makes this impossible. Beyond that, even when the "assistant" just introduces bugs using syntax the students understand, even through their 4th year many students struggle to understand the operation of moderately complex code they've written themselves, let alone written by someone else. Having access to an AI that will confidently offer incorrect explanations for bugs will make this worse.
To be sure a small minority of students will be able to overcome these problems, but that minority is the group that has a good grasp of the fundamentals and has broadened their knowledge through self-study, which earlier AI-reliant classes would make less likely to happen. In any case, I care about the average student, since we already have plenty of stuff about our institutions that makes life easier for a favored few while being worse for the average student (note that our construction of that favored few as the "good" students is a large part of this problem).
To summarize: because AI assistants introduce excess code complexity and difficult-to-debug bugs, they'll slow down rather than speed up project progress for the average student on moderately complex projects. On a fixed deadline, they'll result in worse projects, or necessitate less ambitious project scoping to ensure adequate completion, and I expect this remains broadly true through 4-6 years of study in most programs (don't take this as an endorsement of AI "assistants" for masters students; we've ignored a lot of other problems along the way).
There's a related problem: solving open-ended project assignments well ultimately depends on deeply understanding the problem, and AI "assistants" allow students to put a lot of code in their file without spending much time thinking about the problem or building an understanding of it. This is awful for learning outcomes, but also bad for project success. Getting students to see the value of thinking deeply about a problem is a thorny pedagogical puzzle at the best of times, and allowing the use of AI "assistants" makes the problem much much worse. This is another area I hope to see (or even drive) pedagogical improvement in, for what it's worth.
1/2

Do you also write down mostly undecipherable notes mixing languages when programming complex stuff?

Vidyut3d: a GPU accelerated fluid solver for non-equilibrium plasmas on adaptive grids
Hariswaran Sitaraman, Nicholas Deak, Taaresh Taneja
https://arxiv.org/abs/2507.08200

Vidyut3d: a GPU accelerated fluid solver for non-equilibrium plasmas on adaptive grids
We present the numerical methods, programming methodology, verification, and performance assessment of a non-equilibrium plasma fluid solver that can effectively utilize current and upcoming central processing and graphics processing unit (CPU+GPU) architectures, in this work. Our plasma fluid model solves the coupled conservation equations for species transport, electrostatic Poisson and electron temperature on adaptive Cartesian grids. Our solver is written using performance portable adaptive…

Notes on applicative matching logic
Laurentiu Leustean
https://arxiv.org/abs/2506.10088 https://arxiv.org/pdf/2506.10088

Notes on applicative matching logic
Matching logic (ML) was developed by Grigore Roşu and collaborators as a logic for defining the formal semantics of programming languages and for specifying and reasoning about the behavior of programs. These lecture notes present basic definitions and results on applicative matching logic (AML), a functional variant of ML introduced recently by Xiaohong Chen and Grigore Roşu. They can be used as an introductory text in the theory of AML. Monk's textbook on mathematical logic has an enormous …

I don't mind solving hard and interesting problems.
But I do get unreasonably angry at tools that so clearly care about only one specific use case and give a big FU to any other, like the one I'm trying to solve.
#Programming #PHP

Replaced article(s) found for cs.PL. https://arxiv.org/list/cs.PL/new
[1/1]:
- On the Origins of Objects by Means of Careful Selection
Yegor Bugayenko, Maxim Trunnikov

google_web: Old Google web graph (2002)
A web graph representing a crawl of a portion of the general WWW, from a 2002 Google Programming contest.
This network has 916428 nodes and 5105039 edges.
Tags: Informational, Web graph, Unweighted
https://networks.skewed.de/net/google_web

from my link log —
A review of the Helix editor after 1.5 years.
https://felix-knorr.net/posts/2025-03-16-helix-review.html
saved 2025-03-17 …

Inverted Classroom in der Einf\"uhrungsveranstaltung Programmierung
Ulrich von Zadow, Natalie Kiesler
https://arxiv.org/abs/2506.10057 https://…

Inverted Classroom in der Einführungsveranstaltung Programmierung
Traditionally, the introductory programming course for computer science students at Nuremberg Tech had been implemented as a combination of lectures and exercise sessions. Due to high failure rates in the winter semester 2023/24, an experimental teaching concept based on the inverted classroom was implemented for one cohort in the winter semester 2024/25. Students had to prepare themselves through literature work and activating teaching and learning methods. The course was accompanied by a seri…

"The overall life expectancy of a programming language has dwindled in the past 56 years. A COBOL developer in the 1960s most probably retired in the 2000s, still writing COBOL. As a former professional VBScript, then C#, then Objective-C, later Swift, and finally Go developer, I can only see this trend accelerating. We should expect our favorite programming language to be replaced and removed from the market in a relatively shorter time every decade."

That some people find “text box that spits out a broken version of what they want and then you yell at it until it’s sufficing” more convenient than using existing tools says a lot more about existing tools than about the text box.
E.g. programming has long been extremely overwrought and complex for no reason other than enterprise wankery and gatekeeping, see the various frameworks from Big Tech.
The same companies now rent you expensive tools that “make programming easy”, while their overly complex frameworks and environments are free of course.
Instead of fixing the problem we’re now having two problems.
(The same is true in other industries.)

HPCTransCompile: An AI Compiler Generated Dataset for High-Performance CUDA Transpilation and LLM Preliminary Exploration
Jiaqi Lv, Xufeng He, Yanchen Liu, Xu Dai, Yang Hu, Shouyi Yin
https://arxiv.org/abs/2506.10401

HPCTransCompile: An AI Compiler Generated Dataset for High-Performance CUDA Transpilation and LLM Preliminary Exploration
The rapid growth of deep learning has driven exponential increases in model parameters and computational demands. NVIDIA GPUs and their CUDA-based software ecosystem provide robust support for parallel computing, significantly alleviating computational bottlenecks. Meanwhile, due to the cultivation of user programming habits and the high performance of GPUs, the CUDA ecosystem has established a dominant position in the field of parallel software. This dominance requires other hardware platforms…

Replaced article(s) found for cs.PL. https://arxiv.org/list/cs.PL/new
[1/1]:
- Denotational Semantics of Gradual Typing using Synthetic Guarded Domain Theory (Extended Version)
Eric Giovannini, Tingting Ding, Max S. New

Combinatorial Algorithm for Tropical Linearly Factorized Programming
Yuki Nishida
https://arxiv.org/abs/2507.07596 https://arxiv.org/…

Combinatorial Algorithm for Tropical Linearly Factorized Programming
The tropical semiring is a set of numbers $\mathbb{R}\cup\{-\infty\}$ with addition $a\oplus b:=\max(a,b)$ and multiplication $a\otimes b:=a+b$. As well as in conventional algebra, linear programming problem in the tropical semiring has been developed. In this study, we introduce a new type of tropical optimization problem, namely, tropical linearly factorized programming problem. This problem involves minimizing the objective function given by the product of tropical linear forms $c_{k,1}\otim…

AutoTriton: Automatic Triton Programming with Reinforcement Learning in LLMs
Shangzhan Li, Zefan Wang, Ye He, Yuxuan Li, Qi Shi, Jianling Li, Yonggang Hu, Wanxiang Che, Xu Han, Zhiyuan Liu, Maosong Sun
https://arxiv.org/abs/2507.05687

AutoTriton: Automatic Triton Programming with Reinforcement Learning in LLMs
Kernel development in deep learning requires optimizing computational units across hardware while balancing memory management, parallelism, and hardware-specific optimizations through extensive empirical tuning. Although domain-specific languages like Triton simplify GPU programming by abstracting low-level details, developers must still manually tune critical parameters such as tile sizes and memory access patterns through iterative experimentation, creating substantial barriers to optimal per…

Syntactic Effectful Realizability in Higher-Order Logic
Liron Cohen (BGU), Ariel Grunfeld (BGU), Dominik Kirst (PICUBE), \'Etienne Miquey (I2M)
https://arxiv.org/abs/2506.09458

Syntactic Effectful Realizability in Higher-Order Logic
Realizability interprets propositions as specifications for computational entities in programming languages. Specifically, syntactic realizability is a powerful machinery that handles realizability as a syntactic translation of propositions into new propositions that describe what it means to realize the input proposition. This paper introduces EffHOL (Effectful Higher-Order Logic), a novel framework that expands syntactic realizability to uniformly support modern programming paradigms with sid…

Leveraging Generative AI for Enhancing Automated Assessment in Programming Education Contests
Stefan Dascalescu, Adrian Marius Dumitran, Mihai Alexandru Vasiluta
https://arxiv.org/abs/2506.05990

Leveraging Generative AI for Enhancing Automated Assessment in Programming Education Contests
Competitive programming contests play a crucial role in cultivating computational thinking and algorithmic skills among learners. However, generating comprehensive test cases to effectively assess programming solutions remains resource-intensive and challenging for educators. This paper introduces an innovative NLP-driven method leveraging generative AI (large language models) to automate the creation of high-quality test cases for competitive programming assessments. We extensively evaluated o…

Evaluating the Effectiveness of Large Language Models in Solving Simple Programming Tasks: A User-Centered Study
Kai Deng
https://arxiv.org/abs/2507.04043 …

Evaluating the Effectiveness of Large Language Models in Solving Simple Programming Tasks: A User-Centered Study
As large language models (LLMs) become more common in educational tools and programming environments, questions arise about how these systems should interact with users. This study investigates how different interaction styles with ChatGPT-4o (passive, proactive, and collaborative) affect user performance on simple programming tasks. I conducted a within-subjects experiment where fifteen high school students participated, completing three problems under three distinct versions of the model. Eac…

OpenAI releases GPT-5 pro, a version with extended reasoning exclusive to ChatGPT Pro subscribers, saying it scored 88.4% without tools on the GPQA benchmark (Maximilian Schreiner/The Decoder)
https://the-decoder.com/openai-claims-

OpenAI launches GPT-5 as a unified system with adaptive reasoning for complex tasks
OpenAI has unveiled GPT-5, a new AI system that builds on the reasoning advances of the o1 and o3 models and unifies every previous model line into a single adaptive architecture.

Disney's merging of Hulu into Disney could reduce operating costs, as Hulu will hit $4.1B in programming expenses and $2.9B in non-programming costs in FY 2025 (Todd Spangler/Variety)
https://variety.com/2025/digital/news/dis…

Why Disney Is Shutting Down Hulu App: Disney+ Integration to Save Billions in Costs
Disney could eliminate billions in operating expenses by merging Hulu fully into Disney+ and phasing out Hulu as a standalone app and service.

GhostShell: Streaming LLM Function Calls for Concurrent Embodied Programming
Jian Gong, Youwei Huang, Bo Yuan, Ming Zhu, Juncheng Zhan, Jinke Wang, Hang Shu, Mingyue Xiong, Yanjun Ye, Yufan Zu, Yang Zhou, Yihan Ding, Xuannian Chen, Xingyu Lu, Runjie Ban, Bingchao Huang, Fusen Liu
https://arxiv.org/abs/2508.05298

GhostShell: Streaming LLM Function Calls for Concurrent Embodied Programming
We present GhostShell, a novel approach that leverages Large Language Models (LLMs) to enable streaming and concurrent behavioral programming for embodied systems. In contrast to conventional methods that rely on pre-scheduled action sequences or behavior trees, GhostShell drives embodied systems to act on-the-fly by issuing function calls incrementally as tokens are streamed from the LLM. GhostShell features a streaming XML function token parser, a dynamic function interface mapper, and a mult…

from my link log —
How to take the inverse of a type.
https://2022.ecoop.org/details/ecoop-2022-papers/6/How-to-Take-the-Inverse-of-a-Type
saved 2025-06-03

How to Take the Inverse of a Type (ECOOP 2022 - Research Papers) - ECOOP 2022
ECOOP is Europe’s longest-standing annual Programming Languages (PL) conference, and welcomes high quality research papers relating to the PL field in a broad sense. This year the conference will feature dedicated paper categories for reproduction studies, experience reports, reflective “pearls”, and forward-thinking “new idea” papers. We are also pleased to have two Journal First routes for submission to ECOOP, with the ACM TOPLAS and Science of Computer Programming journals.

[2025-08-13 Wed (UTC), no new articles found for cs.PL Programming Languages]
toXiv_bot_toot

On the Linear Programming Model for Dynamic Stochastic Matching and Its Application on Pricing
Junlin Chen, Chiwei Yan, Hai Jiang
https://arxiv.org/abs/2506.09924

On the Linear Programming Model for Dynamic Stochastic Matching and Its Application on Pricing
Important pricing problems in centralized matching markets -- such as carpooling and food delivery platforms -- often exhibit a bi-level structure. At the upper level, the platform sets prices for different types of agents (e.g., riders with various origins and destinations, or delivery orders from diverse restaurants to customer locations). The lower level then matches converted agents to minimize operational costs, such as pooling riders with similar itineraries into the same vehicle or conso…

AdaptiveLLM: A Framework for Selecting Optimal Cost-Efficient LLM for Code-Generation Based on CoT Length
Junhang Cheng, Fang Liu, Chengru Wu, Li Zhang
https://arxiv.org/abs/2506.10525

AdaptiveLLM: A Framework for Selecting Optimal Cost-Efficient LLM for Code-Generation Based on CoT Length
While Large Language Models (LLMs) have significantly advanced code generation efficiency, they face inherent challenges in balancing performance and inference costs across diverse programming tasks. Dynamically selecting the optimal LLM based on task difficulty and resource constraints offers a promising approach to achieve an optimal balance between efficiency and performance. However, existing model selection methods are resource-intensive and often neglect cost efficiency. Moreover, these a…

google_web: Old Google web graph (2002)
A web graph representing a crawl of a portion of the general WWW, from a 2002 Google Programming contest.
This network has 916428 nodes and 5105039 edges.
Tags: Informational, Web graph, Unweighted
https://networks.skewed.de/net/google_web

Here @… gets at something important: programming languages aren’t just a pile of syntax and features. They have context, motivations, idioms, expectations, communities. These things are all interrelated; in fact, they are all •part of the language•. And they are the things a language guide should communicate.
https://ddrake.prose.sh/why_i_hate_programming_language_intro_tutorials

Task-Based Programming for Adaptive Mesh Refinement in Compressible Flow Simulations
Anjiang Wei, Hang Song, Mert Hidayetoglu, Elliott Slaughter, Sanjiva K. Lele, Alex Aiken
https://arxiv.org/abs/2508.05020

Task-Based Programming for Adaptive Mesh Refinement in Compressible Flow Simulations
High-order solvers for compressible flows are vital in scientific applications. Adaptive mesh refinement (AMR) is a key technique for reducing computational cost by concentrating resolution in regions of interest. In this work, we develop an AMR-based numerical solver using Regent, a high-level programming language for the Legion programming model. We address several challenges associated with implementing AMR in Regent. These include dynamic data structures for patch refinement/coarsening, mes…

[2025-07-14 Mon (UTC), 2 new articles found for cs.PL Programming Languages]
toXiv_bot_toot

from my link log —
Idris 2: quantitative type theory in practice.
https://arxiv.org/abs/2104.00480
saved 2025-06-11 https://dotat…

Idris 2: Quantitative Type Theory in Practice
Dependent types allow us to express precisely what a function is intended to do. Recent work on Quantitative Type Theory (QTT) extends dependent type systems with linearity, also allowing precision in expressing when a function can run. This is promising, because it suggests the ability to design and reason about resource usage protocols, such as we might find in distributed and concurrent programming, where the state of a communication channel changes throughout program execution. As yet, howe…

Non-Euclidean dual gradient ascent for entropically regularized linear and semidefinite programming
Yuhang Cai, Michael Lindsey
https://arxiv.org/abs/2506.09711

Non-Euclidean dual gradient ascent for entropically regularized linear and semidefinite programming
We present an optimization framework that exhibits dimension-independent convergence on a broad class of semidefinite programs (SDPs). Our approach first regularizes the primal problem with the von Neumann entropy, then solve the regularized problem using dual gradient ascent with respect to a problem-adapted norm. In particular, we show that the dual gradient norm converges to zero at a rate independent of the ambient dimension and, via rounding arguments, construct primal-feasible solutions i…

[2025-06-13 Fri (UTC), 4 new articles found for cs.PL Programming Languages]
toXiv_bot_toot

Sources: ABC News, NBC News, and CBS News won't preempt regular TV programming for Trump's June 14 military parade, leaving coverage to their streaming outlets (Brian Steinberg/Variety)
https://variety.com/2025/tv/news/trump-…

Trump Military Parade May Not Get Much Coverage on CBS, NBC, ABC
A spectacular military parade slated for June 14 in Washington D.C. my not get traditional broadcast TV coverage on ABC, NBC or CBS

i often see claims that programming languages are not slow, it’s the implementation that’s slow
but that isn’t true, languages can be and often are designed in a way that makes it hard for programmers to make full use of the machine, and hard for an implementation to run programs written in that language at a decent speed
some sketchy notes with examples here:

Stochastic Quadratic Dynamic Programming
Vincent Guigues, Adriana Washington
https://arxiv.org/abs/2506.07314 https://arxiv.org/pdf/2…

Stochastic Quadratic Dynamic Programming
We introduce an algorithm called SQDP (Stochastic Quadratic Dynamic Programming) to solve some multistage stochastic optimization problems having strongly convex recourse functions. The algorithm extends the classical Stochastic Dual Dynamic Programming (SDDP) method replacing affine cuts by quadratic cuts. We provide conditions ensuring strong convexity of the recourse functions and prove the convergence of SQDP. In the special case of a single stage deterministic problem, we call QCSC (Quadra…

Linguine: A Natural-Language Programming Language with Formal Semantics and a Clean Compiler Pipeline
Lifan Hu
https://arxiv.org/abs/2506.08396 https://

Linguine: A Natural-Language Programming Language with Formal Semantics and a Clean Compiler Pipeline
Linguine is a natural-language-inspired programming language that enables users to write programs in a fluent, controlled subset of English while preserving formal semantics. The language introduces anaphoric constructs, such as pronoun variables (e.g., "it", "them"), that are statically resolved through referent-tracking analysis combined with a Hindley-Milner-style type system. Each pronoun is guaranteed to be unambiguous and well-typed at compile time. The Linguine compiler pipeline includ…

CodeContests : High-Quality Test Case Generation for Competitive Programming
Zihan Wang, Siyao Liu, Yang Sun, Hongyan Li, Kai Shen
https://arxiv.org/abs/2506.05817

CodeContests+: High-Quality Test Case Generation for Competitive Programming
Competitive programming, due to its high reasoning difficulty and precise correctness feedback, has become a key task for both training and evaluating the reasoning capabilities of large language models (LLMs). However, while a large amount of public problem data, such as problem statements and solutions, is available, the test cases of these problems are often difficult to obtain. Therefore, test case generation is a necessary task for building large-scale datasets, and the quality of the test…

Tightening the mixed integer linear formulation for the piecewise linear approximation in general dimensions
Quentin Ploussard, Xiang Li, Matija Pavi\v{c}evi\'c
https://arxiv.org/abs/2508.09395

Tightening the mixed integer linear formulation for the piecewise linear approximation in general dimensions
This paper addresses the problem of tightening the mixed-integer linear programming (MILP) formulation for continuous piecewise linear (CPWL) approximations of data sets in arbitrary dimensions. The MILP formulation leverages the difference-of-convex (DC) representation of CPWL functions. We introduce the concept of well-behaved CPWL interpolations and demonstrate that any CPWL interpolation of a data set has a well-behaved version. This result is critical to tighten the MILP problem. We presen…

from my link log —
Taichi: high-performance parallel programming in Python.
https://www.taichi-lang.org/
saved 2025-02-15 https://dot…

From Tool Calling to Symbolic Thinking: LLMs in a Persistent Lisp Metaprogramming Loop
Jordi de la Torre
https://arxiv.org/abs/2506.10021 https://

From Tool Calling to Symbolic Thinking: LLMs in a Persistent Lisp Metaprogramming Loop
We propose a novel architecture for integrating large language models (LLMs) with a persistent, interactive Lisp environment. This setup enables LLMs to define, invoke, and evolve their own tools through programmatic interaction with a live REPL. By embedding Lisp expressions within generation and intercepting them via a middleware layer, the system allows for stateful external memory, reflective programming, and dynamic tool creation. We present a design framework and architectural principles …

Warm-starting outer approximation for parametrized convex MINLP
Erik Tamm, Gabriele Eichfelder, Jan Kronqvist
https://arxiv.org/abs/2507.08595 https://

Warm-starting outer approximation for parametrized convex MINLP
We address the challenge of efficiently solving parametrized sequences of convex Mixed-Integer Nonlinear Programming (MINLP) problems through warm-starting techniques. We focus on an outer approximation (OA) approach, for which we develop the theoretical foundation and present two warm-starting techniques for solving sequences of convex MINLPs. These types of problem sequences arise in several important applications, such as, multiobjective MINLPs using scalarization techniques, sparse linear r…

Managing Power Gaps as a Topic of Pair Programming Skill: A Grounded Theory
Linus Ververs, Lutz Prechelt
https://arxiv.org/abs/2508.00462 https://arxiv.org…

Managing Power Gaps as a Topic of Pair Programming Skill: A Grounded Theory
Context: Pair Programming as a work mode is used (occasionally or frequently) throughout professional software development. Objective: Understand what power-related phenomena occur in pair programming as it is used in industry; give advice to practitioners on how to do better pair programming. Method: Analyze 22 industrial pair programming sessions using Grounded Theory Methodology. Formulate a Grounded Theory on power-related behaviors. Run a survey with 292 participants about that theory. Use…

An Efficient Augmented Lagrangian Method for Dynamic Optimal Transport on Surfaces Based on Second-Order Cone Programming
Liang Chen, Youyicun Lin, Yuxuan Zhou
https://arxiv.org/abs/2506.08988

An Efficient Augmented Lagrangian Method for Dynamic Optimal Transport on Surfaces Based on Second-Order Cone Programming
This paper proposes an efficient numerical optimization approach for solving dynamic optimal transport (DOT) problems on general smooth surfaces, computing both the quadratic Wasserstein distance and the associated transportation path. Building on the convex DOT model of Benamou and Brenier, we first properly reformulate its dual problem, discretized on a triangular mesh for space together with a staggered grid for time, to a linear second-order cone programming. Then the resulting finite-dimen…

from my link log —
Programming languages and dimensions of units of measure.
https://www.cl.cam.ac.uk/techreports/UCAM-CL-TR-391.html
saved 2025-07-30

Solving the Market Split Problem with Lattice Enumeration
Alfred Wassermann
https://arxiv.org/abs/2508.08702 https://arxiv.org/pdf/2508.08702

Solving the Market Split Problem with Lattice Enumeration
The market split problem was proposed by Cornuéjols and Dawande in 1998 as benchmark problem for algorithms solving linear systems with binary variables. The recent (2025) Quantum Optimization Benchmark Library (QOBLIB) contains a set of feasible instances of the market split problem. The market split problem seems to be difficult to solve with the conventional branch-and-bound approach of integer linear programming software which reportedly can handle QOBLIB instances up to $m=7$. In contra…

from my link log —
No value restriction is needed for algebraic effects and handlers.
https://www.cambridge.org/core/journals/journal-of-funct…

Relationship between Maximum Principle and Dynamic Programming Principle for Risk-Sensitive Stochastic Optimal Control Problems with Applications
Huanqing Dong, Jingtao Shi
https://arxiv.org/abs/2507.06504

Relationship between Maximum Principle and Dynamic Programming Principle for Risk-Sensitive Stochastic Optimal Control Problems with Applications
This paper is concerned with the relationship between maximum principle and dynamic programming principle for risk-sensitive stochastic optimal control problems. Under the smooth assumption of the value function, relations among the adjoint processes, the generalized Hamiltonian function, and the value function are given. As an application, a linear-quadratic risk-sensitive portfolio optimization problem in the financial market is discussed.

[2025-08-12 Tue (UTC), 1 new article found for cs.PL Programming Languages]
toXiv_bot_toot

A Newton Augmented Lagrangian Method for Symmetric Cone Programming with Complexity Analysis
Rui-Jin Zhang, Ruoyu Diao, Xin-Wei Liu, Yu-Hong Dai
https://arxiv.org/abs/2506.04802

A Newton Augmented Lagrangian Method for Symmetric Cone Programming with Complexity Analysis
Symmetric cone programming incorporates a broad class of convex optimization problems, including linear programming, second-order cone programming, and semidefinite programming. Although the augmented Lagrangian method (ALM) is well-suited for large-scale scenarios, its subproblems are often not second-order continuously differentiable, preventing direct use of classical Newton methods. To address this issue, we observe that barrier functions from interior-point methods (IPMs) naturally serve a…

Checking Consistency of Event-driven Traces
Parosh Aziz Abdulla, Mohamed Faouzi Atig, R. Govind, Samuel Grahn, Ramanathan S. Thinniyam
https://arxiv.org/abs/2508.07855 https://

Checking Consistency of Event-driven Traces
Event-driven programming is a popular paradigm where the flow of execution is controlled by two features: (1) shared memory and (2) sending and receiving of messages between multiple handler threads (just called handler). Each handler has a mailbox (modelled as a queue) for receiving messages, with the constraint that the handler processes its messages sequentially. Executions of messages by different handlers may be interleaved. A central problem in this setting is checking whether a candidate…

[2025-06-12 Thu (UTC), no new articles found for cs.PL Programming Languages]
toXiv_bot_toot

This https://arxiv.org/abs/2505.13453 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csPL_…

Pel, A Programming Language for Orchestrating AI Agents
The proliferation of Large Language Models (LLMs) has opened new frontiers in computing, yet controlling and orchestrating their capabilities beyond simple text generation remains a challenge. Current methods, such as function/tool calling and direct code generation, suffer from limitations in expressiveness, scalability, cost, security, and the ability to enforce fine-grained control. This paper introduces Pel, a novel programming language specifically designed to bridge this gap. Inspired by …

Convergence of linear programming hierarchies for Gibbs states of spin systems
Hamza Fawzi, Omar Fawzi
https://arxiv.org/abs/2506.06125 https://

Convergence of linear programming hierarchies for Gibbs states of spin systems
We consider the problem of computing expectation values of local functions under the Gibbs distribution of a spin system. In particular, we study two families of linear programming hierarchies for this problem. The first hierarchy imposes local spin flip equalities and has been considered in the bootstrap literature in high energy physics. For this hierarchy, we prove fast convergence under a spatial mixing (decay of correlations) condition. This condition is satisfied for example above the cri…

Replaced article(s) found for cs.PL. https://arxiv.org/list/cs.PL/new
[1/1]:
- Efficient Decrease-And-Conquer Linearizability Monitoring
Lee Zheng Han, Umang Mathur

Relationship between maximum principle and dynamic programming principle for recursive optimal control problem of stochastic evolution equations
Ying Hu, Guomin Liu, Shanjian Tang
https://arxiv.org/abs/2507.06118

Relationship between maximum principle and dynamic programming principle for recursive optimal control problem of stochastic evolution equations
This paper aims to study the relationship between the maximum principle and the dynamic programming principle for recursive optimal control problem of stochastic evolution equations, where the control domain is not necessarily convex and the value function may be nonsmooth. By making use of the notion of conditionally expected operator-valued backward stochastic integral equations, we establish a connection between the first and second-order adjoint processes in MP and the general derivatives o…

Replaced article(s) found for cs.PL. https://arxiv.org/list/cs.PL/new
[1/1]:
- QCP: A Practical Separation Logic-based C Program Verification Tool
Wu, Feng, Lu, Lin, Liu, Wang, Wu, Xie, Yang, Zhong, Zhan, Hu, Cao