Tootfinder

from my link log —
The Epic Verse calculus: a core calculus for functional logic programming.
https://simon.peytonjones.org/verse-calculus/
saved 2025-06-12

A Functional Data Model and Query Language is All You Need
Jens Dittrich
https://arxiv.org/abs/2507.20671 https://arxiv.org/pdf/2507.20671

A Functional Data Model and Query Language is All You Need
We propose the vision of a functional data model (FDM) and an associated functional query language (FQL). Our proposal has far-reaching consequences: we show a path to come up with a modern QL that solves (almost if not) all problems of SQL (NULL-values, impedance mismatch, SQL injection, missing querying capabilities for updates, etc.). FDM and FQL are much more expressive than the relational model and SQL. In addition, in contrast to SQL, FQL integrates smoothly into existing programming lang…

The Call for the 2026 International Symposium on Functional and Logic Programming (FLOPS) is open - the symposium itself will be May 26-28 in Akita, Japan. Deadline for the CfP is Dec 8 (abstracts) / Dec 16 (submissions).
Send us your best on the best of both worlds! (Also check out the new logo.)
https://function…

AaŠaargh.
https://functional.cafe/@loke/114724782345547751

The deadline for FProper (SIGPLAN Workshop on Functional Programming for Productivity and Performance) full-paper abstracts has been extended to June 14th. (Which is also when the papers themselves are due.)
Send us your paper!
https://conf.researchr.org/home/icfp-s

Functional programming isn't just for Haskell developers. It's for #PHP developers, too. "Thinking Functionally in PHP" is available from LeanPub.
https://leanpub.com/thinking-functiona

On systematic construction of correct logic programs
W{\l}odzimierz Drabent
https://arxiv.org/abs/2508.16782 https://arxiv.org/pdf/2508.16782

On systematic construction of correct logic programs
Partial correctness of imperative or functional programming divides in logic programming into two notions. Correctness means that all answers of the program are compatible with the specification. Completeness means that the program produces all the answers required by the specifications. We also consider semi-completeness -- completeness for those queries for which the program does not diverge. This paper presents an approach to systematically construct provably correct and semi-complete logic …

From Generation to Adaptation: Comparing AI-Assisted Strategies in High School Programming Education
Tong Hu, Songzan Wang
https://arxiv.org/abs/2506.15955

From Generation to Adaptation: Comparing AI-Assisted Strategies in High School Programming Education
This exploratory case study investigated two contrasting pedagogical approaches for LCA-assisted programming with five novice high school students preparing for a WeChat Mini Program competition. In Phase 1, students used LCAs to generate code from abstract specifications (From-Scratch approach), achieving only 20% MVP completion. In Phase 2, students adapted existing Minimal Functional Units (MFUs), small, functional code examples, using LCAs, achieving 100% MVP completion. Analysis revealed t…

exa-AMD: A Scalable Workflow for Accelerating AI-Assisted Materials Discovery and Design
Maxim Moraru, Weiyi Xia, Zhuo Ye, Feng Zhang, Yongxin Yao, Ying Wai Li, Cai-Zhuang Wang
https://arxiv.org/abs/2506.21449

exa-AMD: A Scalable Workflow for Accelerating AI-Assisted Materials Discovery and Design
exa-AMD is a Python-based application designed to accelerate the discovery and design of functional materials by integrating AI/ML tools, materials databases, and quantum mechanical calculations into scalable, high-performance workflows. The execution model of exa-AMD relies on Parsl, a task-parallel programming library that enables a flexible execution of tasks on any computing resource from laptops to supercomputers. By using Parsl, exa-AMD is able to decouple the workflow logic from executio…

Coupling all-electron full-potential density functional theory with grid-based continuum embeddings
Jakob Filser, Edan Bainglass, Karsten Reuter, Oliviero Andreussi
https://arxiv.org/abs/2507.17672

Coupling all-electron full-potential density functional theory with grid-based continuum embeddings
Recent advances in continuum embedding models have enabled the incorporation of solvent and electrolyte effects into density functional theory (DFT) simulations of material surfaces, significantly benefiting electrochemistry, catalysis, and other applications. To extend the simulation of diverse systems and properties, the implementation of continuum embedding models into the Environ library adopts a modular programming paradigm, offering a flexible interface for communication with various DFT …

COMPASS: A Multi-Dimensional Benchmark for Evaluating Code Generation in Large Language Models
James Meaden, Micha{\l} Jarosz, Piotr Jod{\l}owski, Grigori Melnik
https://arxiv.org/abs/2508.13757

COMPASS: A Multi-Dimensional Benchmark for Evaluating Code Generation in Large Language Models
Current code generation benchmarks focus primarily on functional correctness while overlooking two critical aspects of real-world programming: algorithmic efficiency and code quality. We introduce COMPASS (COdility's Multi-dimensional Programming ASSessment), a comprehensive evaluation framework that assesses code generation across three dimensions: correctness, efficiency, and quality. COMPASS consists of 50 competitive programming problems from real Codility competitions, providing authentic …

I have time to experiment with different programming languages and while I'm a big fan of functional or functional style programming, my recent obsession is with #Go
It is a tremendously simple language, without surprises or elaborate mechanisms, procedural and totally boring.. and I love it.
Most satisfying thing is life reload with air and it's usually already compiled and…

Proceedings 14th International Workshop on Trends in Functional Programming in Education
Rose Bohrer (AIST, Tokyo, JP)
https://arxiv.org/abs/2508.02305 https://

Proceedings 14th International Workshop on Trends in Functional Programming in Education
The goal of TFPIE is to gather researchers, teachers and professionals that use, or are interested in the use of, functional programming in education. TFPIE aims to be a venue where novel ideas, classroom-tested ideas and work-in-progress on the use of functional programming in education are discussed. The one-day workshop will foster a spirit of open discussion by having a review process for publication after the workshop.

"Professor Cain uses various programming languages to explain these concepts: he starts with C (roughly from the second lecture to the 8th), then Assembly (lectures 9 to 11), C (lectures 12 to 18), Scheme (lectures 19 to 23), and Python (from 24 to 26). The last lecture (27) dives into some other functional programming languages like ML, Miranda, and even Haskell, as well as some advanced type design concepts, to round up your general programming knowledge."

Approximation of risk-averse optimal feedback control
Philipp A. Guth, Karl Kunisch
https://arxiv.org/abs/2508.15618 https://arxiv.org/pdf/2508.15618

Approximation of risk-averse optimal feedback control
The challenge of constructing feedback control laws for risk-averse optimal control of partial differential equations (PDEs) with random coefficients is addressed. The control objective composes a tracking-type cost with the nonlinear entropic risk measure. A sequential quadratic programming scheme is derived that iteratively solves linear quadratic subproblems obtained through second-order Taylor expansions of the objective functional, with each subproblem re-centered at the previous iterate. …

A Diagrammatic Calculus for a Functional Model of Natural Language Semantics
Matthieu Pierre Boyer
https://arxiv.org/abs/2507.00782 https://

A Diagrammatic Calculus for a Functional Model of Natural Language Semantics
In this paper, we study a functional programming approach to natural language semantics, allowing us to increase the expressivity of a more traditional denotation style. We will formalize a category based type and effect system, and construct a diagrammatic calculus to model parsing and handling of effects, and use it to efficiently compute the denotations for sentences.

At 79, Dr. Jeffrey Bland hikes mountain ranges, surfs in the ocean, and sailed over 40,000 miles on his boat.
Dr. Jonny Bowden plays tennis two hours a day, hikes five days a week and conquered the Fight for Air Climb.
In this fireside chat, these two respected pioneers share science-backed secrets for living younger, longer.
As thriving examples of what’s possible through smart nutrition, functional medicine, and lifestyle design.
This conversation will explore h…

PanelPicker | SXSW Conference & Festivals
PanelPicker® is the official SXSW user-generated session proposal platform. Enter ideas and vote to help shape Conference programming for SXSW and SXSW EDU.

Teaching Introductory Functional Programming Using Haskelite
Pedro Vasconcelos (University of Porto)
https://arxiv.org/abs/2508.03640 https://arxiv.org/pdf…

Teaching Introductory Functional Programming Using Haskelite
Learning functional programming requires learning a substitution-based computational model. While substitution should be a familiar concept from high-school algebra, students often have difficulty applying it to new settings, such as recursive definitions, algebraic data types and higher-order functions. Step-by-step interpreters have been shown to help beginners by clarifying misconceptions and improving understanding. This paper reports on the experience of using a step-by-step tracing inte…

Functional vs. Object-Oriented: Comparing How Programming Paradigms Affect the Architectural Characteristics of Systems
Briza Mel Dias de Sousa (University of S\~ao Paulo), Renato Cordeiro Ferreira (University of S\~ao Paulo, Jheronimus Academy of Data Science, Technical University of Eindhoven, Tilburg University), Alfredo Goldman (University of S\~ao Paulo)
h…

Functional vs. Object-Oriented: Comparing How Programming Paradigms Affect the Architectural Characteristics of Systems
After decades of dominance by object-oriented programming (OOP), functional programming (FP) is gaining increasing attention in the software industry. This study compares the impact of OOP and FP on the architectural characteristics of software systems. For that, it examines the design and implementation of a Digital Wallet system, developed in Kotlin (representing OOP) and Scala (representing FP). The comparison is made through both qualitative and quantitative analyses to explore how each par…

ChatModel: Automating Reference Model Design and Verification with LLMs
Jianmin Ye, Tianyang Liu, Qi Tian, Shengchu Su, Zhe Jiang, Xi Wang
https://arxiv.org/abs/2506.15066

ChatModel: Automating Reference Model Design and Verification with LLMs
As the complexity of integrated circuit designs continues to escalate, the functional verification becomes increasingly challenging. Reference models, critical for accelerating the verification process, are themselves becoming more intricate and time-consuming to develop. Despite the promise shown by large language models (LLMs) in code programming, effectively generating complex reference models remains a significant hurdle. To address these challenges, we introduce ChatModel, the first LLM-ai…

from my link log —
Static interpretation of higher-order modules in Futhark: functional GPU programming in the large.
https://dl.acm.org/doi/10.1145/3236792
saved 2025-05-09

To Zip Through the Cost Analysis of Probabilistic Programs
Matthias Hetzenberger, Georg Moser, Florian Zuleger
https://arxiv.org/abs/2508.14249 https://arx…

To Zip Through the Cost Analysis of Probabilistic Programs
Probabilistic programming and the formal analysis of probabilistic algorithms are active areas of research, driven by the widespread use of randomness to improve performance. While functional correctness has seen substantial progress, automated reasoning about expected runtime remains comparatively limited. In this work, we address this challenge by introducing a refinement-typed probability monad in Liquid Haskell. Our monad enables automated reasoning about expected values and costs by encodi…

This was so much fun - Alex has lots to say about art, programming, creativity, learning, and Haskell, of course!
https://functional.cafe/@HaskellInterlude/114816498470214539

I've been so quiet lately because I've been busy building my 1st full stack app with Clojure(script). It's been a lot of fun and I've learn a ton, not only about clojure but about functional and data oriented programming too.
Expect updates.
#clojure #clojurescript

Rookie Mistakes: Measuring Software Quality in Student Projects to Guide Educational Enhancement
Marco De Luca, Sergio Di Martino, Sergio Di Meglio, Anna Rita Fasolino, Luigi Libero Lucio Starace, Porfirio Tramontana
https://arxiv.org/abs/2507.12488

Rookie Mistakes: Measuring Software Quality in Student Projects to Guide Educational Enhancement
When teaching Programming and Software Engineering in Bachelor's Degree programs, the emphasis on creating functional software projects often overshadows the focus on software quality, a trend that aligns with ACM curricula recommendations. Software Engineering courses are typically introduced later in the curriculum, and can generally allocate only limited time to quality-related topics, leaving educators with the challenge of deciding which quality aspects to prioritize. In this decision, the…

Mutual-Supervised Learning for Sequential-to-Parallel Code Translation
Changxin Ke, Rui Zhang, Shuo Wang, Li Ding, Guangli Li, Yuanbo Wen, Shuoming Zhang, Ruiyuan Xu, Jin Qin, Jiaming Guo, Chenxi Wang, Ling Li, Qi Guo, Yunji Chen
https://arxiv.org/abs/2506.11153

Mutual-Supervised Learning for Sequential-to-Parallel Code Translation
The rise of GPU-based high-performance computing (HPC) has driven the widespread adoption of parallel programming models such as CUDA. Yet, the inherent complexity of parallel programming creates a demand for the automated sequential-to-parallel approaches. However, data scarcity poses a significant challenge for machine learning-based sequential-to-parallel code translation. Although recent back-translation methods show promise, they still fail to ensure functional equivalence in the translate…

from my link log —
Implement your programming language twice.
https://futhark-lang.org/blog/2025-05-07-implement-your-language-twice.html
saved 2025-05-08

Have Object-Oriented Languages Missed a Trick with Class Function and its Subclasses?
Lloyd Allison
https://arxiv.org/abs/2507.00488 https://

Have Object-Oriented Languages Missed a Trick with Class Function and its Subclasses?
Compared to functions in mathematics, functions in programming languages seem to be under classified. Functional programming languages based on the lambda calculus famously treat functions as first-class values. Object-oriented languages have adopted ``lambdas'', notably for call-back routines in event-based programming. Typically a programming language has functions, a function has a type, and some functions act on other functions and/or return functions but there is generally a lack of (i) ``…

Numerical analysis of the convex relaxation of the barrier parameter functional of self-concordant barriers
Vitali Pirau, Roland Hildebrand
https://arxiv.org/abs/2507.01812

Numerical analysis of the convex relaxation of the barrier parameter functional of self-concordant barriers
Self-concordant barriers are essential for interior-point algorithms in conic programming. To speed up the convergence it is of interest to find a barrier with the lowest possible parameter for a given cone. The barrier parameter is a non-convex function on the set of self-concordant barriers on a given cone, and finding an optimal barrier amounts to solving a non-convex infinite-dimensional optimization problem. In this work we study the degradation of the optimal value of the problem when the…

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

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 …

from my link log —
Tracking source locations for profiling GPU programs in Futhark.
https://futhark-lang.org/blog/2025-07-29-tracking-source-locations.html
saved 2025-08-01

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

Verifying Device Drivers with Pancake
Device driver bugs are the leading cause of OS compromises, and their formal verification is therefore highly desirable. To the best of our knowledge, no realistic and performant driver has been verified for a non-trivial device. We propose Pancake, an imperative language for systems programming that features a well-defined and verification-friendly semantics. Leveraging the verified compiler backend of the CakeML functional language, we develop a compiler for Pancake that guarantees that the b…

A Hierarchical and Evolvable Benchmark for Fine-Grained Code Instruction Following with Multi-Turn Feedback
Guoliang Duan, Mingwei Liu, Yanlin Wang, Chong Wang, Xin Peng, Zibin Zheng
https://arxiv.org/abs/2507.00699

A Hierarchical and Evolvable Benchmark for Fine-Grained Code Instruction Following with Multi-Turn Feedback
Large language models (LLMs) have advanced significantly in code generation, yet their ability to follow complex programming instructions with layered and diverse constraints remains underexplored. Existing benchmarks often prioritize functional correctness, overlooking the nuanced requirements found in real-world development. We introduce MultiCodeIF, a comprehensive benchmark designed to evaluate instruction-following in code generation across multiple dimensions: constraint type, hierarchica…