Sample
Schnappinger/argoUML/org.argouml.ui.SettingsTabLayout
Human rating uses the original dataset scale.
Scores
| Method | Score | Scale | Dataset rank (0–100) |
|---|---|---|---|
| Posnett | 0 | 0–1; higher is more readable | 57.9Δ 28.2 |
| Scalabrino | 0.822 | 0–1; higher is more readable | 68.2Δ 38.4 |
| Dorn | 0.15 | 0–1; higher is more readable | 37.3Δ 7.6 |
| Mi | 0.568 | 0–1; higher is more readable | 50.5Δ 20.8 |
| LLOC | 37 | Logical lines; fewer is more readable | 45.2Δ 15.5 |
| DeepSeek V4 Pro | 10.67 | 0–20; mean of three runs | 10.6Δ 19.1 |
| GPT-6.1 Sol | 13 | 0–20; mean of three runs | 9.4Δ 20.3 |
| BTTF | 0.565 | 0–1; higher is more readable | 52.5Δ 22.8 |
| Human | 3.01 | 1–4; original rating | 29.7 |
Views
Loading feature diagnosis…
Source regions
Feature contributions
Feature contributions
| Feature | Value | Contribution (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. | 3208.938 | −105.895 |
| Source linesThe number of non-empty source lines. | 216 | +86.4 |
| Byte entropyHow varied the bytes in the source text are. Repeated bytes give a lower value; a more even mixture gives a higher value. | 5.025 | −7.538 |
Intercept 8.87 + feature contributions = -18.163 (log-odds).
Score = sigmoid(-18.163) = 0.
| Score | 0.822 |
|---|
Feature contributions
| Feature | Value | Contribution (log-odds) |
|---|---|---|
| Comment layout frequencyHow frequently the layout switches between lines containing only comments or whitespace and lines containing code. | 217 | −6.647 |
| Indentation frequencyHow rapidly indentation changes from line to line. | 97 | +2.618 |
| Identifier layout (vertical)How rapidly the visual pattern of identifier characters changes from top to bottom. | 215.914 | +2.608 |
| Number layout frequencyHow rapidly the number of numeric values per line changes through the code. | 97 | −1.805 |
| Operator visual areaThe share of the code’s visual area occupied by operators such as +, =, and *. | 0.03 | +0.655 |
| Comment layout (horizontal)How rapidly the visual pattern of comment characters changes from left to right. | 79.949 | +0.486 |
| 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. | 79.945 | +0.279 |
Intercept 0.07 + feature contributions = -1.736 (log-odds).
Score = sigmoid(-1.736) = 0.15.
| Score | 0.568 |
|---|
| Score | 37 |
|---|
Run 1
The code readability is severely hampered by large blocks of commented-out code (~60 lines), which dominate the file and obscure the active logic. The file starts with a long copyright header, then jump-worthy import statements, but the class's structure is mostly logical. The constructor is slightly cluttered with unused local variables and a large commented section. Nesting is generally flat, which is good. Intent is partially clear from Javadoc but diluted by TODOs and obsolete comments. Code repetition in createProperty, loadPosition, and savePosition is notable but simple. Action granularity is reasonable. Reading flow is disrupted by dead code and comments, making it hard to follow the actual implementation.
Run 2
The code is generally structured, with clear sections for imports, fields, constructor, and methods. However, there are several readability issues. A significant amount of the code is commented out, which adds clutter and makes the active logic less obvious. The file includes a very long copyright header, further padding the file length. The `createProperty`, `loadPosition`, and `savePosition` methods are concise and each performs a limited number of actions, which is good. Yet, the presence of TODOs and commented-out blocks makes the intent ambiguous, especially since the class is noted as unused. Nesting is shallow. The reading flow is disrupted by the large commented chunks. Overall, it is readable but has unnecessary noise.
Run 3
The code has a logical structure with clear sections (imports, class declaration, constructor, methods), but readability is significantly reduced by large blocks of commented-out code and mixed formatting. The nesting is mostly flat, which is positive, but the excessive TODO and commented-out Property declarations obscure the active logic. Intent is somewhat clear—it's a settings tab layout panel—but the disabled functionality makes the actual purpose ambiguous. Code length is inflated by legacy comments and unused helper methods (createProperty, loadPosition, savePosition, makeKey), which add noise without contributing to current behavior. Action granularity is adequate, with one action per line in most active sections. Reading flow is disrupted by inconsistent indentation (e.g., tabs in method signatures) and scattered commented code. Overall, while the active code is simple, the surrounding clutter prevents it from being highly readable.
Run 1
Code Structure: Constructor, configuration helpers, and interface callbacks are logically separated, but disabled functionality leaves unused helpers and variables. Nesting: Very flat, with no complex control flow. Clarity of intent: Descriptive method names and comments explain the layout settings purpose, although the largely disabled implementation makes actual behavior less obvious. Code length: Extensive commented-out code substantially increases reading effort without contributing to execution. Action granularity: Most statements perform one action per line; compact getters and empty callbacks are still understandable. Reading flow: Active methods follow a natural sequence, but large inactive blocks and inconsistent indentation interrupt scanning. Overall, the active code is straightforward, while accumulated disabled code reduces readability.
Run 2
Code Structure: Constructor, configuration helpers, and interface callbacks are logically separated, but disabled functionality and unused helpers clutter the class. Nesting: Very flat, with no complex control flow. Clarity of intent: Descriptive method names and comments explain the layout-settings purpose, but commented-out implementation, unused variables, and empty callbacks obscure what actually works. Code length: Active logic is concise, yet extensive commented-out code and repetitive disabled calls make the file unnecessarily cumbersome to scan. Action granularity: Most statements perform one action per line; compact one-line methods are still understandable. Reading flow: UI setup and configuration operations follow a natural sequence, but large inactive blocks and inconsistent indentation interrupt that flow. Overall, the executable code is straightforward, while accumulated dead code significantly reduces readability.
Run 3
Code Structure: The constructor, configuration helpers, and interface callbacks are logically separated, but disabled functionality and unused helpers clutter the class. Nesting: Nearly all code is flat, making individual operations easy to follow. Clarity of intent: Names and documentation convey a layout-settings panel, and TODOs explain its disabled state; however, commented-out implementation and unused variables obscure what actually works. Code length: Small active methods are concise, but extensive commented-out code substantially increases reading effort. Action granularity: Most statements perform one action per line; a few inline methods compress declarations and returns. Reading flow: UI setup and configuration operations follow a natural sequence, but large inactive blocks and inconsistent indentation interrupt that flow.