Tootfinder

from my link log —
Implementing dependent types in pi-forall.
https://arxiv.org/abs/2207.02129
saved 2025-06-06 https://dotat.at/…

Implementing Dependent Types in pi-forall
These lecture notes describe the design of a minimal dependently-typed language called "pi-forall" and walk through the implementation of its type checker. They are based on lectures given at the Oregon Programming Languages Summer School during July 2023.

Multipass Linear Sketches for Geometric LP-Type Problems
N. Efe \c{C}ekirge, William Gay, David P. Woodruff
https://arxiv.org/abs/2507.11484 https://

Multipass Linear Sketches for Geometric LP-Type Problems
LP-type problems such as the Minimum Enclosing Ball (MEB), Linear Support Vector Machine (SVM), Linear Programming (LP), and Semidefinite Programming (SDP) are fundamental combinatorial optimization problems, with many important applications in machine learning applications such as classification, bioinformatics, and noisy learning. We study LP-type problems in several streaming and distributed big data models, giving $\varepsilon$-approximation linear sketching algorithms with a focus on the h…

For me I use both type of laptops. The windows machine (soon going to #linux) and my #linux laptop (retiring after I convert the windows laptop) I use for serious photo editing, condo newsletters, some work related programming, personal items (like medical).
The Chromebook I use for light…

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.

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…

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…

"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."

Jerry Cain
The late 2000s were an interesting time for online education. The wider availability of faster and more reliable bandwidth led to an explosion of online video. This, in turn, led to the emergence of an ever-expanding number of providers of online learning services, and then to a wave of "Massive Open Online Courses" or MOOCs, many of which were offered by large universities and high schools all over the world. This month's Vidéothèque movie is a full playlist featuring one of the earliest (an…

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…

Combining Type Inference and Automated Unit Test Generation for Python
Lukas Krodinger, Stephan Lukasczyk, Gordon Fraser
https://arxiv.org/abs/2507.01477 h…

Combining Type Inference and Automated Unit Test Generation for Python
Automated unit test generation is an established research field that has so far focused on statically-typed programming languages. The lack of type information in dynamically-typed programming languages, such as Python, inhibits test generators, which heavily rely on information about parameter and return types of functions to select suitable arguments when constructing test cases. Since automated test generators inherently rely on frequent execution of candidate tests, we make use of these fre…

Accelerating MPGP-type Methods Through Preconditioning
Jakub Kru\v{z}\'ik, David Hor\'ak
https://arxiv.org/abs/2507.00617 https://

Accelerating MPGP-type Methods Through Preconditioning
This work investigates the acceleration of MPGP-type algorithms using preconditioning for the solution of quadratic programming problems. The preconditioning needs to be done only on the free set so as not to change the constraints. A variant of preconditioning restricted to the free set is the preconditioning in face. The inner preconditioner in preconditioning in face needs to be recomputed or updated every time the free set changes. Here, we investigate an approximate variant of precondition…

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) ``…

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.

Thread and Memory-Safe Programming with CLASS
Lu\'is Caires (Instituto Superior T\'ecnico)
https://arxiv.org/abs/2505.20848 https://

Thread and Memory-Safe Programming with CLASS
CLASS is a proof-of-concept general purpose linear programming language, flexibly supporting realistic concurrent programming idioms, and featuring an expressive linear type system ensuring that programs (1) never misuse or leak stateful resources or memory, (2) never deadlock, and (3) always terminate. The design of CLASS and the strong static guarantees of its type system originates in its Linear Logic and proposition-as-types foundations. However, instead of focusing on its theoretical found…

Bugs in the Shadows: Static Detection of Faulty Python Refactorings
Jonhnanthan Oliveira, Rohit Gheyi, M\'arcio Ribeiro, Alessandro Garcia
https://arxiv.org/abs/2507.01103

Bugs in the Shadows: Static Detection of Faulty Python Refactorings
Python is a widely adopted programming language, valued for its simplicity and flexibility. However, its dynamic type system poses significant challenges for automated refactoring - an essential practice in software evolution aimed at improving internal code structure without changing external behavior. Understanding how type errors are introduced during refactoring is crucial, as such errors can compromise software reliability and reduce developer productivity. In this work, we propose a stati…

Optimized projection-free algorithms for online learning: construction and worst-case analysis
Julien Weibel (SIERRA), Pierre Gaillard (Thoth), Wouter M. Koolen (CWI), Adrien Taylor (SIERRA)
https://arxiv.org/abs/2506.05855

Optimized projection-free algorithms for online learning: construction and worst-case analysis
This work studies and develop projection-free algorithms for online learning with linear optimization oracles (a.k.a. Frank-Wolfe) for handling the constraint set. More precisely, this work (i) provides an improved (optimized) variant of an online Frank-Wolfe algorithm along with its conceptually simple potential-based proof, and (ii) shows how to leverage semidefinite programming to jointly design and analyze online Frank-Wolfe-type algorithms numerically in a variety of settings-that include …

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

Descriptor: C++ Self-Admitted Technical Debt Dataset (CppSATD)
In software development, technical debt (TD) refers to suboptimal implementation choices made by the developers to meet urgent deadlines and limited resources, posing challenges for future maintenance. Self-Admitted Technical Debt (SATD) is a sub-type of TD, representing specific TD instances ``openly admitted'' by the developers and often expressed through source code comments. Previous research on SATD has focused predominantly on the Java programming language, revealing a significant gap in …

Replaced article(s) found for cs.PL. https://arxiv.org/list/cs.PL/new
[1/1]:
- A Sound Type System for Secure Currency Flow
Luca Aceto, Daniele Gorla, Stian Lybech
…

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…