Sample

Scalabrio47

Human rating uses the original dataset scale.

DatasetScalabrino
Human3.67
Lines23

Scores

MethodScoreScaleDataset rank
(0–100)
Posnett00–1; higher is more readable
67.3Δ 14.3
Scalabrino0.7060–1; higher is more readable
72.4Δ 19.3
Dorn0.8260–1; higher is more readable
96.5Δ 43.5
Mi0.2190–1; higher is more readable
50.3Δ 2.8
LLOC7Logical lines; fewer is more readable
81.7Δ 28.6
DeepSeek V4 Pro150–20; mean of three runs
61.6Δ 8.5
GPT-6.1 Sol170–20; mean of three runs
58.5Δ 5.5
BTTF0.5450–1; higher is more readable
54.8Δ 1.8
Human3.671–5; original rating
53.0

Views

Download official ZIP ↗

Select the downloaded ZIP or its extracted folder. Files stay in your browser.

Loading feature diagnosis…

Source regions

Feature contributions

Feature contributions

FeatureValueContribution
(log-odds)
Halstead volumeHow much symbolic information the code contains. It combines the total number of operators and values with the number of distinct ones.658.979−21.746
Source linesThe number of non-empty source lines.23+9.2
Byte entropyHow varied the bytes in the source text are. Repeated bytes give a lower value; a more even mixture gives a higher value.3.874−5.811

Intercept 8.87 + feature contributions = -9.487 (log-odds).
Score = sigmoid(-9.487) = 0.

Score0.706

Feature contributions

FeatureValueContribution
(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.76+0.446
Comment layout (horizontal)How rapidly the visual pattern of comment characters changes from left to right.76+0.422
Number layout frequencyHow rapidly the number of numeric values per line changes through the code.1+0.398
Comment layout frequencyHow frequently the layout switches between lines containing only comments or whitespace and lines containing code.23+0.222
Operator visual areaThe share of the code’s visual area occupied by operators such as +, =, and *.0.085+0.121
Identifier layout (vertical)How rapidly the visual pattern of identifier characters changes from top to bottom.21.675−0.107
Indentation frequencyHow rapidly indentation changes from line to line.21−0.011

Intercept 0.07 + feature contributions = 1.561 (log-odds).
Score = sigmoid(1.561) = 0.826.

Score0.219
Score7
Run 1

The code is generally readable with clear intent and good action granularity. It uses logical structure, minimal nesting (two levels), and concise naming. The flow is natural: it checks source and property, then branches on event type. Comments clarify the two distinct cases. Minor deductions: the boolean conditions with line breaks are slightly awkward; combining checks into a single if-else-if (since events are mutually exclusive) could improve clarity. Also, two separate if statements rather than else-if implies both could happen, which is misleading.

Run 2

The code has a clear purpose and is moderately readable. The method name and parameter names are meaningful. The structure is logical: it checks if the event source matches the model element and if the property is 'stereotype', then handles add/remove events. However, there are issues: the nested if statements create two levels of nesting, and the condition in the outer if spans multiple lines with an awkward line break. The method is relatively concise but could benefit from early returns or guard clauses to reduce nesting. The action granularity is good—one action per line for the listener calls. The reading flow is somewhat natural but could be improved by extracting the stereotype check into a helper method or using a switch-like structure for event types. The use of comments helps clarify intent but could be more descriptive.

Run 3

The method is logically structured with clear intent and good action granularity. It has a reasonable nesting depth (two levels), and the guard clause at the top effectively filters irrelevant events. Variable names are meaningful, and the comments clarify the two main branches. The code is concise and avoids unnecessary complexity. Minor readability improvements could include extracting the source and property name checks into a helper method or using early returns to reduce nesting, but overall the code is quite readable.

Run 1

Code Structure: Logically groups stereotype association handling and separates addition from removal. Nesting: Two conditional levels are manageable, though an early return could flatten the method. Clarity of intent: Event checks, listener method names, and comments make the purpose clear; 'obj' and 'pce' are less descriptive names. Code length: Concise, with no unnecessary logic, although multiline calls add some visual bulk. Action granularity: Each statement performs a single action; compound conditions remain straightforward. Reading flow: Naturally proceeds from source and property validation to event-specific listener updates. Indentation is consistent, but wrapping somewhat interrupts scanning.

Run 2

Code Structure: Logically groups stereotype-related events under a shared source/property check, then separates addition and removal handling. Nesting: Two conditional levels are manageable, though an early return could flatten the method. Clarity of intent: Method calls, event types, and comments clearly communicate listener registration and removal; generic names such as obj and pce slightly reduce clarity. Code length: Concise, with little redundancy; comments mostly restate the operations. Action granularity: Each statement performs a single action, and multiline conditions and calls remain readable. Reading flow: Proceeds naturally from event filtering to specific handling, although generous line wrapping adds minor visual fragmentation.

Run 3

Code Structure: Logically organized around stereotype changes, with separate handling for additions and removals. Nesting: Two conditional levels are manageable, though an early return could flatten the method. Clarity of intent: Method calls and comments clearly communicate listener registration and removal; generic names such as obj and pce slightly reduce clarity. Code length: Concise, with only minor repetition in event checks and value access. Action granularity: Each statement performs a single action, and multiline calls remain easy to follow. Reading flow: The progression from source validation to event-specific handling is natural, although generous line wrapping mildly interrupts scanning.