Dependencies that Bundle Code and Execution

• URL: http://arxiv.org/abs/2607.02618v1
• Date: Wed, 01 Jul 2026 21:51:22 GMT
• Title: Dependencies that Bundle Code and Execution
• Abstract summary: LIBCACHE is the first system to distribute per-dependency execution caches through a package registry as first-class artifacts alongside compiled code.<n>Each library maintainer produces an execution cache from the library's own test suite and publishes it to Maven Central alongside the JAR.<n>At application build time, LIBCACHE merges all per-dependency caches into a single unified cache that covers the classes exercised across every dependency's test suite.
• Score: 10.237053295937054
• License: http://creativecommons.org/licenses/by-sa/4.0/
• Abstract: Applications are built from many dependencies. Each dependency is distributed by package registries but it only contains compiled code and does not ship execution state, so runtimes rebuild that state from scratch on every startup. Execution caching records this preparation result so subsequent starts can skip it, but no existing system publishes execution state to a registry for downstream consumers to reuse. We introduce LIBCACHE, the first system to distribute per-dependency execution caches through a package registry as first-class artifacts alongside compiled code. Each library maintainer produces an execution cache from the library's own test suite and publishes it to Maven Central alongside the JAR. At application build time, LIBCACHE merges all per-dependency caches into a single unified cache that covers the classes exercised across every dependency's test suite. We evaluate LIBCACHE on three real-world Java projects across twelve workloads. LIBCACHE speeds up application startup by up to 1.91x and outperforms a cache built from a single workload in 10 of 12 workloads, with the largest average gain for batik (1.60x vs. 1.27x). Cache production adds 10-47% to build time for applications, and execution caches average 18x the size of the corresponding JAR. Our main contribution is LIBCACHE, which establishes that execution caches are distributable supply chain artifacts and that merging per-dependency caches delivers broader startup coverage than any single observation run.

Related papers

• AI-Generated Code Is Not Reproducible (Yet): An Empirical Study of Dependency Gaps in LLM-Based Coding Agents [3.0684671771686394]
  This paper presents an empirical study investigating whether Large Language Models (LLMs) can be executed successfully in a clean environment with only OS packages.<n>We evaluate three state-of-the-art LLM coding agents across 300 projects generated from 100 standardized prompts in Python, JavaScript, and Java.<n>Our results show that only 68.3% of projects execute out-of-the-box, with substantial variation across languages.
  arXiv  Detail & Related papers  (2025-12-26T21:17:22Z)
• Classport: Designing Runtime Dependency Introspection for Java [8.337857900646346]
  introspection, i.e., the ability to observe which dependencies are currently used during program execution is fundamental for Software Supply Chain security.<n>We solve this problem with Classport, a system that embeds dependency information into Java class files, enabling the retrieval of dependency information at runtime.<n>We evaluate Classport on six real-world projects, demonstrating the feasibility in identifying dependencies at runtime.
  arXiv  Detail & Related papers  (2025-10-23T08:39:30Z)
• SCBench: A KV Cache-Centric Analysis of Long-Context Methods [61.025422435235456]
  We introduce SCBench, a benchmark for evaluating long-context methods from a KV cachecentric perspective.<n>We provide an extensive KV cache-centric analysis of eight categories long-context solutions, including Gated Linear RNNs and Mamba-Attention hybrids.<n>Our findings show that sub-O(n) memory methods suffer in multi-turn scenarios, while sparse encoding with O(n) memory and sub-O(n2) pre-filling perform robustly.
  arXiv  Detail & Related papers  (2024-12-13T17:59:52Z)
• Commit0: Library Generation from Scratch [77.38414688148006]
  Commit0 is a benchmark that challenges AI agents to write libraries from scratch.<n>Agents are provided with a specification document outlining the library's API as well as a suite of interactive unit tests.<n> Commit0 also offers an interactive environment where models receive static analysis and execution feedback on the code they generate.
  arXiv  Detail & Related papers  (2024-12-02T18:11:30Z)
• Long Code Arena: a Set of Benchmarks for Long-Context Code Models [75.70507534322336]
  Long Code Arena is a suite of six benchmarks for code processing tasks that require project-wide context. These tasks cover different aspects of code processing: library-based code generation, CI builds repair, project-level code completion, commit message generation, bug localization, and module summarization. For each task, we provide a manually verified dataset for testing, an evaluation suite, and open-source baseline solutions.
  arXiv  Detail & Related papers  (2024-06-17T14:58:29Z)
• Detecting and removing bloated dependencies in CommonJS packages [6.115666382910127]
  We present the first study to investigate bloated dependencies within server-side JavaScript applications.<n>We propose a trace-based dynamic analysis that monitors the OS file system to determine which dependencies are not accessed during runtime.
  arXiv  Detail & Related papers  (2024-05-28T08:04:01Z)
• Get More with LESS: Synthesizing Recurrence with KV Cache Compression for Efficient LLM Inference [78.65321721142624]
  We focus on a memory bottleneck imposed by the key-value ( KV) cache. Existing KV cache methods approach this problem by pruning or evicting large swaths of relatively less important KV pairs. We propose LESS, a simple integration of a constant sized cache with eviction-based cache methods.
  arXiv  Detail & Related papers  (2024-02-14T18:54:56Z)
• Charliecloud's layer-free, Git-based container build cache [0.0]
  This image is built by interpreting instructions in a machine-readable recipe, which is faster with a build cache that stores instruction results for re-use. Standard approach is a many-layered union, encoding differences between layers as tar archives. Our experiments show this performs similarly to layered caches on both build time and disk usage, with a considerable advantage for many-instruction recipes.
  arXiv  Detail & Related papers  (2023-08-31T23:05:16Z)
• LongCoder: A Long-Range Pre-trained Language Model for Code Completion [56.813974784131624]
  LongCoder employs a sliding window mechanism for self-attention and introduces two types of globally accessible tokens. Bridge tokens are inserted throughout the input sequence to aggregate local information and facilitate global interaction. memory tokens are included to highlight important statements that may be invoked later and need to be memorized.
  arXiv  Detail & Related papers  (2023-06-26T17:59:24Z)
• Analysis of Library Dependency Networks of Package Managers Used in iOS Development [3.46067608522128]
  The library dependency network in the Swift ecosystem encompasses libraries from CocoaPods, Carthage and Swift Package Manager (PM) Although CocoaPods is the package manager with the biggest set of libraries, the difference to other package managers is not as big as expected. Swift PM is becoming more and more popular, resulting in a gradual slow-down of the growth of the other two package managers.
  arXiv  Detail & Related papers  (2023-05-18T12:14:19Z)
• Code Librarian: A Software Package Recommendation System [65.05559087332347]
  We present a recommendation engine called Librarian for open source libraries. A candidate library package is recommended for a given context if: 1) it has been frequently used with the imported libraries in the program; 2) it has similar functionality to the imported libraries in the program; 3) it has similar functionality to the developer's implementation, and 4) it can be used efficiently in the context of the provided code.
  arXiv  Detail & Related papers  (2022-10-11T12:30:05Z)
• Enabling Fast Differentially Private SGD via Just-in-Time Compilation and Vectorization [8.404254529115835]
  A common pain point in differentially private machine learning is the significant runtime overhead incurred when executing Differentially Private Gradient Descent (DPSGD) We demonstrate that by exploiting powerful language primitives, one can dramatically reduce these overheads, in many cases nearly matching the best non-private running times.
  arXiv  Detail & Related papers  (2020-10-18T18:45:04Z)

This list is automatically generated from the titles and abstracts of the papers in this site.

This site does not guarantee the quality of this site (including all information) and is not responsible for any consequences.