# Programming Languages / Compilers

Programming languages and compilers is a computer science research area focused on the design, implementation, analysis, optimization, and formal properties of computer programs.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Decoding base64 email attachments: a speed ranking of programming languages

DevFeed: [Decoding base64 email attachments: a speed ranking of programming languages](<https://devfeed.tech/articles/decoding-base64-email-attachments-a-speed-ranking-of-programming-languages-146498.md>)

Original publisher: [Read original article](<https://lemire.me/blog/2026/11/20/decoding-base64-email-attachments/>)

Author: Daniel Lemire

Published: 2026-11-20T12:37:52Z

Content type: news

Language: en

Sources: [Daniel Lemire](<https://devfeed.tech/sources/daniel-lemire.md>)

Topics: [Decoding](<https://devfeed.tech/topics/decoding.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>), [email](<https://devfeed.tech/topics/email.md>)

Tags: [base64](<https://devfeed.tech/tags/base64.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [decoding](<https://devfeed.tech/tags/decoding.md>), [email](<https://devfeed.tech/tags/email.md>), [languages](<https://devfeed.tech/tags/languages.md>), [mime](<https://devfeed.tech/tags/mime.md>), [php](<https://devfeed.tech/tags/php.md>), [programming](<https://devfeed.tech/tags/programming.md>), [programming-languages](<https://devfeed.tech/tags/programming-languages.md>), [pull-request](<https://devfeed.tech/tags/pull-request.md>), [ranking](<https://devfeed.tech/tags/ranking.md>), [speed](<https://devfeed.tech/tags/speed.md>)

### AI overview

A benchmark of MIME-style base64 decoding found a thirtyfold gap between the fastest and slowest tested systems. It used one megabyte of random data encoded in 76-character lines with CRLF, verified decoded bytes, and measured median throughput across repeated runs on one pinned core of an Intel Xeon Gold 6548N. The excerpt says the top six systems use simdutf, which removes line endings in its vector loop and compacts affected blocks into a small buffer instead of falling back to a slow path. PHP's current release measured 0.61 GB/s on this input despite exceeding 20 GB/s on uninterrupted base64; a proposed simdutf port reportedly made MIME decoding 28 times faster, moving PHP to second place. The excerpt does not provide the other systems' individual results.

### Source excerpt

Email attachments are base64. So are cryptographic PEM certificates. In both cases the text is broken into lines, 76 characters for email and 64 for PEM. Skipping line endings sounds trivial. Yet many fast decoders only work on uninterrupted base64. As soon as they meet a line break, they fall back to a slow path. ... Continue reading Decoding base64 email attachments: a speed ranking of programming languages

## Community-Focused Academic Brings AI Tools to Colorado Farmers

DevFeed: [Community-Focused Academic Brings AI Tools to Colorado Farmers](<https://devfeed.tech/articles/community-focused-academic-brings-ai-tools-to-colorado-farmers-145257.md>)

Original publisher: [Read original article](<https://spectrum.ieee.org/ai-tools-for-rural-communities>)

Author: Willie D. Jones

Published: 2026-11-19T19:00:02Z

Content type: article

Language: en

Sources: [IEEE Spectrum](<https://devfeed.tech/sources/ieee-spectrum.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [AI Chat](<https://devfeed.tech/topics/ai-chat.md>), [AI Research](<https://devfeed.tech/topics/ai-research.md>), [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>), [Learning](<https://devfeed.tech/topics/learning.md>), [User interface design](<https://devfeed.tech/topics/ui-design.md>)

Tags: [agritourism](<https://devfeed.tech/tags/agritourism.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [ai-chatbot](<https://devfeed.tech/tags/ai-chatbot.md>), [ai-powered](<https://devfeed.tech/tags/ai-powered.md>), [ai-tools](<https://devfeed.tech/tags/ai-tools.md>), [careers](<https://devfeed.tech/tags/careers.md>), [community](<https://devfeed.tech/tags/community.md>), [cooperative-extension](<https://devfeed.tech/tags/cooperative-extension.md>), [extension](<https://devfeed.tech/tags/extension.md>), [farming](<https://devfeed.tech/tags/farming.md>), [ieee-member-news](<https://devfeed.tech/tags/ieee-member-news.md>), [outreach](<https://devfeed.tech/tags/outreach.md>), [practical](<https://devfeed.tech/tags/practical.md>), [research](<https://devfeed.tech/tags/research.md>), [the-institute](<https://devfeed.tech/tags/the-institute.md>), [training](<https://devfeed.tech/tags/training.md>), [type-ti](<https://devfeed.tech/tags/type-ti.md>)

### AI overview

Xue "Alice" Dong brings practical AI support to farmers and ranchers in eastern Colorado through workshops and tools built for their needs. Her browser-based AI-Powered Agritourism Chatbot uses retrieval-augmented generation over curated Extension publications, grounding answers in trusted documents; it requires no app and can run on computers, tablets, or other web-connected devices. Dong also contributed a Project Pythia assistant that translates airport weather reports into plain-language guidance and flags missing data rather than guessing. Her workshops cover ChatGPT, Claude, and Gemini; follow-up surveys found 90 percent of participants had tried at least one new AI task in their business. The article describes these survey findings as preliminary, with full chatbot results still being prepared for publication.

### Source excerpt

Many farmers and ranchers in eastern Colorado are curious about artificial intelligence, but they don't have a local tech-savvy person to show them how to use it. Xue "Alice" Dong has made that her job. Dong, an IEEE senior member, is an extension regional specialist with the Colorado State University Extension, CSU's outreach arm. She works in Logan County and serves a 10-county farming area in Colorado's northeast corner. Her job is to turn university research into practical help for the people who live there. Xue "Alice" Dong Employer Colorado State University Extension in Logan County Title Extension regional specialist Member grade Senior member Alma maters Inner Mongolia Normal University, in Hohhot; Beijing Normal University; State University of New York College of Environmental Science and Forestry, in Syracuse; Colorado State University Global She built the AI-Powered Agritourism Chatbot (AgriTourismAI.com), which helps farmers and ranchers launch and run "agritourism" businesses. Agritourism is when farmers open their property to visitors for fun, education, or shopping events. Familiar examples include pick-your-own fruit orchards, lessons on how to grow vegetables, and sales of handmade products. Dong also teaches workshops where she shows farmers and ranchers how they can use AI tools to help grow and manage their business. She says she sees herself as a link between the university and the countryside. "We [extension specialists] act as a bridge," she says. "We bridge our campus to the rural communities we serve." Many farmers and ranchers are older, and they typically have no technical training. Often their children and grandchildren have left the farm to work in a city or otherwise aren't around to teach them about new tools. Without help, the benefits of AI could pass the farmers by. Dong's workshops give them a way in. Dong was named a finalist in the 2026 GenAI for Good Challenge for her AgriPivot AI Agent. The challenge was organized by IEEE Human

## College Board Delivers Another AI Ultimatum: No AI, No AP CS Principles Course

DevFeed: [College Board Delivers Another AI Ultimatum: No AI, No AP CS Principles Course](<https://devfeed.tech/articles/college-board-delivers-another-ai-ultimatum-no-ai-no-ap-cs-principles-course-142916.md>)

Original publisher: [Read original article](<https://news.slashdot.org/story/26/11/19/0628241/college-board-delivers-another-ai-ultimatum-no-ai-no-ap-cs-principles-course>)

Author: BeauHD

Published: 2026-11-19T11:00:00Z

Content type: news

Language: en

Sources: [Slashdot](<https://devfeed.tech/sources/slashdot.md>)

Topics: [Learning](<https://devfeed.tech/topics/learning.md>), [AI Engineering](<https://devfeed.tech/topics/ai-engineering.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>), [Blockly](<https://devfeed.tech/topics/blockly.md>)

Tags: [2027](<https://devfeed.tech/tags/2027.md>), [about](<https://devfeed.tech/tags/about.md>), [after](<https://devfeed.tech/tags/after.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-application](<https://devfeed.tech/tags/ai-application.md>), [ai-powered](<https://devfeed.tech/tags/ai-powered.md>), [ai-tool](<https://devfeed.tech/tags/ai-tool.md>), [also](<https://devfeed.tech/tags/also.md>), [app](<https://devfeed.tech/tags/app.md>), [application](<https://devfeed.tech/tags/application.md>), [ban](<https://devfeed.tech/tags/ban.md>), [based](<https://devfeed.tech/tags/based.md>), [block](<https://devfeed.tech/tags/block.md>), [blockly](<https://devfeed.tech/tags/blockly.md>), [board](<https://devfeed.tech/tags/board.md>), [build](<https://devfeed.tech/tags/build.md>), [build-with-ai](<https://devfeed.tech/tags/build-with-ai.md>), [college](<https://devfeed.tech/tags/college.md>), [course](<https://devfeed.tech/tags/course.md>), [education](<https://devfeed.tech/tags/education.md>), [principles](<https://devfeed.tech/tags/principles.md>)

### AI overview

The College Board plans to redesign AP Computer Science Principles starting in fall 2027 around responsible AI use. Students will learn to use AI to design, debug, and evaluate code, assess when it is wrong, and build an AI application for an AI Create Project; the exam will include free-response questions about that project. Schools must provide each student with access to a district-approved AI tool that accepts written instructions and returns a response. Starting in 2028-29, project submissions must use one of a limited number of text-based languages. Teachers may continue using block-based tools for instruction, but students must learn an approved text-based language before submitting. The excerpt does not specify the approved tools or languages.

### Source excerpt

Longtime Slashdot reader theodp writes: Just days after news broke of Google's no AI, no Search ultimatum -- prompting school districts to weigh breaking up with Google Search (source paywalled; alternative source) -- the College Board quietly delivered another AI ultimatum to the nation's AP Computer Science Principles teachers, suggesting that their days of teaching AP CSP might be over unless their school districts put an end to their anti-AI ways. "Effective in fall 2027," The College Board explained, "AP Computer Science Principles has been reimagined as the course for teaching students how to work with AI responsibly, safely, and confidently. AI is integral to the world of computer science. Software engineering remains one of the largest professional job categories, and employers now expect software engineers to be fluent in AI. What sets candidates apart is a deeper understanding of AI for designing, debugging, and evaluating code, and the ability to determine when AI is wrong. The redesigned course develops these skills, empowering students to build with AI, not just learn about it. [...] Students also complete an AI Create Project, in which they build an AI application. The AP Exam includes free-response questions about the project, so students who earn a qualifying score for college credit have demonstrated their ability to design, build, and understand an AI-powered application. [...] Students need access to a district-approved AI tool that accepts a student's own written instructions and returns a response. Schools will need to make sure every student has access to one." The College Board also announced a planned ban on the use of block-based programming languages like Snap!, Scratch, Blockly, and MIT App Inventor for students' "AI Create Project" (which replaces the current "Create Performance Task" that counts for 30% of a student's AP exam score): "Beginning with the 2028-29 school year, students will submit their AI Create Project in one of a limited

## MetaphIR: Corpus-Scale Applicability Analysis for LLVM Peephole Optimizations

DevFeed: [MetaphIR: Corpus-Scale Applicability Analysis for LLVM Peephole Optimizations](<https://devfeed.tech/articles/metaphir-corpus-scale-applicability-analysis-for-llvm-peephole-optimizations-142187.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.23555>)

Author: Hongxu Xu, Xintong Zhou, Chunhao Liao, Chengnian Sun

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>)

Tags: [analysis](<https://devfeed.tech/tags/analysis.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [domain-specific-language](<https://devfeed.tech/tags/domain-specific-language.md>), [filter](<https://devfeed.tech/tags/filter.md>), [interactive](<https://devfeed.tech/tags/interactive.md>), [ir](<https://devfeed.tech/tags/ir.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [median](<https://devfeed.tech/tags/median.md>), [optimizations](<https://devfeed.tech/tags/optimizations.md>), [pattern](<https://devfeed.tech/tags/pattern.md>), [precision](<https://devfeed.tech/tags/precision.md>), [queries](<https://devfeed.tech/tags/queries.md>), [rewrite](<https://devfeed.tech/tags/rewrite.md>), [scale](<https://devfeed.tech/tags/scale.md>), [search-engine](<https://devfeed.tech/tags/search-engine.md>)

### AI overview

MetaphIR estimates how often LLVM peephole rewrites apply across large IR corpora before developers implement them. Unlike structural search, which overcounts by ignoring rewrite preconditions, MetaphIR expresses patterns with holes and Boolean constraints, then uses indexed per-function summaries and abstract interpretation to filter impossible matches. This avoids the engineering cost and median 47-minute runtime of recompiling the corpus. Across 20 recent InstCombine rewrites, it reported exact applicability sets in isolation (100% precision and recall); queries took a median 1.27 seconds, 22x faster than a full corpus scan.

### Source excerpt

arXiv:2611.23555v1 Announce Type: cross Abstract: Peephole optimizations replace short source instruction sequences with more efficient equivalents, typically guarded by preconditions such as requiring a constant operand to be a power of two. Since every new rewrite adds maintenance burden and compile-time cost, compiler developers need to know how often real-world programs both match the source pattern and satisfy its preconditions before committing to an implementation. Existing workflows fall short: structural search over an intermediate representation (IR) corpus of 4.8 million functions ignores preconditions and therefore overcounts, whereas implementing the rewrite and recompiling the corpus yields exact counts only after paying the engineering cost, with each run of the corpus's on-demand recompilation pipeline taking a median of 47 minutes. This delay is especially limiting when generalizing a rewrite, as developers often iterate over multiple variants to trade off coverage against complexity. We introduce MetaphIR, a system pairing a domain-specific language for expressing LLVM peephole optimizations with an indexed search engine over large IR corpora. Using a syntax modeled on LLVM's C++ matchers, MetaphIR patterns augment LLVM IR with holes and Boolean preconditions over matched values. To answer queries at interactive speed, MetaphIR builds compact per-function summaries ahead of time and uses abstract interpretation over those summaries to soundly filter out functions that cannot satisfy a query's constraints. Across twenty recent peephole optimizations from LLVM's InstCombine pass, MetaphIR recovers the exact set of functions where each rewrite applies in isolation, achieving 100% precision and recall. Queries complete in a median of 1.27 seconds---a 22x speedup over a full corpus scan---enabling developers to quickly gauge an optimization's reach and generality prior to implementation.

## Coordinating integration of multidisciplinary design analysis and optimisation codes with design structure matrices

DevFeed: [Coordinating integration of multidisciplinary design analysis and optimisation codes with design structure matrices](<https://devfeed.tech/articles/coordinating-integration-of-multidisciplinary-design-analysis-and-optimisation-codes-with-design-structure-matrices-139609.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.22522>)

Author: W. J. Rutten, L. F. P. Etman, F. Warmer

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Operations research and optimization](<https://devfeed.tech/topics/operations-research-and-optimization.md>), [software-architecture](<https://devfeed.tech/topics/software-architecture.md>), [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>)

Tags: [aerospace](<https://devfeed.tech/tags/aerospace.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [automatically](<https://devfeed.tech/tags/automatically.md>), [cs-ce](<https://devfeed.tech/tags/cs-ce.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [design](<https://devfeed.tech/tags/design.md>), [dsm](<https://devfeed.tech/tags/dsm.md>), [efficiency](<https://devfeed.tech/tags/efficiency.md>), [evaluations](<https://devfeed.tech/tags/evaluations.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [framework](<https://devfeed.tech/tags/framework.md>), [fusion](<https://devfeed.tech/tags/fusion.md>), [future](<https://devfeed.tech/tags/future.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [integration](<https://devfeed.tech/tags/integration.md>), [large](<https://devfeed.tech/tags/large.md>), [loops](<https://devfeed.tech/tags/loops.md>), [matrices](<https://devfeed.tech/tags/matrices.md>), [model](<https://devfeed.tech/tags/model.md>), [optimisation](<https://devfeed.tech/tags/optimisation.md>), [physics-comp-ph](<https://devfeed.tech/tags/physics-comp-ph.md>), [structure](<https://devfeed.tech/tags/structure.md>)

### AI overview

Design Structure Matrices (DSMs) make coupling architecture in multidisciplinary design analysis and optimisation codes visible, helping identify structural assumptions and opportunities to improve computational efficiency. The work applies DSM methods to stellarator optimisation with SIMSOPT and the PROCESS systems code. In PROCESS, an automatically generated DSM exposed feedback loops that informed a solver architecture change, significantly reducing model evaluations. The authors see this approach as especially relevant to future frameworks combining high-fidelity models with many inexpensive models.

### Source excerpt

arXiv:2611.22522v1 Announce Type: cross Abstract: The integrated analysis and optimisation codes used to design nuclear fusion reactors need to become increasingly large scale, multidisciplinary and complex to computationally verify design requirements more thoroughly and earlier in the design process. Though the manner in which the integrated models are coupled can have significant implications for computational efficiency, the structure of couplings typically remains hidden in the implementation of a design framework. As this problem is not unique to fusion, we frame integrated design problems as applications of the broader field of Multidisciplinary Design Analysis and Optimisation (MDAO). Originally developed for complex system design problems in e.g. aerospace, the MDAO field uses (extended) Design Structure Matrices (DSMs) to display the architecture of integrated analysis and optimisation codes. The aim of this work is to introduce these DSM methods and demonstrate how they can be used to improve the transparency and efficiency of design codes in fusion. As a proof of concept, DSM methods are applied to two case studies: stellarator optimisation with SIMSOPT and the PROCESS systems code. With these cases, we illustrate how a DSM can help identify structural assumptions in the code, and how architectural insight can be used to improve computational efficiency. In particular, we demonstrate the computational impact by modifying the PROCESS solver architecture based on the feedback loops revealed in an automatically generated DSM, yielding a significant reduction in model evaluations. Such architectural changes are considered especially impactful for future design frameworks that combine higher fidelity models with large numbers of inexpensive models.

## Fidelity Regret: Measuring Simulator Misspecification in Verifiable Design

DevFeed: [Fidelity Regret: Measuring Simulator Misspecification in Verifiable Design](<https://devfeed.tech/articles/fidelity-regret-measuring-simulator-misspecification-in-verifiable-design-139994.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.22263>)

Author: Noah Flynn

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>), [LLM evaluation / benchmarking](<https://devfeed.tech/topics/llm-evaluation-benchmarking.md>), [atomic reference counting](<https://devfeed.tech/topics/atomic-reference-counting.md>)

Tags: [budget](<https://devfeed.tech/tags/budget.md>), [circuit](<https://devfeed.tech/tags/circuit.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [design](<https://devfeed.tech/tags/design.md>), [mitigation](<https://devfeed.tech/tags/mitigation.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [search](<https://devfeed.tech/tags/search.md>), [simulator](<https://devfeed.tech/tags/simulator.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

In a 21,362-design genetic-circuit study spanning five measured gate libraries and three organisms, cheap-simulator selection retained positive reference regret in nearly all tested settings despite valid topological verification. Mean normalized regret was 0.369 across 72 cells, with only six at zero; it varied by reference objective, including 0.113 for cytometry quality versus 0.801 for growth burden in yeast library SC1C1G1T1. An oracle whitelist retaining at least 25% of designs still left positive regret in 30 of 52 cells. At matched modeled cost, an in-sample rule allocating 34% of budget to re-score top cheap-simulator candidates achieved mean excess regret 0.016, versus 0.305 for cheap-only and 0.034 for reference-only selection, and beat cheap-only in 330 of 360 cells. Mitigation depended on budget and library; the abstract frames fidelity regret as a way to detect simulator-to-objective gaps.

### Source excerpt

arXiv:2611.22263v1 Announce Type: new Abstract: RLVF assumes the verifier evaluates the quantity of interest. In genetic-circuit design, a topological verifier can establish that a program is a valid circuit computing the target function, whereas ranking its physical performance requires a simulator. We measure fidelity regret, the reference simple regret incurred when a cheap simulator selects the design, over a 21,362-design combination subspace spanning 5 measured gate libraries and 3 organisms. Exact ordered-assignment checks retain positive regret in every tested cell while shifting magnitudes in both directions. Mean normalized regret is 0.369 over 72 cells and only 6 have zero regret. The discrepancy depends strongly on the reference axis: the yeast library SC1C1G1T1 has mean regret 0.113 for cytometry quality and 0.801 for growth burden, and every evaluated library--circuit-size pair has positive burden regret. Topological verification ties all valid gate assignments, while an oracle whitelist subject to retaining at least 25% of the design space leaves positive regret in 30 of 52 cells. Design-space optimization and feedback-guided search with frozen language models reach the high-regret regions; on a matched zero-regret control, additional optimization instead reduces regret. At a matched modeled-cost budget, mitigation is budget- and library-dependent. An in-sample fixed rule spending $\alpha{=}0.34$ of the budget re-scoring top cheap-simulator designs achieves mean excess regret 0.016, compared with 0.305 for cheap-only and 0.034 for reference-only selection, improving on cheap-only in 330 of 360 cells. More broadly, any workflow optimized through a simulator or digital twin can satisfy its verifier yet perform poorly on the intended physical objective. Fidelity regret provides a transferable template for detecting this gap before optimization and comparing budget-aware remedies across scientific domains.

## TPU Model Design Considerations and Optimization Guide

DevFeed: [TPU Model Design Considerations and Optimization Guide](<https://devfeed.tech/articles/tpu-model-design-considerations-and-optimization-guide-136558.md>)

Original publisher: [Read original article](<https://developers.googleblog.com/tpu-model-design-considerations-and-optimization-guide/>)

Author: Gagik Amirkhanyan; Vaibhav Singh

Published: 2026-11-17T05:43:32.994674Z

Content type: article

Language: en

Sources: [Google Developers Blog](<https://devfeed.tech/sources/google-developers-blog.md>)

Topics: [model architecture](<https://devfeed.tech/topics/model-architecture.md>), [LLM optimization](<https://devfeed.tech/topics/llm-optimization.md>), [distributed-training](<https://devfeed.tech/topics/distributed-training.md>), [High-Performance Computing](<https://devfeed.tech/topics/high-performance-computing.md>), [quantization](<https://devfeed.tech/topics/quantization.md>), [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [arrays](<https://devfeed.tech/tags/arrays.md>), [design](<https://devfeed.tech/tags/design.md>), [developers](<https://devfeed.tech/tags/developers.md>), [dimensions](<https://devfeed.tech/tags/dimensions.md>), [experts](<https://devfeed.tech/tags/experts.md>), [guide](<https://devfeed.tech/tags/guide.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [llms](<https://devfeed.tech/tags/llms.md>), [mapping](<https://devfeed.tech/tags/mapping.md>), [mixture-of-experts](<https://devfeed.tech/tags/mixture-of-experts.md>), [mixture-of-experts-moe](<https://devfeed.tech/tags/mixture-of-experts-moe.md>), [model](<https://devfeed.tech/tags/model.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [performance](<https://devfeed.tech/tags/performance.md>), [principles](<https://devfeed.tech/tags/principles.md>), [rules](<https://devfeed.tech/tags/rules.md>), [systolic-arrays](<https://devfeed.tech/tags/systolic-arrays.md>), [tpu](<https://devfeed.tech/tags/tpu.md>)

### AI overview

The guide's core recommendation is to design model shapes, routing, and parallelism around TPU hardware, then validate changes by wall-clock measurements on a tuned stack. Align contracting and output dimensions to multiples of 256; reshape attention to head_dim 256 where quality permits, since smaller dimensions can leave the MXU underused. Keep dynamic workloads in fixed-shape buffers and represent variable extents with metadata to avoid recompilation. For MoEs, LatentMoE compresses routed tokens before dispatch, reducing expert weight reads and communication; a measured 30B model gained 14% end-to-end training throughput with latent width 768. Larger shared experts and fewer, wider routed experts can improve compute intensity, though routing diversity may suffer and the best granularity should be ablated at target scale. Offload sorting and gather/scatter to SparseCore, fuse vector operations where possible, and map communication-heavy parallel axes to fast physical links. The text stresses that measured rankings and gains depend on configuration; thresholds can change across TPU generations.

### Source excerpt

The newly launched AI-Hypercomputer/tpu-codesign guide provides hardware-grounded design rules to help developers maximize performance on TPUs for LLMs and Mixture-of-Experts (MoE) workloads. Key principles include aligning reduction and output dimensions to 256 for systolic arrays, adopting LatentMoE to compress routed token traffic, and mapping parallel axes directly onto physical links.

## SAFE: Formal Specification and Implementation of a Scalable Analysis Framework for ECMAScript

DevFeed: [SAFE: Formal Specification and Implementation of a Scalable Analysis Framework for ECMAScript](<https://devfeed.tech/articles/safe-formal-specification-and-implementation-of-a-scalable-analysis-framework-for-ecmascript-138009.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.21148>)

Author: Hongki Lee, Sooncheol Won, Joonho Jin, Junhee Cho, Sukyoung Ryu

Published: 2026-11-17T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>), [ECMAScript](<https://devfeed.tech/topics/ecmascript.md>), [Tool](<https://devfeed.tech/topics/tool.md>)

Tags: [analysis](<https://devfeed.tech/tags/analysis.md>), [applications](<https://devfeed.tech/tags/applications.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [community](<https://devfeed.tech/tags/community.md>), [compilation](<https://devfeed.tech/tags/compilation.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [define](<https://devfeed.tech/tags/define.md>), [design](<https://devfeed.tech/tags/design.md>), [ecmascript](<https://devfeed.tech/tags/ecmascript.md>), [flexible](<https://devfeed.tech/tags/flexible.md>), [formal](<https://devfeed.tech/tags/formal.md>), [framework](<https://devfeed.tech/tags/framework.md>), [future](<https://devfeed.tech/tags/future.md>), [generate](<https://devfeed.tech/tags/generate.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [intermediate](<https://devfeed.tech/tags/intermediate.md>), [intermediate-representations](<https://devfeed.tech/tags/intermediate-representations.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [safe](<https://devfeed.tech/tags/safe.md>), [specification](<https://devfeed.tech/tags/specification.md>)

### AI overview

SAFE is an open-source, formally specified analysis framework for ECMAScript intended to help JavaScript researchers build and adapt program analyses. It defines three intermediate representations and formally specifies the translations between them. Open-source tools generate parsers and some representations, supporting adaptation to syntax changes; the framework is designed to be flexible, scalable, and pluggable across compilation phases. The abstract says SAFE is publicly available and collaborative research using it is underway.

### Source excerpt

arXiv:2611.21148v1 Announce Type: cross Abstract: The prevalent uses of JavaScript in web programming have revealed security vulnerability issues of JavaScript applications, which emphasizes the need for JavaScript analyzers to detect such issues. Recently, researchers have proposed several analyzers of JavaScript programs and some web service companies have developed various JavaScript engines. However, unfortunately, most of the tools are not documented well, thus it is very hard to understand and modify them. Or, such tools are often not open to the public. In this paper, we present formal specification and implementation of SAFE, a scalable analysis framework for ECMAScript, developed for the JavaScript research community. This is the very first attempt to provide both formal specification and its opensource implementation for JavaScript, compared to the existing approaches focused on only one of them. To make it more amenable for other researchers to use our framework, we formally define three kinds of intermediate representations for JavaScript used in the framework, and we provide formal specifications of translations between them. To be adaptable for adventurous future research including modifications in the original JavaScript syntax, we actively use open-source tools to automatically generate parsers and some intermediate representations. To support a variety of program analyses in various compilation phases, we design the framework to be as flexible, scalable, and pluggable as possible. Finally, our framework is publicly available, and some collaborative research using the framework are in progress.

## Taint Analysis via Heap-Aware Propagation

DevFeed: [Taint Analysis via Heap-Aware Propagation](<https://devfeed.tech/articles/taint-analysis-via-heap-aware-propagation-139299.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.20453>)

Author: Yusen Su, Jorge A. Navas, Arie Gurfinkel

Published: 2026-11-17T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>)

Topics: [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>), [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>), [structure](<https://devfeed.tech/topics/structure.md>)

Tags: [array](<https://devfeed.tech/tags/array.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-lo](<https://devfeed.tech/tags/cs-lo.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [data-flow-analysis](<https://devfeed.tech/tags/data-flow-analysis.md>), [data-structure](<https://devfeed.tech/tags/data-structure.md>), [experiments](<https://devfeed.tech/tags/experiments.md>), [heap](<https://devfeed.tech/tags/heap.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [taint-analysis](<https://devfeed.tech/tags/taint-analysis.md>), [world](<https://devfeed.tech/tags/world.md>)

### AI overview

The paper presents a field-sensitive taint analysis for C that combines DSA points-to information with explicit dependency tracking. It identifies a precision loss when a struct mixes scalar fields with a flexible array member accessed using symbolic indices: existing DSA-style analysis can merge field information across the whole object, increasing false alarms. Its proposed I-DSA represents field positions as intervals, limiting merges to fields within symbolic bounds, and pairs this with a sound data-flow analysis based on abstract interpretation. Implemented on SeaDSA and Crab for LLVM IR, the tool supports configurable taint policies through taint intrinsics. The reported experiments find that I-DSA reduces false alarms from this pattern at little pointer-analysis cost; SVF exhibits similar field-sensitivity loss, while the taint analysis scales better than PhASAR on real-world programs.

### Source excerpt

arXiv:2611.20453v1 Announce Type: cross Abstract: Taint analysis for C depends on how precisely the analysis tracks tainted values as they flow through memory objects. Without field sensitivity, a tainted object field can spuriously taint an entire object, producing significant false alarms. In this paper, we present a field-sensitive taint analysis that combines Data Structure Analysis (DSA) for field-sensitive points-to information with a data-flow analysis for tracking explicit dependencies. We identify that existing DSA-style analyses lose precision on a common object pattern: a C struct object that mixes scalar fields with a flexible array member. When such an array is accessed with symbolic indices, DSA loses points-to field sensitivity for the entire object, inflating false alarms in the data-flow analysis. To address this, we propose I-DSA, which extends DSA by representing field positions as intervals, so that a pointer with symbolic bounds merges only the fields within those bounds. We further develop a sound data-flow analysis based on abstract interpretation. We implement I-DSA on top of SeaDSA and the data-flow analysis inside Crab. Our tool targets LLVM IR and supports configurable taint policies by instrumenting the IR with taint intrinsics. Our experiments show that I-DSA reduces the false alarms caused by this pattern at little cost in the pointer analysis, that SVF, an inclusion-based pointer analysis, shows a similar field-sensitivity loss, and that our taint analysis scales better than PhASAR on real-world programs.

## Precision in type system design (or the Option type as an anti-pattern)

DevFeed: [Precision in type system design (or the Option type as an anti-pattern)](<https://devfeed.tech/articles/precision-in-type-system-design-or-the-option-type-as-an-anti-pattern-139422.md>)

Original publisher: [Read original article](<https://dashbit.co/blog/precision-in-type-system-design>)

Author: José Valim

Published: 2026-11-17T00:00:00Z

Content type: article

Language: en

Sources: [Dashbit Blog](<https://devfeed.tech/sources/dashbit-blog.md>)

Topics: [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>), [union types](<https://devfeed.tech/topics/union-types.md>), [typesafety](<https://devfeed.tech/topics/typesafety.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [api](<https://devfeed.tech/tags/api.md>), [arithmetic](<https://devfeed.tech/tags/arithmetic.md>), [array](<https://devfeed.tech/tags/array.md>), [arrays](<https://devfeed.tech/tags/arrays.md>), [article](<https://devfeed.tech/tags/article.md>), [binaries](<https://devfeed.tech/tags/binaries.md>), [boolean](<https://devfeed.tech/tags/boolean.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [code](<https://devfeed.tech/tags/code.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [collection](<https://devfeed.tech/tags/collection.md>), [design](<https://devfeed.tech/tags/design.md>), [elixir](<https://devfeed.tech/tags/elixir.md>), [option](<https://devfeed.tech/tags/option.md>), [precision](<https://devfeed.tech/tags/precision.md>), [simplicity](<https://devfeed.tech/tags/simplicity.md>), [type](<https://devfeed.tech/tags/type.md>), [type-system](<https://devfeed.tech/tags/type-system.md>)

### AI overview

The article argues that greater type precision can expose hidden runtime assumptions, while also making programs harder to prove, signatures more verbose, error messages harder to read, and type checking slower. Its Elixir examples show how distinguishing empty from non-empty lists lets `Enum.max_by` require a non-empty list and catches an unsafe refactor; however, proving that a list remains non-empty after dropping elements can still exceed the type system's capabilities. The author calls `Option`/`Maybe` results an anti-pattern for API and language designers when they compensate for behavior that could be guaranteed statically, while recognizing they remain appropriate for inherently uncertain operations such as file access. Types rule out some errors but do not make programs error-free, so runtime failures still need isolation. The article concludes that sound, decidable type systems will reject some valid programs, and that designers must balance precision with ergonomics and performance.

### Source excerpt

When fine-tuning a type system for precision, we often have to make trade-offs between simplicity and expressiveness in its design. The goal of this article is to explore these trade-offs.

## Runtime Analysis of Cartesian Genetic Programming on Max: A Proven Exponential Speedup

DevFeed: [Runtime Analysis of Cartesian Genetic Programming on Max: A Proven Exponential Speedup](<https://devfeed.tech/articles/runtime-analysis-of-cartesian-genetic-programming-on-max-a-proven-exponential-speedup-132189.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.16013>)

Author: Duc-Cuong Dang, Roman Kalkreuth, Andre Opris

Published: 2026-11-13T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>), [Combinatorial optimization](<https://devfeed.tech/topics/combinatorial-optimization.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [automated](<https://devfeed.tech/tags/automated.md>), [based](<https://devfeed.tech/tags/based.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [benefit](<https://devfeed.tech/tags/benefit.md>), [can](<https://devfeed.tech/tags/can.md>), [candidate](<https://devfeed.tech/tags/candidate.md>), [computer](<https://devfeed.tech/tags/computer.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cs-ne](<https://devfeed.tech/tags/cs-ne.md>), [decades](<https://devfeed.tech/tags/decades.md>), [discovery](<https://devfeed.tech/tags/discovery.md>), [efficiently](<https://devfeed.tech/tags/efficiently.md>), [evolution](<https://devfeed.tech/tags/evolution.md>), [experiments](<https://devfeed.tech/tags/experiments.md>), [first](<https://devfeed.tech/tags/first.md>), [fitness](<https://devfeed.tech/tags/fitness.md>), [max](<https://devfeed.tech/tags/max.md>), [programming](<https://devfeed.tech/tags/programming.md>), [runtime](<https://devfeed.tech/tags/runtime.md>)

### AI overview

For the Max problem, the paper proves that the (1+1) Cartesian Genetic Programming algorithm with common mutation operators has expected runtime at most O(log^9 n) to evolve an equivalent optimal program with the same output. The abstract contrasts this polylogarithmic bound with the previously established superlinear expected runtime for tree-based genetic programming in the optimal program length n, describing the difference as an exponential speedup. Experiments complement the theoretical analysis; the excerpt does not provide their details.

### Source excerpt

arXiv:2611.16013v1 Announce Type: cross Abstract: Genetic Programming (GP) is a search paradigm inspired from natural evolution for the automated discovery of expressions, functions, and computer programs. Cartesian GP (CGP) is a flavor of GP that uses a graph-based model to encode candidate programs, as contrasted to the conventional Tree-based GP (TGP). Since its inception two decades ago, CGP has predominantly been analyzed empirically, thus little is known regarding its theoretical performance guarantees. This paper analyzes CGP for the Max problem, which has been only rigorously studied for TGP with a proven expected runtime superlinear in the optimal program length $n$. We prove that the expected time for the ($1$+$1$)~CGP employing common mutation operators to evolve an equivalent optimal of the same output is polylogarithmic in $n$, specifically at most $O(\log^9{n})$. This is remarkable, as it shows an exponential speedup by switching to CGP. Our results shed light on the benefit and the compactness of the graph-based representation for programs, and on how CGP can navigate its search and fitness spaces efficiently. This is a first proven performance guarantee for CGP on an established benchmark problem. Experiments complement our theoretical findings.

## Toward Autonomous RTL and Synthesis Optimization: Benchmarking and Self-Improving Agents

DevFeed: [Toward Autonomous RTL and Synthesis Optimization: Benchmarking and Self-Improving Agents](<https://devfeed.tech/articles/toward-autonomous-rtl-and-synthesis-optimization-benchmarking-and-self-improving-agents-128350.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.13713>)

Author: Wenji Fang, Yao Lu, Jinghua Wang, Zhiyao Xie

Published: 2026-11-11T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>), [agentic workflows](<https://devfeed.tech/topics/agentic-workflows.md>), [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>), [Optimization](<https://devfeed.tech/topics/optimization.md>), [Phoronix Test Suite](<https://devfeed.tech/topics/phoronix-test-suite.md>)

Tags: [17](<https://devfeed.tech/tags/17.md>), [2](<https://devfeed.tech/tags/2.md>), [3](<https://devfeed.tech/tags/3.md>), [abstract](<https://devfeed.tech/tags/abstract.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agent-framework](<https://devfeed.tech/tags/agent-framework.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-native](<https://devfeed.tech/tags/ai-native.md>), [algorithm](<https://devfeed.tech/tags/algorithm.md>), [algorithms](<https://devfeed.tech/tags/algorithms.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [area](<https://devfeed.tech/tags/area.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [automation](<https://devfeed.tech/tags/automation.md>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [benchmarking](<https://devfeed.tech/tags/benchmarking.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-ar](<https://devfeed.tech/tags/cs-ar.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [rtl](<https://devfeed.tech/tags/rtl.md>), [synthesis](<https://devfeed.tech/tags/synthesis.md>)

### AI overview

The paper outlines three directions for autonomous RTL and synthesis optimization: realistic benchmarks that evaluate designs in EDA workflows; tool-grounded RTL optimization; and design-specific synthesis tuning. Its Dr. RTL multi-agent framework analyzes critical paths, rewrites RTL, evaluates implementation results, and improves using reusable optimization skills. Across 20 real-world designs, it reports average WNS and TNS improvements of 21% and 17%, respectively, with 6% less area than commercial synthesis. The paper also explores agent-driven synthesis scripts and executable algorithms spanning intermediate representations, technology-independent optimization, and technology mapping. It envisions joint exploration of architectural, RTL, and EDA algorithm choices guided by verification constraints and implementation feedback.

### Source excerpt

arXiv:2611.13713v1 Announce Type: new Abstract: Recent advances in large language models (LLMs) and autonomous agents are creating new opportunities for hardware design optimization. This paper examines three connected directions toward autonomous RTL and synthesis optimization: (1) Realistic benchmarking. We discuss reference-based and open-ended RTL optimization benchmarks that evaluate optimization opportunities under realistic EDA workflows. (2) Tool-grounded RTL optimization. We present Dr. RTL, a multi-agent framework that automates critical-path analysis, RTL rewriting, and implementation-level evaluation, while continuously improving through reusable optimization skills. Evaluated on 20 real-world RTL designs, Dr.~RTL achieves average WNS/TNS improvements of 21\%/17\% with a 6\% area reduction over commercial synthesis. (3) Design-specific synthesis optimization. We explore agent-driven synthesis script tuning and the discovery of executable synthesis algorithms across intermediate representations, technology-independent optimization, and technology mapping. Finally, we envision AI-native design automation that jointly explores architectural, RTL, and EDA algorithm design spaces, guided by verification constraints and implementation feedback.

## PRISM: Preference-based Reward and Uncertainty-Integrated Synthesis Minimization for RTL PPA Optimization

DevFeed: [PRISM: Preference-based Reward and Uncertainty-Integrated Synthesis Minimization for RTL PPA Optimization](<https://devfeed.tech/articles/prism-preference-based-reward-and-uncertainty-integrated-synthesis-minimization-for-rtl-ppa-optimization-127244.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.11051>)

Author: Armin Abdollahi, Negin Ashrafi, Mehdi Kamal, Massoud Pedram

Published: 2026-11-10T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Combinatorial optimization](<https://devfeed.tech/topics/combinatorial-optimization.md>), [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>), [Parallel reasoning](<https://devfeed.tech/topics/parallel-reasoning.md>)

Tags: [budget](<https://devfeed.tech/tags/budget.md>), [cs-ar](<https://devfeed.tech/tags/cs-ar.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [ppa](<https://devfeed.tech/tags/ppa.md>), [reward](<https://devfeed.tech/tags/reward.md>), [rtl](<https://devfeed.tech/tags/rtl.md>), [synthesis](<https://devfeed.tech/tags/synthesis.md>), [uncertainty](<https://devfeed.tech/tags/uncertainty.md>)

### AI overview

PRISM aims to improve RTL power, performance, and area while limiting costly commercial synthesis calls. It generates rewrites with an LLM, filters them through compile and simulation equivalence checks, extracts low-cost proxy features, then selectively evaluates candidates with Synopsys Design Compiler. A preference reward model trained on pairwise synthesis outcomes ranks candidates; ensemble uncertainty and diversity-aware selection guide evaluations. PRISM maintains a set of non-dominated designs and feeds them back into generation and refinement. The abstract reports post-synthesis gains across RTLLM v2.0 modules under fixed call budgets, and says ablations identify reward-guided selection and candidate dropping as key to sample-efficient progress. It evaluates the same pipeline at 7, 15, and 45 nm without retraining; the excerpt gives no quantitative gains.

### Source excerpt

arXiv:2611.11051v1 Announce Type: cross Abstract: This paper introduces a budget-aware, multi-objective framework (called PRISM) for RTL optimization that improves power, performance, and area (PPA) while sharply limiting expensive commercial synthesis tool calls. Starting from a synthesizable baseline and functional testbench, the method iterates through LLM-driven rewrite generation, fast compile/simulation equivalence filtering, low-cost proxy feature extraction, and selective commercial synthesis tool (Synopsys Design Compiler (DC)) evaluation. To prioritize which candidates deserve high-quality synthesis, we train a preference-based reward model using pairwise ranking supervision derived from commercial synthesis tool outcomes, and combine ensemble uncertainty with a diversity-aware acquisition rule to avoid early bias and redundant evaluations. A key advantage is that PRISM maintains a best-tradeoff set G of non-dominated designs throughout the run: G preserves the best solutions found so far, is fed back into generation and refinement, and enables consistent, cumulative improvements rather than repeatedly restarting from the baseline. Across RTLLM v2.0 modules, the approach consistently yields post-synthesis gains under fixed commercial synthesis tool call budgets, and ablations confirm that reward-guided selection and candidate dropping are central to sample-efficient progress. PRISM efficacy is evaluated across multiple technology nodes (7 nm, 15 nm, and 45 nm) using identical pipelines without retraining.

## ShikumiMiner: Mining Recurring Implementation Patterns in AI Codebases

DevFeed: [ShikumiMiner: Mining Recurring Implementation Patterns in AI Codebases](<https://devfeed.tech/articles/shikumiminer-mining-recurring-implementation-patterns-in-ai-codebases-127201.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2609.02789>)

Author: Afsana Tasnim, Saif Uddin Mahmud, Md Erfan, Md Rayhanur Rahman

Published: 2026-11-10T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [coding patterns](<https://devfeed.tech/topics/coding-patterns.md>), [Data Mining & Modeling](<https://devfeed.tech/topics/data-mining-modeling.md>), [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [analyze](<https://devfeed.tech/tags/analyze.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [compare](<https://devfeed.tech/tags/compare.md>), [control](<https://devfeed.tech/tags/control.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [framework](<https://devfeed.tech/tags/framework.md>), [functions](<https://devfeed.tech/tags/functions.md>), [github](<https://devfeed.tech/tags/github.md>), [graph](<https://devfeed.tech/tags/graph.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llm-applications](<https://devfeed.tech/tags/llm-applications.md>), [local-llm](<https://devfeed.tech/tags/local-llm.md>), [mining](<https://devfeed.tech/tags/mining.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [patterns](<https://devfeed.tech/tags/patterns.md>), [static](<https://devfeed.tech/tags/static.md>), [static-analysis](<https://devfeed.tech/tags/static-analysis.md>)

### AI overview

ShikumiMiner uses static analysis combining Abstract Syntax Tree and Control Flow Graph features to identify and compare recurring implementation patterns in C++ local LLM codebases. The study analyzes ten open-source GitHub repositories and uses a multi-label Random Forest model to classify functions into seven categories defined for the study. The supplied abstract does not specify the categories or report the patterns found.

### Source excerpt

arXiv:2609.02789v2 Announce Type: replace Abstract: Large language models are paving the way towards innovation by understanding, analyzing, summarizing and generating content in the modern world. Currently there are thousands of LLM projects developed by engineers in open-source repositories. However, whether these LLM projects have underlying patterns or not remains a question. Exploring these underlying patterns will give new dimensions to the developers who aim to develop these LLM projects. In this paper, we propose ShikumiMiner, a static-analysis framework that combines Abstract Syntax Tree (AST) and Control Flow Graph (CFG) features to detect and compare recurring implementation patterns in C++ local LLM codebases. We analyze ten GitHub open-source repositories and classify functions into seven study-specific categories using a multi-label Random Forest model. Studying these patterns can provide useful insights for developers aiming to design LLM applications.

## From Formal Methods to Fuzzing and Back

DevFeed: [From Formal Methods to Fuzzing and Back](<https://devfeed.tech/articles/from-formal-methods-to-fuzzing-and-back-127266.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.12338>)

Author: Alastair F. Donaldson

Published: 2026-11-10T05:00:00Z

Content type: opinion

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Formal methods](<https://devfeed.tech/topics/formal-methods.md>), [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [compilers](<https://devfeed.tech/tags/compilers.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [formal-methods](<https://devfeed.tech/tags/formal-methods.md>), [fuzzing](<https://devfeed.tech/tags/fuzzing.md>), [generative-ai](<https://devfeed.tech/tags/generative-ai.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [keystone](<https://devfeed.tech/tags/keystone.md>), [scale](<https://devfeed.tech/tags/scale.md>), [software](<https://devfeed.tech/tags/software.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

The author's experience suggests fuzzing can find real bugs in very large systems where formal methods have been difficult to scale, while formal methods remain useful for targeted work. The account traces this shift through GPUVerify, which verifies GPU kernels, and GraphicsFuzz, which uses randomized testing on GPU compilers. It presents the oracle problem as a link between the approaches, describes work at their boundary, and considers whether generative AI could help formal methods scale. The author plans to explore that question through the Keystone project; the abstract states this as an aim, not a demonstrated result.

### Source excerpt

arXiv:2611.12338v1 Announce Type: new Abstract: For the first twelve years of my career in computer science I mainly worked on formal methods. I had been drawn to the field as an undergraduate by its promise of a way to build software with strong, mathematically based correctness guarantees. But after many years of struggling to make formal methods scale, I was seduced by randomised testing---also known as fuzzing. Fuzzing is much less principled than formal methods, but it just works: it can be readily applied to very large systems, and it is extremely effective at finding real bugs that developers care about and fix. In this personal account I trace my path from formal methods to fuzzing, by way of the GPUVerify project on verifying GPU kernels and the GraphicsFuzz project on randomised testing of GPU compilers. I argue that the oracle problem provides an intellectual link between fuzzing and formal methods, describe my continuing, targeted uses of formal methods in the domain of GPU programming language design, and discuss work at the boundary between formal methods and fuzzing. Finally, I reflect on whether generative AI might be the missing ingredient that allows formal methods to scale, and set out my plans for large-scale formal methods via the Keystone project, through which my collaborators and I aim to find out how much of that promise can be realised in practice.

## Optimal Probabilistic Answer Set Programming: Complexity and Implementations

DevFeed: [Optimal Probabilistic Answer Set Programming: Complexity and Implementations](<https://devfeed.tech/articles/optimal-probabilistic-answer-set-programming-complexity-and-implementations-124607.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.09022>)

Author: Damiano Azzolini, Giuseppe Mazzotta, Francesco Ricca, Fabrizio Riguzzi

Published: 2026-11-09T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [computational complexity](<https://devfeed.tech/topics/computational-complexity.md>), [Combinatorial optimization](<https://devfeed.tech/topics/combinatorial-optimization.md>), [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>)

Tags: [complexity](<https://devfeed.tech/tags/complexity.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lo](<https://devfeed.tech/tags/cs-lo.md>), [inference](<https://devfeed.tech/tags/inference.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [probabilistic](<https://devfeed.tech/tags/probabilistic.md>), [programming](<https://devfeed.tech/tags/programming.md>), [real-world](<https://devfeed.tech/tags/real-world.md>), [semantics](<https://devfeed.tech/tags/semantics.md>), [set](<https://devfeed.tech/tags/set.md>)

### AI overview

The paper extends credal Probabilistic Answer Set Programming to support optimization through weak constraints, addressing tasks where solutions must meet optimality criteria. It defines the semantics and studies the complexity of inference and most probable explanation tasks. The proposed practical implementations use Algebraic Model Counting and Answer Set Programming with Quantifiers; an evaluation on three real-world tasks reports applicability. The supplied text does not describe implementation details or comparative results.

### Source excerpt

arXiv:2611.09022v1 Announce Type: cross Abstract: Probabilistic Answer Set Programming (PASP) extends Answer Set Programming with the possibility of representing uncertain data. Among the possible available semantics, we focus here on the credal semantics. In this setting, prior work has focused exclusively on plain ASP programs, i.e., programs without optimization constructs. However, many real world tasks define optimality criteria over the possible solutions, which cannot be conveniently modeled with existing probabilistic ASP frameworks. In this paper, we close this gap and propose optimal Probabilistic Answer Set Programming, which extends PASP by also allowing weak constraints, which are the standard optimization construct of ASP. We define the semantics of such programs, study the computational complexity of the inference and most probable explanation tasks, and propose practical implementations based on Algebraic Model Counting and Answer Set Programming with Quantifiers. An empirical evaluation of the proposed approach on three real world tasks confirms the applicability of our framework.

## Java and the Next Generation of Programming Models

DevFeed: [Java and the Next Generation of Programming Models](<https://devfeed.tech/articles/java-and-the-next-generation-of-programming-models-122669.md>)

Original publisher: [Read original article](<https://inside.java/2026/11/08/devoxxbelgium-java-next-programming-models/>)

Author: Ana-Maria Mihalceanu

Published: 2026-11-08T00:00:00Z

Content type: article

Language: en

Sources: [Inside Java](<https://devfeed.tech/sources/inside-java.md>)

Topics: [Java](<https://devfeed.tech/topics/java.md>), [AI Chat](<https://devfeed.tech/topics/ai-chat.md>), [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-models](<https://devfeed.tech/tags/ai-models.md>), [analyze](<https://devfeed.tech/tags/analyze.md>), [api](<https://devfeed.tech/tags/api.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [backends](<https://devfeed.tech/tags/backends.md>), [bridge](<https://devfeed.tech/tags/bridge.md>), [can](<https://devfeed.tech/tags/can.md>), [code](<https://devfeed.tech/tags/code.md>), [engines](<https://devfeed.tech/tags/engines.md>), [express](<https://devfeed.tech/tags/express.md>), [external](<https://devfeed.tech/tags/external.md>), [files](<https://devfeed.tech/tags/files.md>), [function](<https://devfeed.tech/tags/function.md>), [gap](<https://devfeed.tech/tags/gap.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [inference](<https://devfeed.tech/tags/inference.md>), [java](<https://devfeed.tech/tags/java.md>), [jvm](<https://devfeed.tech/tags/jvm.md>), [models](<https://devfeed.tech/tags/models.md>), [programming](<https://devfeed.tech/tags/programming.md>), [project-babylon](<https://devfeed.tech/tags/project-babylon.md>), [project-panama](<https://devfeed.tech/tags/project-panama.md>)

### AI overview

The session presents two ways to work with specialized runtimes and AI models from Java. For current inference work, it covers the Foreign Function and Memory API (FFM) and tools such as jextract to interact with runtimes outside the JVM. It then introduces Project Babylon's Code Reflection as a proposed path for expressing AI models as Java programs that can be analyzed, transformed, and lowered to inference engines and hardware accelerator backends, without external model files or glue code. The description frames these as present-day FFM-based inference and a future Code Reflection approach; it does not provide implementation details or performance results.

### Source excerpt

Modern software increasingly interacts with AI models, query languages, and other specialized programming models, forcing you to switch contexts, embed foreign code, or write verbose wrappers to bridge the gap. What if you could express logic from outside the JVM directly in Java? In this session, we start by looking at how Java enables you to safely interact with runtimes outside of the JVM using the Foreign Function and Memory API and tools like jextract. Then will push further with Project Babylon's code reflection: express AI models as Java programs that Babylon can analyze, transform and lower to inference engines, thus leveraging hardware accelerator backends while skipping external model files or the need to glue code.

## Making profile-guided optimization reproducible

DevFeed: [Making profile-guided optimization reproducible](<https://devfeed.tech/articles/making-profile-guided-optimization-reproducible-122552.md>)

Original publisher: [Read original article](<https://fzakaria.com/2026/11/07/making-profile-guided-optimization-reproducible>)

Published: 2026-11-07T18:00:00Z

Content type: article

Language: en

Sources: [Farid Zakaria's Blog](<https://devfeed.tech/sources/farid-zakaria-s-blog.md>)

Topics: [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>), [Nix](<https://devfeed.tech/topics/nix.md>), [inlining](<https://devfeed.tech/topics/inlining.md>), [performance-optimization](<https://devfeed.tech/topics/performance-optimization.md>)

Tags: [amd](<https://devfeed.tech/tags/amd.md>), [binaries](<https://devfeed.tech/tags/binaries.md>), [block](<https://devfeed.tech/tags/block.md>), [blocks](<https://devfeed.tech/tags/blocks.md>), [boot](<https://devfeed.tech/tags/boot.md>), [branch](<https://devfeed.tech/tags/branch.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [build](<https://devfeed.tech/tags/build.md>), [builder](<https://devfeed.tech/tags/builder.md>), [builds](<https://devfeed.tech/tags/builds.md>), [cache](<https://devfeed.tech/tags/cache.md>), [clang](<https://devfeed.tech/tags/clang.md>), [clock](<https://devfeed.tech/tags/clock.md>), [closure](<https://devfeed.tech/tags/closure.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compilers](<https://devfeed.tech/tags/compilers.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [performance](<https://devfeed.tech/tags/performance.md>), [pgo](<https://devfeed.tech/tags/pgo.md>), [profile](<https://devfeed.tech/tags/profile.md>)

### AI overview

Profile-guided optimization can improve performance, but its training run normally depends on machine conditions and thread scheduling, producing profiles and binaries that may differ across builds. The article makes PGO reproducible by running only the training step inside Rewind, a deterministic VM, while keeping the instrumented and final compiles as ordinary derivations. The profile is fixed by Rewind inputs such as epoch, seed, schedule, CPU model, and clock. Because Intel and AMD remain distinguishable inside the VM, training must be pinned to a CPU vendor and the derivation requires a matching builder feature. Reproducibility does not ensure a useful profile: the training workload and schedule should resemble expected production behavior. In the example, three of four schedules omit `compress` from training, while one yields an approximately even workload split.

### Source excerpt

Profile-guided optimization (PGO) is an easy way to speed up a program, especially if the workload is somewhat stable. In leaving performance on the table I built a profile-guided sqlite3 variant for a 1.32x speedup for our select workloads.

## Imprompt: A Language Framework for Prompt Programming

DevFeed: [Imprompt: A Language Framework for Prompt Programming](<https://devfeed.tech/articles/imprompt-a-language-framework-for-prompt-programming-117261.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2607.22683>)

Author: Chentian Wu, Shengyuan Yang, Adithya Murali

Published: 2026-11-04T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [Prompt Engineering](<https://devfeed.tech/topics/prompt-engineering.md>), [prompt](<https://devfeed.tech/topics/prompt.md>), [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>), [Programming Language Type Systems](<https://devfeed.tech/topics/programming-language-type-systems.md>), [Transpilers](<https://devfeed.tech/topics/transpilers.md>), [typesafety](<https://devfeed.tech/topics/typesafety.md>)

Tags: [case-studies](<https://devfeed.tech/tags/case-studies.md>), [compilation](<https://devfeed.tech/tags/compilation.md>), [compilers](<https://devfeed.tech/tags/compilers.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-cl](<https://devfeed.tech/tags/cs-cl.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [decoding](<https://devfeed.tech/tags/decoding.md>), [foundations](<https://devfeed.tech/tags/foundations.md>), [framework](<https://devfeed.tech/tags/framework.md>), [language](<https://devfeed.tech/tags/language.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [programming](<https://devfeed.tech/tags/programming.md>), [prompt](<https://devfeed.tech/tags/prompt.md>), [prompt-engineering](<https://devfeed.tech/tags/prompt-engineering.md>), [prompting](<https://devfeed.tech/tags/prompting.md>), [study](<https://devfeed.tech/tags/study.md>), [type-checking](<https://devfeed.tech/tags/type-checking.md>)

### AI overview

Imprompt frames prompts as programs that describe tasks while leaving lower-level execution details to separate mechanisms. It presents structured prompting as prompt programming plus compilation, formally defines two compilers, and explores prompt-program typing by relating type checking to constrained decoding. The authors report implementing the compilers and type checkers and evaluating them in case studies; the excerpt does not give evaluation results.

### Source excerpt

arXiv:2607.22683v2 Announce Type: replace Abstract: With the unprecedented success of Language Models (LMs), the science of Prompt Engineering has evolved the powerful idea of Prompt Programming, where prompts are treated as a programmable control surface for describing complex tasks and leveraging LM capabilities. However, existing prompt programming frameworks suffer from various complexities and inelegances, which make them hard to utilize in practice for effectively describing tasks. We propose Imprompt, a new language framework for the study and practice of prompt programming. We undertake a foundational investigation of prompt programming, and contend that prompt programs must contain only the task descriptions and must be decoupled from lower-level 'execution' details. We further develop this position by illustrating structured prompting as a combination of prompt programming and prompt program 'compilation'. We exemplify this view by formally defining two compilers for Imprompt programs. We then explore the idea of typing for prompt programs and draw a correspondence between type checking and constrained decoding. Finally, we implement our compilers and type checkers and evaluate them on a variety of case studies. We believe our work contributes programming-language foundations toward the emerging area of prompt programming.

## Deep Learning Compilers: Architecture, Optimization, and Empirical Characterization

DevFeed: [Deep Learning Compilers: Architecture, Optimization, and Empirical Characterization](<https://devfeed.tech/articles/deep-learning-compilers-architecture-optimization-and-empirical-characterization-116924.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.04273>)

Author: Jinghao Wen, Ruixuan Wang, Xun Jiao

Published: 2026-11-04T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>), [Deep learning](<https://devfeed.tech/topics/deep-learning.md>), [PyTorch](<https://devfeed.tech/topics/pytorch.md>), [High-Performance Computing](<https://devfeed.tech/topics/high-performance-computing.md>)

Tags: [analysis](<https://devfeed.tech/tags/analysis.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [backend](<https://devfeed.tech/tags/backend.md>), [characterization](<https://devfeed.tech/tags/characterization.md>), [compilation](<https://devfeed.tech/tags/compilation.md>), [compilers](<https://devfeed.tech/tags/compilers.md>), [cs-ar](<https://devfeed.tech/tags/cs-ar.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [deep-learning](<https://devfeed.tech/tags/deep-learning.md>), [deployment](<https://devfeed.tech/tags/deployment.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [experiments](<https://devfeed.tech/tags/experiments.md>), [frontend](<https://devfeed.tech/tags/frontend.md>), [fusion](<https://devfeed.tech/tags/fusion.md>), [graph](<https://devfeed.tech/tags/graph.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [nvidia](<https://devfeed.tech/tags/nvidia.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [performance](<https://devfeed.tech/tags/performance.md>), [pytorch](<https://devfeed.tech/tags/pytorch.md>), [research](<https://devfeed.tech/tags/research.md>)

### AI overview

The paper analyzes deep learning compiler architecture across frontend, middle-end, and backend stages, highlighting the middle-end's role in connecting model representations to hardware-specific optimization. In PyTorch/TorchInductor experiments on an NVIDIA RTX A6000, benefits varied by workload: fusion-friendly graphs achieved up to 8.21x speedup, while other workloads improved less. Compilation overhead could take thousands of executions to amortize. Dynamic-shape compilation cut cumulative shape-transition costs by about 70%, with a modest steady-state performance penalty.

### Source excerpt

arXiv:2611.04273v1 Announce Type: new Abstract: As deep learning (DL) models become increasingly complex and hardware architectures grow more heterogeneous, DL compilers play a critical role in optimizing computational efficiency and enabling scalable deployment. This paper presents a systematic analysis of DL compilers, covering their architectural evolution, compilation workflows, optimization techniques, and emerging research directions. We organize DL compiler architectures into frontend, middle-end, and backend stages, emphasizing the role of the middle-end in connecting high-level model representations with hardware-specific optimizations. We further examine representative DL compilers and recent optimization techniques across different compilation stages. Beyond architectural and technical analysis, we conduct an empirical evaluation of compiler behaviors to investigate the effectiveness of graph optimization, compilation overhead, and dynamic-shape handling. Experiments using PyTorch/TorchInductor on an NVIDIA RTX A6000 demonstrate that compiler benefits depend strongly on workload characteristics, with speedups of up to 8.21\times for fusion-friendly computation graphs, while other workloads exhibit limited improvements. Our results further reveal that compilation overhead can require thousands of executions to amortize, and dynamic-shape compilation reduces cumulative shape-transition costs by approximately 70\% at the expense of modest steady-state performance degradation. By combining systematic architectural analysis with quantitative experimental evidence, this work provides insights into the design, optimization, and practical deployment of modern DL compilers.

## How our agent skills research, build, and test a complete Elastic integration

DevFeed: [How our agent skills research, build, and test a complete Elastic integration](<https://devfeed.tech/articles/how-our-agent-skills-research-build-and-test-a-complete-elastic-integration-114234.md>)

Original publisher: [Read original article](<https://www.elastic.co/search-labs/blog/agent-skills-elastic-integration>)

Author: Chris Berkhout

Published: 2026-11-02T00:00:00Z

Content type: article

Language: en

Sources: [Elasticsearch Labs](<https://devfeed.tech/sources/elasticsearch-labs.md>)

Topics: [Agent Skills](<https://devfeed.tech/topics/agent-skills.md>), [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>), [Developer skills](<https://devfeed.tech/topics/developer-skills.md>), [Integration testing](<https://devfeed.tech/topics/integration-testing.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>), [NVD](<https://devfeed.tech/topics/nvd.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [agent-skills](<https://devfeed.tech/tags/agent-skills.md>), [agentic-ai](<https://devfeed.tech/tags/agentic-ai.md>), [api](<https://devfeed.tech/tags/api.md>), [cel](<https://devfeed.tech/tags/cel.md>), [developer-experience](<https://devfeed.tech/tags/developer-experience.md>), [elastic](<https://devfeed.tech/tags/elastic.md>), [integration](<https://devfeed.tech/tags/integration.md>), [integrations](<https://devfeed.tech/tags/integrations.md>), [research](<https://devfeed.tech/tags/research.md>), [test](<https://devfeed.tech/tags/test.md>)

### AI overview

Elastic's Integration Skills built a NIST NVD integration with two data streams: current CVE snapshots and individual change events. Research found that 78% of records in a day's collection were republications of older CVEs, often with security-relevant changes, leading to the two-stream design. Without an API key, backfill requests must be paced to stay within the shared rate limit. The integration selects one CVSS assessment for ECS fields using a stated version and source priority, while preserving all metric arrays in integration-specific fields. Pipeline and system tests passed, but the text cautions that passing tests cannot establish correct API interpretation, sensible defaults, useful real data, or adequate documentation. Manual inspection and review of the research brief, README, CEL programs, and test coverage remain part of deciding whether to trust the result. Suggested refinements include a latest transform, script tests for error paths, a real logo, and a dashboard.

### Source excerpt

We pointed our agent skills at the NIST NVD API and got two data streams and a validated CEL program, with pipeline and system tests passing. The research showed 78% of a day's CVE records are republications of older ones, which changed the design.

## Maintainer spotlight: Anthony Bolden (@Walnut356)

DevFeed: [Maintainer spotlight: Anthony Bolden (@Walnut356)](<https://devfeed.tech/articles/maintainer-spotlight-anthony-bolden-walnut356-113396.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/inside-rust/2026/11/02/maintainer-spotlight-anthony-bolden-walnut356/>)

Author: Jakub Beránek

Published: 2026-11-02T00:00:00Z

Content type: article

Language: en

Sources: [Inside Rust Blog](<https://devfeed.tech/sources/inside-rust-blog.md>)

Topics: [Tool](<https://devfeed.tech/topics/tool.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>), [Programming language](<https://devfeed.tech/topics/programming-language.md>), [Maintainers](<https://devfeed.tech/topics/maintainers.md>), [Python](<https://devfeed.tech/topics/python.md>)

Tags: [compiler](<https://devfeed.tech/tags/compiler.md>), [debugger](<https://devfeed.tech/tags/debugger.md>), [google-summer-of-code](<https://devfeed.tech/tags/google-summer-of-code.md>), [programming](<https://devfeed.tech/tags/programming.md>), [rust](<https://devfeed.tech/tags/rust.md>), [spotlight](<https://devfeed.tech/tags/spotlight.md>)

### AI overview

Anthony Bolden's work has focused on making Rust debugging more usable on Windows, especially for programs built with MSVC. After Rust toolchains did not distribute debuginfo visualizers on Windows and compiler debuginfo tests did not work there, he contributed fixes and worked to improve the tests. He says the Rust build command worked on his first attempt, while trying to work with LLVM on Windows had been frustrating. His Google Summer of Code project improved compiler debuginfo testing; afterward, he joined the Rust compiler team. His planned work includes better visualizers for `Vec` and wide pointers, hashmap indexing, and performance improvements. He says proposed LLDB plugin interface changes might enable native Rust debugging integration, improved expression parsing, and possible miri integration. He also suggests shipping visualizers written in Rust. Bolden advises new Rust programmers to experiment and investigate compiler errors rather than focusing too early on best practices.

### Source excerpt

There are hundreds of people who maintain the Rust toolchain, often on a volunteer basis on top of another job. The Rust Content team is working on a series of blog posts highlighting some of these prolific contributors to recognize the awesome work that they are doing in order to make Rust better for everyone. You can find the previous post here. Consider donating to the Rust Foundation Maintainers Fund if you'd like to support Rust Project maintainers. In this post, we would like to introduce Anthony Bolden (@Walnut356). Anthony is a self-taught programmer who went on a mission to improve the Rust debugger experience. This year, he participated as a contributor in the Google Summer of Code program, and recently he joined the Rust compiler team. We interviewed Anthony to find out what brought him to programming and how he became an expert on debuggers. Read more below! Can you briefly introduce yourself and tell us how you started with programming? Hello, my name is Anthony Bolden, also known as @Walnut356, and I live in Wisconsin. I do not have any formal computer science education and I've never had a job in the tech industry, so my journey to programming was a bit different. I work overnight shifts in a hotel, where I often have a lot of time to spare, and I needed something to occupy my mind. For I while, I used to solve puzzles or read books, but eventually I got tired of that. I wanted to find a long-term project, so I tried programming. It took me a couple of tries until it "clicked", but when that happened, I instantly fell in love with it. It is so much fun! How did you discover Rust? I bought a couple of C++ books when I was learning how to program, so that was my entrypoint. But I was very dissatisfied with the development experience there. I wanted to make a simple game, because I've always found game design fascinating, but adding a dependency like SDL to my project turned out to be very difficult. I spent SO MUCH time trying to get it to work, and it

## DIFUZZI: A Differential Fuzzing Tool for Code Functional Similarity Assessment

DevFeed: [DIFUZZI: A Differential Fuzzing Tool for Code Functional Similarity Assessment](<https://devfeed.tech/articles/difuzzi-a-differential-fuzzing-tool-for-code-functional-similarity-assessment-107376.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.38337>)

Author: Simantika Bhattacharjee Dristi, Matthew B. Dwyer

Published: 2026-10-30T04:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [Tool](<https://devfeed.tech/topics/tool.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>)

Tags: [assessment](<https://devfeed.tech/tags/assessment.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [code](<https://devfeed.tech/tags/code.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [differential-fuzzing](<https://devfeed.tech/tags/differential-fuzzing.md>), [fuzzing](<https://devfeed.tech/tags/fuzzing.md>), [generator](<https://devfeed.tech/tags/generator.md>), [generators](<https://devfeed.tech/tags/generators.md>), [input](<https://devfeed.tech/tags/input.md>), [llm](<https://devfeed.tech/tags/llm.md>), [machine-learning](<https://devfeed.tech/tags/machine-learning.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [semantic](<https://devfeed.tech/tags/semantic.md>), [similarity](<https://devfeed.tech/tags/similarity.md>), [software](<https://devfeed.tech/tags/software.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [tool](<https://devfeed.tech/tags/tool.md>)

### AI overview

DIFUZZI aims to make differential fuzzing easier to apply for assessing functional similarity between programs. Differential fuzzing can compare program behavior at scale, but constructing suitable input generators for a pair of programs often requires substantial manual effort. DIFUZZI adds an LLM-based generator synthesis step that is iteratively validated and repaired. The abstract frames this as an alternative to formal equivalence approaches, which it says do not scale or quantify degrees of similarity, and machine-learning approximations, which can miss subtle semantic differences. The supplied text does not report evaluation results.

### Source excerpt

arXiv:2610.38337v1 Announce Type: new Abstract: A range of software engineering tasks, such as optimization and refactoring, seek to preserve the behavior of software components and require methods to assess functional similarity. Research has explored formal approaches to prove functional equivalence and used machine learning methods to approximate it, but the former does not scale and does not quantify the extent of similarity and the latter struggles when subtle semantic differences are present. Differential fuzzing offers a scalable approach for differencing programs semantically, but applying it often requires substantial manual effort to construct input generators that are well-suited to a target pair of programs. To address this challenge, we introduce DIFUZZI, which incorporates an LLM-based generator synthesis step that is iteratively validated and repaired. By automating this step, DIFUZZI paves the way for broader applicability of differential fuzzing. We release DIFUZZI at https://github.com/Dristi123/difuzzi_tool, with a demonstration video at https://youtu.be/FlHNOHuo9WE

## Learning to Formulate: Agentic Hardware-Software Co-Design of AI Infrastructure through Progressive Optimization and Verification

DevFeed: [Learning to Formulate: Agentic Hardware-Software Co-Design of AI Infrastructure through Progressive Optimization and Verification](<https://devfeed.tech/articles/learning-to-formulate-agentic-hardware-software-co-design-of-ai-infrastructure-through-progressive-optimization-and-verification-107584.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.39380>)

Author: Yi Ding, Li Shang

Published: 2026-10-30T04:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [AI Infrastructure](<https://devfeed.tech/topics/ai-infrastructure.md>), [Chip design](<https://devfeed.tech/topics/chip-design.md>), [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Optimization](<https://devfeed.tech/topics/optimization.md>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>), [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai-infrastructure](<https://devfeed.tech/tags/ai-infrastructure.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-ar](<https://devfeed.tech/tags/cs-ar.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [hardware-software-co-design](<https://devfeed.tech/tags/hardware-software-co-design.md>), [nvidia-gb10](<https://devfeed.tech/tags/nvidia-gb10.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [templates](<https://devfeed.tech/tags/templates.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

Formulaic uses an agent to progressively formulate hardware-software design problems, a mathematical solver to optimize within each formulation, and verification and measurement to check correctness and results. Its templates define program families and their correctness conditions; wall relaxation guides chip search by pricing hardware constraints that bind software. The paper reports separate studies, not one end-to-end run: on NVIDIA GB10, agent-written templates execute complete Qwen3-8B layers 1.075x faster than SGLang; in a simulated Ventus GPU study, joint design reduces worst-scenario Qwen2.5-0.5B cycles to 0.428 of the reference, compared with 0.934 for software-only optimization; and proof reuse makes checking a five-step GEMM refinement chain 2.51x faster.

### Source excerpt

arXiv:2610.39380v1 Announce Type: cross Abstract: AI infrastructure, the chips and software that train and serve AI models, is designed in layers. Layers make the system manageable, but they also fix which choices an optimizer can consider. Gains that need the chip and its software to change together are excluded before optimization begins: the formulation leaves them out. Language-model agents make it possible to revisit these boundaries, but an agent's proposal cannot show by itself that a design is correct or optimal. We present Formulaic, a flow that divides the work. The agent writes the formulation, a mathematical solver optimizes within it, and verification and measurement check its assumptions and results. The agent refines the problem step by step, from the computation graph toward the chip. Each step is a template: a family of programs with the conditions under which they are correct. Wall relaxation searches the chip by pricing the hardware limits that bind the software. This paper takes a first step, through separate studies rather than one end-to-end run. On NVIDIA GB10, templates the agent wrote run complete Qwen3-8B layers $1.075\times$ faster than SGLang. In a simulated Ventus GPU study, joint design cuts the worst-scenario cycles of Qwen2.5-0.5B to 0.428 of the reference, against 0.934 for software alone. On a five-step GEMM refinement chain, reusing proofs makes checking $2.51\times$ faster.

[Next page](<https://devfeed.tech/topics/programming-languages-compilers.md?cursor=WyIyMDI2LTEwLTMwVDA0OjAwOjAwKzAwOjAwIiwgIjJkZDA4NTg0LWY1ZjMtNDA5OC05YjdkLTYwZDNmYWE1YTEyYiJd>)