Tootfinder

When I read commentary about suggestions for where C should go, I often think
back and give thanks that it wasn't developed under the advice of a worldwide
crowd.
-- Dennis Ritchie (1941-2011), creator of the C programming language and of
UNIX

Dr. Boot: Bootstrapping Program Synthesis Language Models to Perform Repairing
Noah van der Vleuten
https://arxiv.org/abs/2507.15889 https://

Dr. Boot: Bootstrapping Program Synthesis Language Models to Perform Repairing
Language models for program synthesis are usually trained and evaluated on programming competition datasets (MBPP, APPS). However, these datasets are limited in size and quality, while these language models are extremely data hungry. Additionally, the language models have a misaligned program synthesis process compared to humans. While humans iteratively develop code with the help of a compiler, most program synthesis models currently produce code in one go. To solve these issues, we introduce …

Steering Conceptual Bias via Transformer Latent-Subspace Activation
Vansh Sharma, Venkat Raman
https://arxiv.org/abs/2506.18887 https://

Steering Conceptual Bias via Transformer Latent-Subspace Activation
This work examines whether activating latent subspaces in language models (LLMs) can steer scientific code generation toward a specific programming language. Five causal LLMs were first evaluated on scientific coding prompts to quantify their baseline bias among four programming languages. A static neuron-attribution method, perturbing the highest activated MLP weight for a C++ or CPP token, proved brittle and exhibited limited generalization across prompt styles and model scales. To address th…

Mapple: A Domain-Specific Language for Mapping Distributed Heterogeneous Parallel Programs
Anjiang Wei, Rohan Yadav, Hang Song, Wonchan Lee, Ke Wang, Alex Aiken
https://arxiv.org/abs/2507.17087

Mapple: A Domain-Specific Language for Mapping Distributed Heterogeneous Parallel Programs
Optimizing parallel programs for distributed heterogeneous systems remains a complex task, often requiring significant code modifications. Task-based programming systems improve modularity by separating performance decisions from core application logic, but their mapping interfaces are often too low-level. In this work, we introduce Mapple, a high-level, declarative programming interface for mapping distributed applications. Mapple provides transformation primitives to resolve dimensionality mi…

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

PVS Studio author Valerii Filatov dives deep into the past twenty-six years of C# history: from the humble beginnings of version 1.0 to present-day C# 13.
"History of C#: versions, .NET, Unity, Blazor, and MAUI"
https://pvs-studio.com/en/blog/posts/csharp/1248/

History of C#: versions, .NET, Unity, Blazor, and MAUI
C# is a popular programming language leveraged to develop apps, web services, and games. Let′s take a peek at the tangled history of its evolution from version to version and explore the different...

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:

Tracing Errors, Constructing Fixes: Repository-Level Memory Error Repair via Typestate-Guided Context Retrieval
Xiao Cheng, Zhihao Guo, Huan Huo, Yulei Sui
https://arxiv.org/abs/2506.18394

Tracing Errors, Constructing Fixes: Repository-Level Memory Error Repair via Typestate-Guided Context Retrieval
Memory-related errors in C programming continue to pose significant challenges in software development, primarily due to the complexities of manual memory management inherent in the language. These errors frequently serve as vectors for severe vulnerabilities, while their repair requires extensive knowledge of program logic and C's memory model. Automated Program Repair (APR) has emerged as a critical research area to address these challenges. Traditional APR approaches rely on expert-designed …

The connection between the language in which we think/program and the problems
and solutions we can imagine is very close. For this reason restricting
language features with the intent of eliminating programmer errors is at best
dangerous.
-- Bjarne Stroustrup in "The C Programming Language"

We've been studying the cognitive science of *diagrams*, and have recently put out a new (very) lightweight programming language and tool for diagramming models in formal methods. Check it out here!
https://blog.brownplt.org/2025/06/09/copeanddrag.html

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

An extension of C++ with memory-centric specifications for HPC to reduce memory footprints and streamline MPI development
The C++ programming language and its cousins lean towards a memory-inefficient storage of structs: The compiler inserts helper bits such that individual instance variables fit to byte or cache boundaries, while it is not able to exploit knowledge about the range of integers, enums or bitsets. Furthermore, the language provides neither support for data exchange via MPI nor for arbitrary floating-point precisions. We propose C++ attributes through which developers can guide the compiler what memo…

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

I maintain a heterogeneous MSP environment for backup which consists of a collection of sh scripts (they mostly run on FreeBSD) with (c) notes dating back to 2004, with 5 authors, 4 of whom are no longer my cow-orkers. As the unfortunate 5th, I am still doing tweaks to catch edge & corner cases >20y after the 1st author had the idea that rsync, shell, mt, & standard POSIX tools could be assembled into a decent free backup world.
Use Python. Or Go. Or even Perl.

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…

"What Stroustrup wanted was apparently what a lot of people wanted: a language that provided OOP features, such as those offered by Smalltalk, but compiled into binaries that would execute as fast as an executable written in C.
The solution Stroustrup adopted was not to adopt the Smalltalk model, but instead to take inspiration from fellow Scandinavians and to bolt ideas borrowed from Simula into C."

Analyzing C/C Library Migrations at the Package-level: Prevalence, Domains, Targets and Rationals across Seven Package Management Tools
Haiqiao Gu, Yiliang Zhao, Kai Gao, Minghui Zhou
https://arxiv.org/abs/2507.03263

Analyzing C/C++ Library Migrations at the Package-level: Prevalence, Domains, Targets and Rationals across Seven Package Management Tools
Library migration happens when a library can not meet the project's requirements and is non-trivial to accomplish. To mitigate the problem, substantial efforts have been devoted to understanding its characteristics and recommending alternative libraries, especially for programming language (PL) ecosystems with a central package hosting platform, such as Python (PyPI). However, to the best of our knowledge, understanding of C/C++ library migrations is still lacking, possibly due to challenges re…

Rust vs. C for Python Libraries: Evaluating Rust-Compatible Bindings Toolchains
Isabella Basso do Amaral (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)
https://

Rust vs. C for Python Libraries: Evaluating Rust-Compatible Bindings Toolchains
The Python programming language is best known for its syntax and scientific libraries, but it is also notorious for its slow interpreter. Optimizing critical sections in Python entails special knowledge of the binary interactions between programming languages, and can be cumbersome to interface manually, with implementers often resorting to convoluted third-party libraries. This comparative study evaluates the performance and ease of use of the PyO3 Python bindings toolchain for Rust against ct…

Large Language Models for Multilingual Vulnerability Detection: How Far Are We?
Honglin Shu, Michael Fu, Junji Yu, Dong Wang, Chakkrit Tantithamthavorn, Junjie Chen, Yasutaka Kamei
https://arxiv.org/abs/2506.07503

Large Language Models for Multilingual Vulnerability Detection: How Far Are We?
Various deep learning-based approaches utilizing pre-trained language models (PLMs) have been proposed for automated vulnerability detection. With recent advancements in large language models (LLMs), several studies have begun exploring their application to vulnerability detection tasks. However, existing studies primarily focus on specific programming languages (e.g., C/C++) and function-level detection, leaving the strengths and weaknesses of PLMs and LLMs in multilingual and multi-granularit…

This https://arxiv.org/abs/2502.16517 has been replaced.
link: https://scholar.google.com/scholar?q=a

Annotation-guided AoS-to-SoA conversions and GPU offloading with data views in C++
The C++ programming language provides classes and structs as fundamental modeling entities. Consequently, C++ code tends to favour array-of-structs (AoS) for encoding data sequences, even though structure-of-arrays (SoA) yields better performance for some calculations. We propose a C++ language extension based on attributes that allows developers to guide the compiler in selecting memory arrangements, i.e.~to select the optimal choice between AoS and SoA dynamically depending on both the execut…

Performance Portable Gradient Computations Using Source Transformation
Kim Liegeois, Brian Kelley, Eric Phipps, Sivasankaran Rajamanickam, Vassil Vassilev
https://arxiv.org/abs/2507.13204

Performance Portable Gradient Computations Using Source Transformation
Derivative computation is a key component of optimization, sensitivity analysis, uncertainty quantification, and nonlinear solvers. Automatic differentiation (AD) is a powerful technique for evaluating such derivatives, and in recent years, has been integrated into programming environments such as Jax, PyTorch, and TensorFlow to support derivative computations needed for training of machine learning models, resulting in widespread use of these technologies. The C++ language has become the de fa…

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

A first look at ROS~2 applications written in asynchronous Rust
The increasing popularity of the Rust programming language in building robotic applications using the Robot Operating System (ROS~2) raises questions about its real-time execution capabilities, particularly when employing asynchronous programming. Existing real-time scheduling and response-time analysis techniques for ROS~2 focus on applications written in C++ and do not address the unique execution models and challenges presented by Rust's asynchronous programming paradigm. In this paper, we a…

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 …