| --- |
| license: other |
| license_name: open-data-attribution-training-disclosure-license-odatl-1.0 |
| license_link: LICENSE |
| language: |
| - en |
| tags: |
| - benchmark |
| - bench |
| - corpus |
| - coding |
| - code |
| - english |
| --- |
| |
| # Coding-Corpus-Bench |
|
|
| A benchmark dataset for evaluating language-semantics reasoning across systems programming and low-level programming languages. |
|
|
| ## Overview |
|
|
| **Coding-Corpus-Bench** contains 100 curated programming-language questions designed to test whether a model can reason precisely about language semantics rather than rely on superficial pattern matching or observed behavior. |
|
|
| The benchmark covers: |
|
|
| * Rust |
| * Go |
| * C |
| * C++ |
| * Zig |
| * V |
| * CUDA |
|
|
| Questions focus on subtle semantic rules including ownership, lifetimes, type systems, overload resolution, memory models, evaluation order, synchronization, representation validity, and compiler behavior under explicitly stated language/toolchain versions. |
|
|
| Each example provides both a question and a rubric describing the reasoning and conclusion expected from a high-quality answer. |
|
|
| ## Dataset Statistics |
|
|
| | Language | Examples | |
| | --------- | -------: | |
| | Rust | 15 | |
| | Go | 15 | |
| | C | 14 | |
| | C++ | 14 | |
| | Zig | 14 | |
| | V | 14 | |
| | CUDA | 14 | |
| | **Total** | **100** | |
|
|
| ## Dataset Format |
|
|
| The dataset is provided as **JSONL**. Each line represents one benchmark item. |
|
|
| ```json |
| { |
| "id_aa": "rust_001", |
| "title": "GAT higher-ranked implied static", |
| "category": "Rust", |
| "prompt": "...", |
| "system_prompt": "...", |
| "rubric": "...", |
| "expected_deliverables": "", |
| "reference_files": "" |
| } |
| ``` |
|
|
| ### Fields |
|
|
| | Field | Description | |
| | ----------------------- | ------------------------------------------------------------------------------------------------------ | |
| | `id_aa` | Unique identifier for the benchmark item. | |
| | `title` | Short description of the semantic issue being tested. | |
| | `category` | Programming language or platform category. | |
| | `prompt` | The question presented to the model, often including a code fragment and explicit version assumptions. | |
| | `system_prompt` | Task-specific instruction describing the required reasoning perspective. | |
| | `rubric` | Evaluation criteria for judging the answer. | |
| | `expected_deliverables` | Reserved field for expected deliverables; currently empty for all examples. | |
| | `reference_files` | Reserved field for supporting references; currently empty for all examples. | |
|
|
| ## What the Benchmark Tests |
|
|
| The corpus emphasizes questions where a superficially plausible answer can be wrong without precise knowledge of the language specification. |
|
|
| ### Rust |
|
|
| Examples cover topics such as: |
|
|
| * Generic associated types and higher-ranked trait bounds |
| * Lifetime inference and implied `'static` requirements |
| * Drop timing |
| * Wildcard patterns |
| * Method-call receiver adjustment and autoref |
| * Closure capture and closure traits |
| * Two-phase borrows |
| * Trait coherence |
| * `ManuallyDrop` |
| * Type validity and undefined behavior |
| * Trait-object method dispatch |
| * `Self: Sized` and dyn compatibility |
| * Non-lexical lifetimes |
| * Borrowing through `ref` patterns |
| * Compile-time evaluation |
| * Trait bounds |
|
|
| ### Go |
|
|
| Examples test areas including: |
|
|
| * `select` operand evaluation |
| * Typed nil values inside interfaces |
| * Slice range semantics |
| * Generic type sets |
| * Named return values and `defer` |
| * Channel synchronization and happens-before |
| * Method sets |
| * Buffered-channel synchronization |
| * Deferred argument evaluation |
| * Slice capacity |
| * Approximation elements such as `~int` |
| * Closed-channel receive semantics |
| * Untyped constants and representability |
|
|
| ### C |
|
|
| Examples address ISO C semantics such as: |
|
|
| * Object representation and byte size |
| * `CHAR_BIT` |
| * Relational comparison of pointers |
| * Integer promotions |
| * Unsigned arithmetic |
| * Pointer representation and object-pointer sizes |
|
|
| ### C++ |
|
|
| Examples cover: |
|
|
| * Mutable lambda captures |
| * Guaranteed copy elision |
| * Deleted copy constructors |
| * Overload resolution |
| * Character literal types |
|
|
| ### Zig |
|
|
| Examples cover: |
|
|
| * Bit size versus ABI size |
| * Pointer constness coercion |
| * Typed shifts |
| * Tagged-union active-field rules |
|
|
| ### V |
|
|
| Examples cover: |
|
|
| * String byte length |
| * Mutability of struct fields and bindings |
| * Array slicing |
| * `if` expressions |
|
|
| ### CUDA |
|
|
| Examples cover: |
|
|
| * Warp shuffle operations |
| * Memory fences versus execution synchronization |
| * Kernel launch cardinality |
| * Block-level versus grid-level barriers |
|
|
| ## Version-Specific Reasoning |
|
|
| Questions explicitly state the relevant language or toolchain version where the answer depends on version-specific semantics. |
|
|
| Examples include: |
|
|
| * **Rust 1.85.0, edition 2021** |
| * **Go 1.23** |
| * **ISO C17** |
| * **ISO C++20** |
| * **Zig 0.13.0** |
| * **V 0.4.10** |
| * **CUDA 12.x** |
|
|
| Evaluations should therefore be performed against the assumptions stated in each individual item rather than against an unspecified "latest" language version. |
|
|
| ## Evaluation |
|
|
| The `rubric` field contains the expected evaluation criteria. |
|
|
| Rubrics generally distinguish between: |
|
|
| 1. **The final conclusion** — whether code compiles, what it prints, whether behavior is defined, etc. |
| 2. **The decisive reasoning** — whether the answer identifies the particular language rule responsible for that conclusion. |
|
|
| For example, a benchmark item may require both: |
|
|
| * the exact output; and |
| * an explanation of why evaluation order, borrowing, synchronization, or destructor timing produces that output. |
|
|
| This makes the dataset suitable for evaluating **reasoning quality**, not merely final-answer accuracy. |
|
|
| ### Example |
|
|
| A Rust item concerning a reborrow expects the answer to recognize that the program compiles because the reborrow's lifetime ends at its last use under non-lexical lifetimes, rather than incorrectly rejecting the program merely because two mutable references appear in the same scope. |
|
|
| ## Intended Uses |
|
|
| The dataset can be used for: |
|
|
| * Evaluating LLM coding and reasoning models |
| * Testing language-semantics competence |
| * Comparing models across programming languages |
| * Building automated benchmark/evaluation pipelines |
| * Studying hallucination and specification-reasoning errors |
| * Evaluating whether models provide decisive explanations rather than unsupported conclusions |
|
|
| ## Recommended Evaluation Protocol |
|
|
| For each item: |
|
|
| 1. Provide the `prompt` to the model under the assumptions stated in the prompt. |
| 2. Preserve the relevant language/toolchain version. |
| 3. Evaluate the response against the associated `rubric`. |
| 4. Score the requested conclusion separately from the supporting reasoning where the rubric provides separate criteria. |
| 5. Do not award correctness merely because a model happens to give the expected output without explaining the semantic rule when the rubric explicitly requires that explanation. |
|
|
| ## Data Integrity |
|
|
| The supplied corpus contains: |
|
|
| * **100** benchmark items |
| * **7** language/platform categories |
| * An empty `expected_deliverables` field for every item |
| * An empty `reference_files` field for every item |
|
|
| The benchmark is therefore self-contained at the example/rubric level; no external reference files are specified by the dataset entries themselves. |
|
|
| ## License |
|
|
| Open Data Attribution Training Disclosure License (ODATL‑1.0) |
