AX·NEWS
Sign in

Software Engineering

Software Engineering news — Wednesday 30 September 2026

140 stories from 6 sources, every one in English. Each links to its publisher.

Open in the live feedRSS feedOn a TV

  1. 56k.rip – the 1996 dial-up internet experience
    USHacker News Front Page

    Article URL: https://56k.rip/ Comments URL: https://news.ycombinator.com/item?id=49915126 Points: 232 # Comments: 94

  2. EDG C/C++ Compiler Project
    USlobste.rs

    During the 2025 November C++ ISO meeting Edison Design Group announced that they would be winding down and that they will open-source their front end . This is the repo containing said front end along with some other components like C and…

  3. The top secret URSALA, RAQUEL, and FARRAH satellites
    USHacker News Front Page

    Article URL: https://www.thespacereview.com/article/4951/1 Comments URL: https://news.ycombinator.com/item?id=49915082 Points: 287 # Comments: 149

  4. We used a database as a message queue. Now we use Kafka
    USlobste.rs

    Comments

  5. Gemini 4 Argon
    USHacker News Front Page

    See also: Gemini 4 Argon (High): Intelligence, Performance and Price Analysis - https://news.ycombinator.com/item?id=49914236 Comments URL: https://news.ycombinator.com/item?id=49913571 Points: 1593 # Comments: 1061

  6. Finding Bugs
    USlobste.rs

    Comments

  7. Halfspace experimental IDE for solid modeling with distance fields
    USHacker News Front Page

    Article URL: https://www.mattkeeter.com/projects/halfspace/ Comments URL: https://news.ycombinator.com/item?id=49913350 Points: 176 # Comments: 10

  8. EDG C++ front-end goes public
    USHacker News Front Page

    https://github.com/edgcpp/compiler Comments URL: https://news.ycombinator.com/item?id=49913192 Points: 231 # Comments: 112

  9. Surprisingly complex waves reveal the brain's inner workings
    USHacker News Front Page

    Article URL: https://www.quantamagazine.org/surprisingly-complex-waves-reveal-the-brains-inner-workings-20260930/ Comments URL: https://news.ycombinator.com/item?id=49912955 Points: 238 # Comments: 92

  10. Software occlusion culling in Block Game
    USlobste.rs

    Comments

  11. Before pixels: Modular industrial dashboards
    USHacker News Front Page

    Article URL: https://unsung.aresluna.org/before-pixels-modular-industrial-dashboards/ Comments URL: https://news.ycombinator.com/item?id=49912792 Points: 265 # Comments: 47

  12. 5x faster Edge Functions: V8 isolates to Firecracker MicroVMs
    USHacker News Front Page

    Article URL: https://www.netlify.com/blog/edge-functions-firecracker-microvms/ Comments URL: https://news.ycombinator.com/item?id=49912444 Points: 216 # Comments: 94

  13. Branch Target Reuse: Spectre-v2 Attacks in JIT Engines
    USlobste.rs

    Comments

  14. Launch HN: Magnitude (YC S25) – Self-optimizing inference engine for agents
    USHacker News Front Page

    Hey HN, Anders and Tom here. We're building Magnitude, an inference engine for agents that optimizes itself to run as fast as possible on your hardware. It works on Mac, Linux, and Windows on any hardware and is up to 2x faster than…

  15. Qt 6.12 LTS Released
    USlobste.rs

    Comments

  16. Songhive — A fully self-hosted and federated music platform
    USlobste.rs

    What if your music server had a social network attached, and your social network could play music? Comments

  17. Organizations need decision-grade knowledge. AI makes it urgent.
    USStack Overflow Blog

    AI can make the first part remarkably fast. It can find the page, the discussion and the person who might know. The harder work begins when those sources disagree, or when they become stale.

  18. Another Look at Provable Security
    USlobste.rs

    Comments

  19. Anyone can start building verified knowledge with Stack Internal
    USStack Overflow Blog

    Stack Internal transforms your daily work into a living memory that’s shared with the rest of your team. Now anyone can create and share their knowledge in a Stack Internal workspace for free by visiting stackinternal.com.

  20. Hanami, Why?: Introductions
    USlobste.rs

    Comments

  21. cp: -r or -R?
    USHacker News Front Page

    Article URL: https://movq.de/blog/postings/2026-09-30/0/POSTING-en.html Comments URL: https://news.ycombinator.com/item?id=49910465 Points: 111 # Comments: 103

  22. So you think you could be an electrician?
    USHacker News Front Page

    Article URL: https://asteriskmag.com/issues/15/so-you-think-you-could-be-an-electrician Comments URL: https://news.ycombinator.com/item?id=49910462 Points: 420 # Comments: 364

  23. Tcl/Tk 9.1
    USlobste.rs

    Comments

  24. A brief history of the Bloomberg terminal
    USHacker News Front Page

    Article URL: https://spectrum.ieee.org/bloomberg-terminal Comments URL: https://news.ycombinator.com/item?id=49909583 Points: 362 # Comments: 153

  25. Q2 2026 Backblaze Drive Stats: Hard Drive Failure Rates
    USlobste.rs

    Comments

  26. What TLA+ can and can't check
    USlobste.rs

    Comments

  27. Getting ready for 2026 results: A look back on Developer Survey findings
    USStack Overflow Blog
  28. What TLA+ can and can't check
    USHacker News Front Page

    Article URL: https://buttondown.com/hillelwayne/archive/what-tla-can-and-cant-check/ Comments URL: https://news.ycombinator.com/item?id=49909056 Points: 215 # Comments: 47

  29. SDF vs. MSDF vs. Slug: GPU Text Rendering
    USHacker News Front Page

    Article URL: https://alphapixeldev.com/sdf-vs-msdf-vs-slug-vs-rive-gpu-text-rendering/ Comments URL: https://news.ycombinator.com/item?id=49908962 Points: 141 # Comments: 54

  30. Turbo Haskell
    USlobste.rs

    Comments

  31. Under Autumn’s Spell (October 2026 Wallpapers Edition)
    DESmashing Magazine

    Misty mornings, leaves shining in bright red, yellow, and orange hues , and spooky creatures making an appearance — October has a very special charm. So, how about some new desktop wallpapers to celebrate October’s beauty, and the upcoming…

  32. The last time my family was replaced by technology
    USHacker News Front Page

    Article URL: https://manuel.darcemont.fr/posts/the-last-time-my-family-was-replaced-by-technology/ Comments URL: https://news.ycombinator.com/item?id=49908394 Points: 294 # Comments: 576

  33. Back to Backups: A Year in Review
    USlobste.rs

    Comments

  34. Differences between `foldl` and `foldr`
    USlobste.rs

    Comments

  35. attezt: device attestation, PKCS11 and ACME
    USlobste.rs

    Comments

  36. Dumb Servers, Smart Clients: Distributing Images with Quarry
    USlobste.rs

    Comments

  37. A no-cost audio upgrade for my workstation
    USlobste.rs

    Comments

  38. snowdesktop: Immutable Debian desktop for developers
    USlobste.rs

    Comments

  39. Join Ordering, Part 1: The Shape of the Search Space
    USlobste.rs

    Comments

  40. State of Devs 2026
    USlobste.rs

    Comments

  41. Most data centers refusing to say how much water, electricity they use
    USHacker News Front Page

    Article URL: https://nltimes.nl/2026/09/30/data-centers-refusing-say-much-water-electricity-use Comments URL: https://news.ycombinator.com/item?id=49907057 Points: 137 # Comments: 143

  42. Pi.dev: You Said No MCP
    USHacker News Front Page

    Article URL: https://earendil.com/posts/you-said-no-mcp/ Comments URL: https://news.ycombinator.com/item?id=49906637 Points: 607 # Comments: 336

  43. Coding is not solved
    USlobste.rs

    Comments

  44. Singapore govt dating app uses Gale-Shapley stable marriage algorithm
    USHacker News Front Page

    Related: https://www.bbc.com/news/articles/cqzjzr893yv4o Comments URL: https://news.ycombinator.com/item?id=49906432 Points: 280 # Comments: 203

  45. The Cuckoo's Egg (book) - Wikipedia
    USlobste.rs

    Comments

  46. OpenDLSS: A Vulkan Reimplementation of Nvidia's DLSS 5 Neural Rendering Network
    USHacker News Front Page

    Article URL: https://github.com/maanHimself/OpenDLSS-NR Comments URL: https://news.ycombinator.com/item?id=49906100 Points: 245 # Comments: 114

  47. OpenBSD's ports tree keeps GPL coreutils and rejects uutils (Rust rewrite)
    USlobste.rs

    A contributor proposed a new OpenBSD port for uutils, the Rust reimplementations of GNU coreutils. The proposal met firm resistance: Stuart Henderson called it unusable, explaining that GNU coreutils exists mainly to stabilize…

  48. Doing a Machine Learning PhD While Working in Japan
    USHacker News Front Page

    Article URL: https://www.tokyodev.com/articles/doing-a-machine-learning-phd-while-working-in-japan Comments URL: https://news.ycombinator.com/item?id=49905644 Points: 126 # Comments: 41

  49. Why Is Sam Altman a Free Man?
    USHacker News Front Page

    Article URL: https://prospect.org/2026/09/29/artificial-intelligence-agents-openai-microsoft-sam-altman-greg-brockman-ah-nice/ Comments URL: https://news.ycombinator.com/item?id=49905633 Points: 151 # Comments: 96

  50. September 2026: The world today, as seen by one Polish guy
    USHacker News Front Page

    Article URL: https://tomwojcik.com/posts/2026-09-21/september-2026-the-world-today/ Comments URL: https://news.ycombinator.com/item?id=49905487 Points: 441 # Comments: 319

  51. Dirty Optimization Secrets (C for Playdate)
    USlobste.rs

    Comments

  52. LinkedIn Larpmaxxing
    USHacker News Front Page

    Article URL: https://hereticpleb.vercel.app/blog/linkedin-larpmaxxing/ Comments URL: https://news.ycombinator.com/item?id=49904314 Points: 258 # Comments: 220

  53. Fake Express Packages on npm Spread a Linux Worm
    USlobste.rs

    Comments

  54. Retrieve, Reproduce, Reveal: Dissecting Retrieval-Augmented Software Vulnerability Detection
    USarXiv cs.SE (Software)

    arXiv:2609.37669v1 Announce Type: new Abstract: Retrieval-Augmented Generation (RAG) is increasingly used to enhance Large Language Model (LLM)-based software vulnerability detection by grounding predictions in retrieved vulnerability…

  55. Irene: Equivalence Checking of Hybrid Quantum Programs via Structure-Preserving Symbolic Reduction
    USarXiv cs.SE (Software)

    arXiv:2609.36065v1 Announce Type: cross Abstract: Equivalence checking is essential for validating compiler transformations of hybrid quantum programs, which combine quantum operations, measurements, and classical control…

  56. Can Agents Design Libraries for Agents?
    USarXiv cs.SE (Software)

    arXiv:2609.36730v1 Announce Type: cross Abstract: Agents increasingly build on code written by other agents, and they reimplement rather than reuse, growing the codebases later agents must work in. To measure how well agents design…

  57. Bridging User Feedback and System Diagnosis: Reproducing Mobile Performance Issues from Reviews
    USarXiv cs.SE (Software)

    arXiv:2508.11147v3 Announce Type: replace Abstract: Mobile application performance is a vital factor for user experience. Yet, performance issues are notoriously difficult to detect in development environments, where they often manifest…

  58. HEDGEHOG: Hierarchical Evaluation of Drug Generators Through Rigorous Filtration
    USarXiv cs.SE (Software)

    arXiv:2607.13155v2 Announce Type: replace-cross Abstract: Generative molecular models can support early drug discovery by proposing new candidate compounds de novo. In practice, useful candidates must balance target-relevant activity…

  59. Multi-Mode Debugging for FRP-Based Embedded Systems
    USarXiv cs.PL (Programming)

    arXiv:2608.04264v2 Announce Type: replace Abstract: Emfrp is a functional reactive programming (FRP) language designed for small-scale embedded systems. Time-varying values are the primary abstraction mechanism in FRP and enable concise…

  60. Agent-Callable Feature Coverage: Measuring Software Readiness for AI Agents
    USarXiv cs.SE (Software)

    arXiv:2609.35789v1 Announce Type: new Abstract: AI agents already operate graphical software through screenshot-based computer use, so the pressing question is not whether agents can operate software, but how well software supports them…

  61. Automated Evaluation of Multi-Turn Dialogues in In-Car Conversational Assistants
    USarXiv cs.SE (Software)

    arXiv:2609.35812v1 Announce Type: cross Abstract: In-car conversational assistants (ICAs) are increasingly integrated into vehicles to support route planning, vehicle control, and information access. Ensuring their reliability is…

  62. LatentSift: Policy-State Filtering for Token-Efficient Verification of Software Engineering Agents
    USarXiv cs.SE (Software)

    arXiv:2609.36371v1 Announce Type: new Abstract: Test-time scaling improves software engineering agents by generating multiple candidate trajectories and selecting the best one. Verifying and selecting among these long interactions can…

  63. From Dead Code and Static Requirements to Working Engines: Software Revival with Coding Agents
    USarXiv cs.SE (Software)

    arXiv:2609.36161v1 Announce Type: new Abstract: Can coding agents restore software that no longer runs while preserving its underlying methods, and reconstruct industrial software engines from open specifications? Here we introduce…

  64. Assay: Claims That Decay With the Code. Content-Addressed Evidence Graphs for Accountable AI-Assisted Software Delivery
    USarXiv cs.SE (Software)

    arXiv:2609.36170v1 Announce Type: new Abstract: AI coding agents fail in two coupled ways. They spend most of their context window rediscovering where things live, and they assert success without evidence when the work gets hard…

  65. Do Agent Benchmarks Do What They Say? An Executable-Contract Audit of Tool-Using Agent Environments
    USarXiv cs.SE (Software)

    arXiv:2609.37315v1 Announce Type: new Abstract: Tool-using agents are entering settings where a wrong action carries real cost, and the benchmarks certifying them grade what each simulated tool call reports having done, assuming the tool…

  66. Exploring Emotional Intelligence in Software Testing
    USarXiv cs.SE (Software)

    arXiv:2609.37526v1 Announce Type: new Abstract: Background: Emotional Intelligence (EI) is the ability to recognise, understand, and manage one's own and others' emotions. Software testers deliver judgements about colleagues' work under…

  67. VeriWeave Govern: Evidence-Gated Deterministic Runtime Governance for Enterprise AI Agents
    USarXiv cs.SE (Software)

    arXiv:2609.37457v1 Announce Type: cross Abstract: Enterprise artificial-intelligence agents increasingly call tools, modify infrastructure, and process protected data, creating a need to separate action generation from action…

  68. A Function-level Dataset of Vulnerable and Fixed Source Code in JavaScript and TypeScript
    USarXiv cs.SE (Software)

    arXiv:2609.38012v1 Announce Type: cross Abstract: JavaScript and TypeScript are widely used in modern web development, making their security critical; however, automated vulnerability detection is often constrained by the availability of…

  69. PlayCoder: Making LLM-Generated GUI Code Playable
    USarXiv cs.SE (Software)

    arXiv:2604.19742v2 Announce Type: replace Abstract: Large language models (LLMs) have achieved strong results in code generation, but their ability to generate GUI applications, especially games, remains insufficiently studied. Existing…

  70. Code Lifespan Survival Analysis (CLSA): Predicting the Survival of Source Code Lines Using AST-Aware Mining
    USarXiv cs.SE (Software)

    arXiv:2606.04993v4 Announce Type: replace Abstract: Context: Predicting which source lines will be deleted - and when - matters for maintenance and review prioritization. Existing MSR approaches work at file or method granularity, masking…

  71. Relic: From Multi-Agent Collaboration to Persistent Organizational Capability
    USarXiv cs.SE (Software)

    arXiv:2609.32965v2 Announce Type: replace-cross Abstract: Multiple agents may often conflict in an organization: for example, one coding agent changes an interface in a repository, but another continues to develop on the old version where…

  72. Root-Cause Attribution Is a Search Problem: Continual Search for Long-Horizon Agent Failures
    USarXiv cs.SE (Software)

    arXiv:2609.13463v2 Announce Type: replace-cross Abstract: The increasing deployment of AI agents in long-horizon tasks yields massive execution logs. Diagnosing failures within these records is crucial for reliability, as it transforms…

  73. The Complexity Kink: A Prompt-Side Structural Complexity Index for Code-Generation Reliability
    USarXiv cs.SE (Software)

    arXiv:2609.19616v2 Announce Type: replace-cross Abstract: Complexity measured from generated code is failure-dependent: a difficult prompt can yield a short failing program and be assigned low output complexity. We introduce a…

  74. ASCEND: Personal AI Agents for Autonomous Scientific Computing Across HPC Clusters and GPU Workstations
    USarXiv cs.SE (Software)

    arXiv:2609.32868v2 Announce Type: replace-cross Abstract: Traditional scientific computing requires researchers to translate computational intent into environment configuration, resource requests, and executable jobs, then diagnose…

  75. A Leakage-Safe, Cost-Aware Regression Testing Methodology for the Quantum Transpiler
    USarXiv cs.SE (Software)

    arXiv:2609.35834v1 Announce Type: new Abstract: Quantum SDKs such as Qiskit are revised continually, and a single transpiler-pass change can introduce a software regression, so continuous integration (CI) must select and prioritize tests…

  76. PoliVEM: a Python-driven virtual element framework for computational solid mechanics
    USarXiv cs.SE (Software)

    arXiv:2609.35878v1 Announce Type: new Abstract: This work presents PoliVEM, a software framework for the Virtual Element Method (VEM) in computational solid and structural mechanics. A C++17 computational core and a Python interface place…

  77. The Artifact Promotion Control Model: An Implementation Case Study. Build on Target Machines vs. Build Once and Promote Artifacts
    USarXiv cs.SE (Software)

    arXiv:2609.35891v1 Announce Type: new Abstract: Artifact promotion means building the software once and moving that same built copy through the test and production environments, instead of building it again on each server. A previous…

  78. XRepoSkill: Learning Transferable Skills for Software Engineering Agents
    USarXiv cs.SE (Software)

    arXiv:2609.36807v1 Announce Type: new Abstract: Software engineering agents increasingly use reusable skills distilled from prior experience to resolve repository-level issues, yet such skills often fail to transfer across repositories. A…

  79. CodeNib: A Multi-View Data System for Serving Repository Context to Coding Agents
    USarXiv cs.SE (Software)

    arXiv:2607.25431v2 Announce Type: replace Abstract: An incremental code index can complete every update without error and still return the wrong graph half the time. Coding agents depend on such reused views for search and navigation, yet…

  80. ORCA-bench: How Ready Are Language Model Agents for Oncall?
    USarXiv cs.SE (Software)

    arXiv:2607.28545v3 Announce Type: replace-cross Abstract: Large language models can write, patch, and search code, but oncall root cause analysis (RCA) demands something different: reasoning over noisy metrics, logs, traces, and source…

  81. Evaluating System One Models for Agent Security Decisions: Reliability, Calibration, and Selective Automation
    USarXiv cs.SE (Software)

    arXiv:2609.33401v2 Announce Type: replace-cross Abstract: Model-based judges support agent security by detecting prompt injections, assessing interaction risks, and screening harmful requests. System One models select from predefined…

  82. Evaluating AGENTS.md: Are Repository-Level Context Files Helpful for Coding Agents?
    USarXiv cs.SE (Software)

    arXiv:2602.11988v3 Announce Type: replace Abstract: A widespread practice in software development is to tailor coding agents to repositories using context files, such as AGENTS.md. Although this practice is strongly encouraged by agent…

  83. Active-SWE: Benchmarking Coding Agents for Proactive Bug Fixing without Issue Reports
    USarXiv cs.SE (Software)

    arXiv:2608.04682v2 Announce Type: replace Abstract: Coding agents powered by large language models (LLMs) are increasingly adopted in software engineering (SWE) scenarios, capable of fixing a specific bug in large-scale codebase. However…

  84. The reach of a verification tool decides its value: A controlled study of verification surface, artifact quality, and cost in AI coding agents
    USarXiv cs.SE (Software)

    arXiv:2608.28795v2 Announce Type: replace Abstract: Modern artificial-intelligence coding agents can be equipped with tools for checking their own work e.g. a linter, a boot probe, a shell, a screenshot tool. We call this set the agent's…

  85. CIRCLE: A Framework for Evaluating AI from a Real-World Lens
    USarXiv cs.SE (Software)

    arXiv:2602.24055v5 Announce Type: replace-cross Abstract: This study proposes CIRCLE, a six-stage, lifecycle-based framework to bridge the reality gap between model-centric performance metrics and AI system outcomes in deployment. Current…

  86. Low Reasoning Effort Is Enough for Routine Office Work by Language-Model Agents
    USarXiv cs.SE (Software)

    arXiv:2608.03169v2 Announce Type: replace-cross Abstract: Purpose: Developers choose how much a language-model agent reasons before it acts. Some pick a high level for fear that a low one is not enough, and pay for it in tokens, time and…

  87. CTE-Bench: Counterfactual Trace Evaluation for Stateful Software Simulators
    USarXiv cs.SE (Software)

    arXiv:2609.36647v1 Announce Type: new Abstract: Coding agents change running software: they patch a service's code or overwrite its stored state, and then act on their own expectation of how the service will respond afterwards. A wrong…

  88. Cross-Organizational SysML Model Integration: A Survey of Challenges and AI-Supported Tasks
    USarXiv cs.SE (Software)

    arXiv:2609.37000v1 Announce Type: new Abstract: Cross-organizational collaboration is widely regarded as a key promise of SysML-based Model-Based Systems Engineering (MBSE), yet practitioners still face persistent challenges when…

  89. LoLBench: Evaluating Coding Agents with Long-Horizon Proposals on Large Software Systems
    USarXiv cs.SE (Software)

    arXiv:2609.37143v1 Announce Type: new Abstract: Modern coding agents can deliver increasingly large repository-level changes, and recent benchmarks reflect this by emphasizing long-horizon tasks with large reference implementations. Many…

  90. Multi-Mode Debugging for FRP-Based Embedded Systems
    USarXiv cs.SE (Software)

    arXiv:2608.04264v2 Announce Type: replace-cross Abstract: Emfrp is a functional reactive programming (FRP) language designed for small-scale embedded systems. Time-varying values are the primary abstraction mechanism in FRP and enable…

  91. AgentBug-Smith: Automatically Reproducing Real-World Harness Bugs in Agentic Systems
    USarXiv cs.SE (Software)

    arXiv:2609.37864v1 Announce Type: new Abstract: Agent harness bugs exhibit unique characteristics and remain challenging for state-of-the-art software agents to repair. Progress in this area is further hindered by existing benchmarks…

  92. Evaluating Name-Only Directory Routing for One-Shot Code Search
    USarXiv cs.SE (Software)

    arXiv:2609.35918v1 Announce Type: new Abstract: Finding the right files is an early challenge for coding agents. We test whether a language model can follow directory and file names to find annotated code files missed by fixed lexical…

  93. SIGIL: Skill Compilation for Reliable and Efficient Agent Execution
    USarXiv cs.SE (Software)

    arXiv:2607.27309v3 Announce Type: replace Abstract: Agent skills describe reusable procedures, but runtime models must still interpret their instructions and coordinate execution. We introduce Skill Compilation, which translates the…

  94. The Invisible Throttle: Running on Borrowed Time in Scratch
    USarXiv cs.SE (Software)

    arXiv:2609.36152v1 Announce Type: new Abstract: Scratch has 135 million registered users, most of them children, and 164 million shared projects. What they are taught about the speed of a script fits in one sentence: a loop iterates once…

  95. Is Agent Code Less Maintainable Than Human Code?
    USarXiv cs.SE (Software)

    arXiv:2606.21804v2 Announce Type: replace Abstract: Maintainability is a core dimension of software engineering, shaping how code is written, reviewed, and developed over time. While coding agents have demonstrated strong performance on…

  96. CURATE: Leveraging LLM Agents to Compose, Catalog, and Deploy Reproducible Workflows
    USarXiv cs.SE (Software)

    arXiv:2608.04270v2 Announce Type: replace Abstract: Agentic code generation has the potential to accelerate the development of computational workflows while also reducing barriers to entry. However, a key gap remains: existing coding…

  97. Counterfactual Rollout Replay: Forkable Environments as Free Process Rewards for Software Engineering Agents
    USarXiv cs.SE (Software)

    arXiv:2609.33875v2 Announce Type: replace Abstract: Outcome-only reinforcement learning gives software engineering (SWE) agents a terminal success signal but little direct guidance about intermediate decisions. We introduce Counterfactual…

  98. Lookahead-R: Budget-Aware Tool Retrieval via Execution-Centric Planning
    USarXiv cs.SE (Software)

    arXiv:2609.35811v1 Announce Type: cross Abstract: Tool retrieval is a critical bottleneck for LLM-based agents operating over large, heterogeneous API ecosystems. Existing approaches face an inherent trade-off: semantic retrievers are fast…

  99. When Does Correction Become Repair? Mechanistic Auditing of Internal Interventions in Tool-Using LLMs
    USarXiv cs.SE (Software)

    arXiv:2609.36138v1 Announce Type: cross Abstract: Before invoking external tools, an agentic LLM must select among a K-way action space: executing a call, seeking clarification, answering directly, or declining. While internal activation…

  100. Remember Your Trace: Memory-Guided Long-Horizon Agentic Framework for Consistent and Hierarchical Repository-Level Code Documentation
    USarXiv cs.SE (Software)

    arXiv:2605.14563v3 Announce Type: replace Abstract: Automated code documentation is essential for modern software development, providing the contextual grounding that both human developers and coding agents rely on to navigate large…

  101. Profiling the Energy Consumption of Serverless Functions with Joule Profiler
    USarXiv cs.SE (Software)

    arXiv:2609.37531v1 Announce Type: new Abstract: Cloud providers and customers have widely adopted serverless computing as a convenient paradigm for deploying and executing functions on demand. To do so, serverless platforms require…

  102. Beyond Productivity: Measuring Developers' Cognitive Load During GenAI-Supported Software Development
    USarXiv cs.SE (Software)

    arXiv:2609.37645v1 Announce Type: new Abstract: Generative AI (GenAI) is changing software development workflows and how developers work. Industry evaluations of GenAI adoption often monitor productivity gains, usage, and output quality…

  103. Is manual software optimization a thing of the past?
    USarXiv cs.SE (Software)

    arXiv:2609.37849v1 Announce Type: new Abstract: Scientific software is increasingly required to process larger datasets while maintaining acceptable execution times. Software optimization traditionally requires substantial expertise in…

  104. Merged, Not Measured: An Empirical Study of Performance Issues Fixed by Coding Agents
    USarXiv cs.SE (Software)

    arXiv:2609.37985v1 Announce Type: new Abstract: Coding agents open pull requests (PRs) that claim to speed up software, but studies of human performance fixes say little about how maintainers respond to such a fix or whether its claim…

  105. How Much Prompt Is Enough? A Blackbox Minimization of Few-Shots in LLMs
    USarXiv cs.SE (Software)

    arXiv:2609.36289v1 Announce Type: new Abstract: Prompts are the primary mechanism for directing the behavior of large language models (LLMs). Yet the internal structure and causal hierarchy of prompts remain poorly understood: which parts…

  106. Independent Verification Paths Are Not Independent: A Case Study of Common-Mode Failure in a Satellite Catalogue Pipeline
    USarXiv cs.SE (Software)

    arXiv:2609.37603v1 Announce Type: new Abstract: A common safeguard for a data pipeline is redundant computation: derive each published number by two routes built on different technology and refuse to exit when they disagree. We report one…

  107. More Programs or More Rolls? Separating Coverage from Specialization in LLM Harnesses
    USarXiv cs.SE (Software)

    arXiv:2609.35873v1 Announce Type: cross Abstract: Automated generation of LLM harnesses promises to improve inference through task specialization. Yet additional answer coverage can arise from repeated execution of the same program, making…

  108. TokenCast: Forecasting Token Consumption During LLM Agent Execution
    USarXiv cs.SE (Software)

    arXiv:2609.35760v2 Announce Type: replace-cross Abstract: When a large language model (LLM) agent executes the same task, token consumption can vary by over an order of magnitude across runs. The agent chooses its next steps based on tool…

  109. Towards an AI Software Factory for Data Systems
    USarXiv cs.SE (Software)

    arXiv:2609.36323v1 Announce Type: cross Abstract: AI-assisted coding tools deliver significant acceleration of coding, but only limited impact across the end-to-end software development lifecycle (SDLC)--an Amdahl's law effect! In this…

  110. The Editor Has Read-Only Access: Correctness Signals in Diffusion Language Models
    USarXiv cs.SE (Software)

    arXiv:2609.36783v1 Announce Type: new Abstract: Diffusion language models generate code by repeatedly updating a partially masked sequence. We ask whether their internal activations encode code correctness and whether that information can…

  111. Complexity-Aware Evaluation of LLM Comprehension
    USarXiv cs.SE (Software)

    arXiv:2609.37405v1 Announce Type: new Abstract: Large language models (LLMs) are increasingly used for software engineering tasks that require understanding existing source code, including behavior prediction, function explanation…

  112. Efficient Extraction for Effectful E-Graphs
    USarXiv cs.PL (Programming)

    arXiv:2609.31887v2 Announce Type: replace Abstract: Egraphs have enabled recent advances in program optimization, synthesis, and verification, yet remain difficult to apply to effectful programs whose memory and I/O operations must respect…

  113. Irene: Equivalence Checking of Hybrid Quantum Programs via Structure-Preserving Symbolic Reduction
    USarXiv cs.PL (Programming)

    arXiv:2609.36065v1 Announce Type: new Abstract: Equivalence checking is essential for validating compiler transformations of hybrid quantum programs, which combine quantum operations, measurements, and classical control…

  114. DatalogBench: Evaluating Large Language Models on Text-to-Datalog Synthesis
    USarXiv cs.PL (Programming)

    arXiv:2609.37233v1 Announce Type: new Abstract: Datalog underpins reasoning tasks such as program analysis, but its programs are hard to write. Existing synthesizers automate this task but require users to state their intent as…

  115. A programming language combining quantum and classical control
    USarXiv cs.PL (Programming)

    arXiv:2511.22537v2 Announce Type: replace-cross Abstract: The two main notions of control in quantum programming languages are often referred to as "quantum control" and "classical control". With the latter, the control flow is based on…

  116. Modelling Shared-Space Coordination in mCRL2: a Bach-to-mCRL2 Translation Framework
    USarXiv cs.PL (Programming)

    arXiv:2609.37726v1 Announce Type: cross Abstract: Although significant research has focused on the theory and implementation of data-based coordination languages, the critical aspect of their automated verification using model-checking…

  117. GitCF: Reducing Incomplete Changes by Exploiting Multiple Similarities Among Commits
    USarXiv cs.SE (Software)

    arXiv:2609.37045v1 Announce Type: new Abstract: Software developers often struggle to identify all locations that their changes affect, and incomplete changes frequently result from these omissions. To mitigate this problem, several…

  118. SCOUT: Synergizing Reasoning and Tool-Use for Computer-Use Safety
    USarXiv cs.SE (Software)

    arXiv:2609.36201v1 Announce Type: cross Abstract: Computer-use agents (CUAs), while capable of completing computer tasks in everyday and professional workflows, can cause unintended harm even under benign instructions and environments…

  119. UNBIND: UNlearning By INference-time Directional Steering for Code LLMs
    USarXiv cs.SE (Software)

    arXiv:2609.35913v1 Announce Type: new Abstract: Code large language models acquire programming capabilities from large code corpora, but can also memorize implementations that later require removal. Code unlearning is needed to control…

  120. SafeLLM4SE: Statistical Evaluation and Reporting for LLM-based Software Engineering Systems
    USarXiv cs.SE (Software)

    arXiv:2609.37294v1 Announce Type: new Abstract: Large language models (LLMs) are increasingly used for software engineering tasks, yet their stochastic behavior challenges the validity, reproducibility, and comparability of their…

  121. Mechanised operational semantics of Rowhammer
    USarXiv cs.PL (Programming)

    arXiv:2607.10314v2 Announce Type: replace Abstract: Rowhammer is a hardware vulnerability in dynamic random-access memory (DRAM) in which repeated accesses to aggressor rows can induce bit-flips in victim rows. This phenomenon violates a…

  122. MCP Error Messages Written for Developers Hurt the Most Capable Agents Most
    USarXiv cs.SE (Software)

    arXiv:2609.35381v2 Announce Type: replace Abstract: Many Model Context Protocol (MCP) servers wrap web APIs built for human developers, and their error messages tell the reader to run a command, edit a configuration, open a web page or…

  123. Strategies for Deploying AI Agents in Production at Scientific User Facilities
    USarXiv cs.SE (Software)

    arXiv:2609.36362v1 Announce Type: new Abstract: Agentic artificial intelligence (AI) is moving beyond research demonstrations toward production use at scientific user facilities, including light sources, neutron sources, nanoscience…

  124. CRJudgeBench: Can AI Detect Plausible but Invalid Code Reviews?
    USarXiv cs.SE (Software)

    arXiv:2609.37216v1 Announce Type: new Abstract: Large language models can generate plausible code-review comments, but such comments may contain technically incorrect claims that mislead developers. We study technical trustworthiness…

  125. Formal Reasoning about Performance Models
    USarXiv cs.PL (Programming)

    arXiv:2609.37728v1 Announce Type: cross Abstract: Discrete-event simulation is a standard technique for modelling and analysing the performance of computer systems, networks, and services. Although simulation tools are widely used…

  126. WitnessGym: Benchmarking Coding Agents on the Construction of Bug Witnesses
    USarXiv cs.SE (Software)

    arXiv:2609.36635v1 Announce Type: new Abstract: Bug validation asks a coding agent to produce an executable witness for a reported bug. The witness combines a concrete input with a testing harness and exposes faulty behavior during…

  127. Mubric: Mutation Testing-Guided Rubric Generation for LLM Evaluation
    USarXiv cs.SE (Software)

    arXiv:2609.37322v1 Announce Type: cross Abstract: Rubric-based evaluation is widely used to assess LLM-based systems by decomposing response quality into task-specific scoring criteria. However, automatically generating rubrics that…

  128. Poking Around in the Dark: Why a Shared Understanding of Components Matters
    USarXiv cs.SE (Software)

    arXiv:2606.02442v3 Announce Type: replace Abstract: By listing the components included in an application, Software Bills of Materials (SBOMs) are intended to support the timely identification of vulnerable components and ensure the…

  129. GitHarness: Git Init Your Harness Working Memory for Perpetual User Requirements
    USarXiv cs.SE (Software)

    arXiv:2609.36789v1 Announce Type: cross Abstract: LLM-based agents increasingly collaborate with users on long-horizon tasks, accumulating evidence, code, and drafts through extensive search, reasoning, and execution. As users inspect…

  130. The Uneven Decline of Collective Knowledge Production: Evidence from Stack Overflow After Generative AI
    USarXiv cs.SE (Software)

    arXiv:2609.36069v1 Announce Type: new Abstract: Generative AI (Gen AI) is reshaping how individuals learn and work, but its consequences for collective knowledge, the shared body of knowledge that online communities produce together…

  131. After the Fix: Transfer of Corrected Agent Experience
    USarXiv cs.SE (Software)

    arXiv:2609.34603v2 Announce Type: replace-cross Abstract: Does repairing an episode make its experience a better memory for the next task? We transfer the same failed source before and after accepted repair to a fixed target, alongside…

  132. The Invisible Scheduler: Dragging a Sprite Can Change What a Scratch Program Does
    USarXiv cs.SE (Software)

    arXiv:2609.36147v1 Announce Type: new Abstract: Tens of millions of children program in Scratch, whose programs are concurrent: when the green flag is clicked, every sprite's scripts start together and share the project's state. Which…

  133. Beyond Rule-Based Mutation Testing: Test-Aware Mutant Generation Using Large Language Models
    USarXiv cs.SE (Software)

    arXiv:2609.35841v1 Announce Type: new Abstract: Mutation testing evaluates test-suite adequacy by injecting synthetic faults into program code. However, traditional rule-based tools often generate large numbers of trivial, redundant, or…

  134. Live Architecture Models for Cloud-Native Architecture-as-Code: Early Results from Kubernetes Conformance Checking
    USarXiv cs.SE (Software)

    arXiv:2609.36148v1 Announce Type: new Abstract: Infrastructure drift can separate a running Kubernetes system from its documented architectural intent. This paper investigates live architecture models: editable architectural…

  135. Compositional Safety Failures in Harness Evolution: Identification and Runtime Monitoring
    USarXiv cs.SE (Software)

    arXiv:2609.33123v2 Announce Type: replace-cross Abstract: Self-evolving agent harnesses continually update persistent components such as memory, prompts, skills, and tools. We call this process harness evolution. However, such evolution…

  136. The Only Intuitive Interface Is The Nipple
    USlobste.rs

    Comments

  137. RSS Feeds for Last.fm
    USHacker News Front Page

    Article URL: https://lfm.xiffy.nl/ Comments URL: https://news.ycombinator.com/item?id=49903862 Points: 108 # Comments: 34

  138. Responsible Release of AI-Generated Mathematics
    USHacker News Front Page

    Article URL: https://agmai.org/general-sep29/ Comments URL: https://news.ycombinator.com/item?id=49903713 Points: 101 # Comments: 138

  139. Hardly Promethean
    USlobste.rs

    Comments

  140. How to speed up the Rust compiler in September 2026
    USlobste.rs

    Comments