Source code
Official dataset source · Dorn/cuda/45
Sample
Dorn/cuda/45
Human rating uses the original dataset scale.
Scores
| Method | Score | Scale | Dataset rank (0–100) |
|---|---|---|---|
| Posnett | 0.921 | 0–1; higher is more readable | 89.7Δ 73.5 |
| Scalabrino | 0.171 | 0–1; higher is more readable | 12.4Δ 3.8 |
| Dorn | 0.957 | 0–1; higher is more readable | 98.6Δ 82.5 |
| Mi | 0.582 | 0–1; higher is more readable | 62.1Δ 46.0 |
| LLOC | 9 | Logical lines; fewer is more readable | 61.3Δ 45.1 |
| DeepSeek V4 Pro | 12.67 | 0–20; mean of three runs | 57.5Δ 41.4 |
| GPT-6.1 Sol | 15 | 0–20; mean of three runs | 52.8Δ 36.6 |
| BTTF | 0.664 | 0–1; higher is more readable | 88.3Δ 72.1 |
| Human | 2.64 | 1–5; original rating | 16.2 |
Views
Select the downloaded ZIP or its extracted folder. Files stay in your browser.
Loading feature diagnosis…
Source regions
Feature contributions
Feature contributions
| Feature | Value | Contribution (log-odds) |
|---|---|---|
| Byte entropyHow varied the bytes in the source text are. Repeated bytes give a lower value; a more even mixture gives a higher value. | 4.104 | −6.157 |
| Halstead volumeHow much symbolic information the code contains. It combines the total number of operators and values with the number of distinct ones. | 129.059 | −4.259 |
| Source linesThe number of non-empty source lines. | 10 | +4 |
Intercept 8.87 + feature contributions = 2.455 (log-odds).
Score = sigmoid(2.455) = 0.921.
| Score | 0.171 |
|---|
Feature contributions
| Feature | Value | Contribution (log-odds) |
|---|---|---|
| Identifier layout (horizontal)How rapidly the visual pattern of identifier characters changes from left to right. It measures spatial frequency, not the meaning of the names. | 7.818 | +3.334 |
| Comment layout (horizontal)How rapidly the visual pattern of comment characters changes from left to right. | 0 | −0.804 |
| Indentation frequencyHow rapidly indentation changes from line to line. | 1 | −0.703 |
| Comment layout frequencyHow frequently the layout switches between lines containing only comments or whitespace and lines containing code. | 11 | +0.647 |
| Operator visual areaThe share of the code’s visual area occupied by operators such as +, =, and *. | 0.047 | +0.488 |
| Number layout frequencyHow rapidly the number of numeric values per line changes through the code. | 1 | +0.398 |
| Identifier layout (vertical)How rapidly the visual pattern of identifier characters changes from top to bottom. | 6.523 | −0.319 |
Intercept 0.07 + feature contributions = 3.111 (log-odds).
Score = sigmoid(3.111) = 0.957.
| Score | 0.582 |
|---|
| Score | 9 |
|---|
Run 1
The code is highly structured and consistent, invoking a macro repeatedly with sequential integer arguments. This creates a flat, predictable structure with clear intent: generating multiple CUDA kernel variants. Each line performs a single action, and the flow is natural for a configuration/generation pattern. However, readability is limited because the macro name is extremely long and repetitive, making visual scanning tedious and error-prone. Without context on what the macro does or why these specific values are used, the purpose remains ambiguous to a new reader. The conciseness is good, but the lack of whitespace or grouping slightly reduces clarity.
Run 2
The code consists solely of macro invocations, each on its own line, which keeps the structure flat, concise, and easy to scan. The macro name clearly indicates its purpose: creating CUDA kernels for MD5 with salted passwords, and the numeric arguments (8–16) suggest varying parameters like password length. However, readability is limited because no context is provided for the macro definition, argument meaning, or surrounding code, making the intent slightly ambiguous without additional documentation. The repetition is intentional and clear, but the lack of comments or spacing groups slightly reduces overall clarity.
Run 3
The code consists of repetitive macro invocations with no context or explanation. While the structure is technically flat and each macro call is on its own line, the readability is severely hampered by the long, cryptic macro name and lack of surrounding code or comments. The intent is unclear without seeing the macro definition - it appears to create CUDA kernels for different sizes, but this is not self-evident. The code is concise but too terse, offering no information about purpose, parameters, or usage. The reading flow is mechanical and monotonous, making it difficult to discern what is being accomplished. Overall, the code assumes deep familiarity with the macro's purpose and offers little to aid understanding for anyone not already familiar with this specific codebase.
Run 1
Code Structure: A simple, logically ordered sequence of macro invocations. Nesting: Completely flat, with no nested control flow. Clarity of intent: The macro name suggests CUDA kernel generation for salted MD5 operations, but its implementation and the meaning of arguments 8–16 are not shown. Code length: Short, though repetitive; explicit invocations may be appropriate for compile-time generation. Action granularity: Each line contains exactly one macro invocation. Reading flow: Consecutive numeric arguments make the sequence predictable and easy to scan, although the long, densely concatenated macro name reduces readability.
Run 2
Code Structure: A consistently organized sequence of macro invocations, ordered by argument value. Nesting: Completely flat, with no nested control flow. Clarity of intent: The macro name suggests CUDA kernel creation for a salted MD5 operation, but its dense naming and unexplained numeric arguments leave the exact purpose unclear without the definition. Code length: Short overall, though repetitive; whether the repetition is necessary depends on the macro implementation. Action granularity: One macro invocation per line makes individual entries easy to distinguish, although each macro's internal actions are hidden. Reading flow: Natural ascending order and uniform formatting make the sequence easy to scan.
Run 3
Code Structure: A uniform sequence of macro invocations is logically organized by ascending argument. Nesting: No visible nesting makes the snippet easy to scan. Clarity of intent: The macro name suggests CUDA kernel generation for a salted MD5 operation, but its dense naming and unexplained numeric arguments obscure precise behavior. Code length: Short overall, though repetitive; whether this repetition is necessary depends on the macro implementation. Action granularity: Each line contains one macro invocation, although the actions generated by the macro are hidden. Reading flow: Consistent formatting and consecutive values provide a natural top-to-bottom flow. A brief comment explaining the numeric range would improve readability.