Sample

JetBrains/b41

Human rating uses the original dataset scale.

DatasetJetBrains

Human0.87

Lines9

Scores

Method	Score	Scale	Dataset rank (0–100)
Posnett	0.024	0–1; higher is more readable	95.8Δ 22.9
Scalabrino	0.961	0–1; higher is more readable	97.5Δ 24.6
Dorn	0.491	0–1; higher is more readable	43.2Δ 29.7
Mi	0.363	0–1; higher is more readable	31.4Δ 41.5
LLOC	4	Logical lines; fewer is more readable	92.8Δ 19.9
DeepSeek V4 Pro	17.67	0–20; mean of three runs	88.6Δ 15.7
GPT-6.1 Sol	19	0–20; mean of three runs	96.2Δ 23.3
BTTF	0.644	0–1; higher is more readable	94.9Δ 22.0
Human	0.87	0–1; original rating	72.9

Views

Source code

import java.math.BigDecimal; public class EulerMascheroniConstant { public static void main(String[] args) { BigDecimal gamma = new BigDecimal("0.57721566490153286060651209"); gamma = gamma.setScale(1000, BigDecimal.ROUND_HALF_UP); System.out.println(gamma); } }

Loading feature diagnosis…

Source regions

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.	272.481	−8.992
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.776	−7.164
Source linesThe number of non-empty source lines.	9	+3.6

Intercept 8.87 + feature contributions = -3.686 (log-odds).
Score = sigmoid(-3.686) = 0.024.

Score	0.961

Feature contributions

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.	9	+0.718
Indentation frequencyHow rapidly indentation changes from line to line.	9	−0.426
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.	77.778	+0.371
Identifier layout (vertical)How rapidly the visual pattern of identifier characters changes from top to bottom.	7.848	−0.3
Number layout frequencyHow rapidly the number of numeric values per line changes through the code.	9	+0.214
Operator visual areaThe share of the code’s visual area occupied by operators such as +, =, and *.	0.085	+0.119

Intercept 0.07 + feature contributions = -0.038 (log-odds).
Score = sigmoid(-0.038) = 0.491.

Score	0.363

Score	4

Run 1

The code is concise, well-structured, and easy to understand. It imports a necessary class, clearly defines a public class and main method, initializes a constant with an accurate value, adjusts its scale, and prints it—all with minimal nesting and one action per line. The only minor drawback is the slightly redundant setScale operation, which could be simplified, and the use of the deprecated BigDecimal.ROUND_HALF_UP constant, but these do not significantly harm readability.

Run 2

The code is highly readable with a clear, logical structure. It has a single class and method, minimal nesting, and an unambiguous purpose: printing the Euler-Mascheroni constant to 1000 decimal places. Each action is on its own line, and the reading flow is natural—import, class definition, main method, constant creation, scale setting, and output. The code is concise but appropriately verbose for the task. Minor deductions: the variable name gamma is slightly redundant given the class name, and the hard-coded constant may benefit from a named constant or comment explaining the significance of the value. Overall, it is straightforward and easy to follow.

Run 3

The code is highly readable. It has a clear, logical structure with a single class and main method. Nesting is minimal—no conditional blocks or loops are present. The intent is unambiguous: it prints the Euler-Mascheroni constant to 1000 decimal places. Code length is concise and avoids unnecessary lines. Action granularity is good: each logical step (creation, scaling, printing) is on its own line. Reading flow is natural, from import to variable initialization to output. Minor deductions: the variable name `gamma` is slightly generic, and `ROUND_HALF_UP` is deprecated in newer Java versions, but these do not materially affect readability.

Run 1

Code Structure: Clearly organized into an import, a descriptively named class, and a short main method. Nesting: Minimal, with only the standard class and method levels. Clarity of intent: The class name and gamma variable communicate the constant being printed, though setting the scale to 1000 may misleadingly suggest greater precision rather than padding the supplied value. Code length: Concise, with no unnecessary logic. Action granularity: Each statement performs one clear operation. Reading flow: Natural progression from initialization to scale adjustment to output.

Run 2

Code Structure: Imports, class, and main method are logically organized. Nesting: Minimal, limited to the necessary class and method blocks. Clarity of intent: The class name and gamma variable clearly identify the constant, though setting its scale to 1000 may misleadingly suggest greater precision; it only appends zeros to the supplied approximation. Code length: Concise, with no unnecessary logic. Action granularity: Each statement performs one clear action. Reading flow: Natural progression from initialization to formatting to output. The deprecated BigDecimal.ROUND_HALF_UP constant is less expressive than RoundingMode.HALF_UP.

Run 3

Code Structure: The import, class, and main method are logically organized. Nesting: Only the necessary class and method scopes are present. Clarity of intent: The class name and gamma variable clearly indicate the constant being printed, though setting the scale to 1000 may misleadingly suggest greater precision than the supplied value provides. Code length: The implementation is concise with no unnecessary code. Action granularity: Each statement performs one distinct action. Reading flow: Initialization, scale adjustment, and output follow a natural sequence.