Sample
Human rating uses the original dataset scale.
| Method | Score | Scale | Dataset rank (0–100) |
|---|---|---|---|
| Posnett | 0.047 | 0–1; higher is more readable | 73.2Δ 7.1 |
| Scalabrino | 0.614 | 0–1; higher is more readable | 24.3Δ 56.0 |
| Dorn | 0.3 | 0–1; higher is more readable | 47.5Δ 32.8 |
| Mi | 0.621 | 0–1; higher is more readable | 66.0Δ 14.4 |
| LLOC | 2 | Logical lines; fewer is more readable | 94.6Δ 14.2 |
| DeepSeek V4 Pro | 18 | 0–20; mean of three runs | 91.4Δ 11.1 |
| GPT-6.1 Sol | 19.33 | 0–20; mean of three runs | 98.3Δ 18.0 |
| BTTF | 0.627 | 0–1; higher is more readable | 62.4Δ 18.0 |
| Human | 3.96 | 1–4; original rating | 80.4 |
Loading feature diagnosis…
| 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. | 292.575 | −9.655 |
| 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.679 | −7.019 |
| Source linesThe number of non-empty source lines. | 12 | +4.8 |
Intercept 8.87 + feature contributions = -3.004 (log-odds).
Score = sigmoid(-3.004) = 0.047.
| Score | 0.614 |
|---|
| Feature | Value | Contribution (log-odds) |
|---|---|---|
| Comment layout (horizontal)How rapidly the visual pattern of comment characters changes from left to right. | 0 | −0.804 |
| Comment layout frequencyHow frequently the layout switches between lines containing only comments or whitespace and lines containing code. | 13 | +0.576 |
| 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. | 95.923 | −0.398 |
| Indentation frequencyHow rapidly indentation changes from line to line. | 12 | −0.322 |
| Identifier layout (vertical)How rapidly the visual pattern of identifier characters changes from top to bottom. | 11.866 | −0.244 |
| Number layout frequencyHow rapidly the number of numeric values per line changes through the code. | 12 | +0.145 |
| Operator visual areaThe share of the code’s visual area occupied by operators such as +, =, and *. | 0.084 | +0.13 |
Intercept 0.07 + feature contributions = -0.847 (log-odds).
Score = sigmoid(-0.847) = 0.3.
| Score | 0.621 |
|---|
| Score | 2 |
|---|
The code is highly readable: a small, focused class with clear purpose (deprecated adapter for MultipleFailureException). Structure is logical with package, import, class declaration, field, constructor. Nesting is essentially flat. Intent is unambiguous due to the @Deprecated annotation and superclass call. Length is minimal and necessary. Each line performs one action. Reading flow is natural from package to constructor. Minor deductions only for the lack of Javadoc explaining the deprecation rationale, but the code itself is exemplary.
The code is highly readable due to its clear structure, minimal nesting, and concise length. It demonstrates a clean single-purpose class that extends a parent exception and adds a serial version UID, with a straightforward constructor that delegates to the superclass. The package and imports are well-organized, and the @Deprecated annotation clearly communicates intent. Each action is on a single line, and the reading flow is natural. Minor deductions include the redundant fully-qualified name for the parent class despite being in the same package and the lack of a comment explaining why the class is deprecated.
The code is highly readable due to its simplicity and clear structure. It consists of a single class extending a parent exception class, with a straightforward constructor that delegates to the superclass. The package and import declarations are minimal and logical. Nesting is essentially flat, with only one constructor and no complex control flow. The intent is unambiguous: it's a deprecated subclass of MultipleFailureException. Code length is minimal and appropriately concise. Each action (package declaration, import, class annotation, field, constructor) is on its own line, maintaining good action granularity. Reading flow is natural and follows standard Java conventions.
Code Structure: Logically organized into package, import, annotation, class, field, and constructor. Nesting: Minimal, with only class and constructor scopes. Clarity of intent: Clearly defines a deprecated compatibility subclass that delegates failure handling to its superclass; the fully qualified superclass name avoids ambiguity. Code length: Concise, with no unnecessary implementation. Action granularity: Each declaration and statement occupies its own line. Reading flow: Follows standard Java conventions and reads naturally from class identity to initialization.
Code Structure: Logically organized with package, import, annotation, class, field, and constructor. Nesting: Minimal, limited to the class and constructor. Clarity of intent: Clearly a deprecated compatibility subclass that forwards failures to its superclass; the fully qualified superclass name distinguishes it from the identically named subclass. A brief deprecation explanation would clarify the intended replacement. Code length: Concise, with no unnecessary implementation. Action granularity: Each declaration and operation occupies its own line. Reading flow: Conventional Java layout makes the code easy to follow.
Code Structure: Logically organized into package, import, annotation, class, field, and constructor. Nesting: Minimal, with only class and constructor scopes. Clarity of intent: Clearly a deprecated compatibility wrapper that forwards failures to its superclass; the fully qualified superclass distinguishes the identically named classes, though the reason for retaining the wrapper is undocumented. Code length: Concise, with no unnecessary implementation. Action granularity: Each declaration and operation occupies its own line. Reading flow: Natural top-to-bottom progression with conventional Java formatting.