Sample
Schnappinger/argoUML/org.argouml.ui.cmd.ShortcutField
Human rating uses the original dataset scale.
Scores
| Method | Score | Scale | Dataset rank (0–100) |
|---|---|---|---|
| Posnett | 0 | 0–1; higher is more readable | 42.8Δ 50.6 |
| Scalabrino | 0.76 | 0–1; higher is more readable | 52.4Δ 41.0 |
| Dorn | 0.314 | 0–1; higher is more readable | 48.5Δ 44.9 |
| Mi | 0.576 | 0–1; higher is more readable | 53.1Δ 40.3 |
| LLOC | 42 | Logical lines; fewer is more readable | 42.1Δ 51.3 |
| DeepSeek V4 Pro | 14 | 0–20; mean of three runs | 29.9Δ 63.5 |
| GPT-6.1 Sol | 15 | 0–20; mean of three runs | 25.7Δ 67.7 |
| BTTF | 0.357 | 0–1; higher is more readable | 28.7Δ 64.7 |
| Human | 4 | 1–4; original rating | 93.4 |
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. | 3580.657 | −118.162 |
| Source linesThe number of non-empty source lines. | 173 | +69.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. | 4.736 | −7.104 |
Intercept 8.87 + feature contributions = -47.195 (log-odds).
Score = sigmoid(-47.195) = 0.
| Score | 0.76 |
|---|
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. | 174 | −5.124 |
| Indentation frequencyHow rapidly indentation changes from line to line. | 111 | +3.102 |
| Number layout frequencyHow rapidly the number of numeric values per line changes through the code. | 111 | −2.126 |
| Identifier layout (vertical)How rapidly the visual pattern of identifier characters changes from top to bottom. | 172.887 | +2.007 |
| Operator visual areaThe share of the code’s visual area occupied by operators such as +, =, and *. | 0.042 | +0.53 |
| Comment layout (horizontal)How rapidly the visual pattern of comment characters changes from left to right. | 77.19 | +0.441 |
| 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. | 78.971 | +0.32 |
Intercept 0.07 + feature contributions = -0.78 (log-odds).
Score = sigmoid(-0.78) = 0.314.
| Score | 0.576 |
|---|
| Score | 42 |
|---|
Run 1
The code has a reasonable class structure with clear method separation, but it suffers from excessive copyright comments (around 50 lines) before the actual code, hurting readability. The constructor contains a large anonymous inner KeyListener class with multiple methods and logic, making it harder to follow. The toString method within the listener has nested conditionals and a switch statement, creating moderate nesting depth. Intent is mostly clear from method names, but the inline comments are sparse for the complex key handling logic. Some methods do multiple things per line, like the event firing logic, reducing readability. The reading flow is disrupted by the long constructor and anonymous class. Overall, it's maintainable but could be improved by extracting the KeyListener into a separate class, reducing comments, and breaking down complex methods.
Run 2
The code is well-structured with clear separation of concerns: field initialization, listener setup, and event firing. Nesting is reasonable—the anonymous KeyListener contains a switch statement but depth is manageable. Intent is clear from method names and comments; 'toString' inside the listener could be confusing but its behavior is consistent. Code length is slightly verbose due to legacy license headers but the logic itself is concise. Action granularity is mostly one action per line, though a few lines combine logic (e.g., keyCode assignment and currentKeyCode update). Reading flow is natural: constructor initializes components, adds listeners, then defines helper methods, followed by public API and event firing. The main weakness is the anonymous inner class containing multi-line formatting and slightly dense conditional logic in toString, but overall readability remains high.
Run 3
The code has a clear overall structure with logical class organization, but suffers from a large anonymous inner class that is overly long and contains nested logic. The keyPressed/keyReleased methods are concise, but the private toString() method has deep nesting and mixed concerns (formatting, validation, event firing). Action granularity is mostly one action per line, improving readability. The reading flow is disrupted by the monolithic constructor and the event listener implementation embedded within it. Redundant comments and excessive boilerplate (e.g. copyright headers) slightly reduce clarity. The event firing method is straightforward and well-named, but the listener logic is verbose. Overall, readable but could benefit from extracting the key handling logic into a separate named class and flattening nested conditional branches.
Run 1
Code Structure: The class logically separates initialization, listener registration, and event notification, but substantial shortcut-processing logic is embedded in an anonymous listener inside the constructor. Nesting: Mostly moderate, with deeper constructor/listener/method/conditional nesting and nested checks in notification dispatch. Clarity of intent: Descriptive class and method names and useful comments communicate the purpose; abbreviated variables such as ke, tf, and modifText and the stateful toString helper make details less obvious. Code length: Reasonably compact implementation, although repeated modifier-key cases and some redundant comments add verbosity. Action granularity: Statements generally perform one action per line, making operations easy to follow. Reading flow: Event handlers and public methods follow a coherent sequence, but the long constructor, inconsistent spacing, and interleaving of formatting, state updates, and event dispatch interrupt the flow.
Run 2
Code Structure: The class separates listener registration and notification cleanly, but embeds substantial keyboard-processing logic in an anonymous listener inside the constructor. Nesting: Mostly moderate, though the constructor, anonymous class, helper method, and conditional switches create several nested levels. Clarity of intent: Class documentation, descriptive event methods, and comments explain shortcut capture; however, the helper named toString, abbreviated variables, and shared currentKeyCode state require closer inspection. Code length: Reasonably compact implementation, with some redundant local variables and extensive license boilerplate increasing reading overhead. Action granularity: Statements generally perform one action per line, making individual operations easy to follow. Reading flow: Initialization, keyboard handling, and listener notification follow a logical sequence, but inconsistent whitespace and placing conversion plus event dispatch inside the same helper interrupt an otherwise clear flow.
Run 3
Code Structure: The class separates construction, listener registration, and notification logically, but embeds substantial shortcut-processing logic in an anonymous listener inside the constructor. Nesting: Mostly moderate, with deeper conditional and switch nesting in key conversion and event dispatch. Clarity of intent: Class documentation, descriptive APIs, and comments make the purpose clear; abbreviated names such as ke, tf, and modifText, plus the generic toString method name, reduce precision. Code length: Reasonably compact implementation, though lengthy license headers and some redundant comments slow scanning. Action granularity: Statements generally perform one action per line, making operations easy to follow. Reading flow: Consistent formatting and grouped event handlers support comprehension, but mutable currentKeyCode state shared across callbacks and event notification occurring inside string conversion require extra attention.