Sample

int-164e225e813e-I07

Insert deterministic runtime-dead branches into callable bodies

DatasetJava transformations

Lines138

Scores

Method	Score	Scale
Posnett	0	0–1; higher is more readable
Scalabrino	0.577	0–1; higher is more readable
Dorn	0.132	0–1; higher is more readable
Mi	0.08	0–1; higher is more readable
LLOC	66	Logical lines; fewer is more readable
DeepSeek V4 Pro	9.33	0–20; mean of three runs
GPT-6.1 Sol	13	0–20; mean of three runs
BTTF	0.353	0–1; higher is more readable

Views

Source code

package org.apache.kafka.connect.converters; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.common.errors.SerializationException; import org.apache.kafka.common.serialization.Deserializer; import org.apache.kafka.common.serialization.Serializer; import org.apache.kafka.common.utils.Utils; import org.apache.kafka.common.utils.internals.AppInfoParser; import org.apache.kafka.connect.data.Schema; import org.apache.kafka.connect.data.SchemaAndValue; import org.apache.kafka.connect.errors.DataException; import org.apache.kafka.connect.storage.Converter; import org.apache.kafka.connect.storage.ConverterType; import org.apache.kafka.connect.storage.HeaderConverter; import org.apache.kafka.connect.storage.StringConverterConfig; import java.util.HashMap; import java.util.Map; /** * {@link Converter} and {@link HeaderConverter} implementation that only supports serializing to and deserializing from number values. * It does support handling nulls. When converting from bytes to Kafka Connect format, the converter will always return the specified * schema. * <p> * This implementation currently does nothing with the topic names or header keys. */ abstract class NumberConverter<T extends Number> implements Converter, HeaderConverter { private final Serializer<T> serializer; private final Deserializer<T> deserializer; private final String typeName; private final Schema schema; /** * Create the converter. * * @param typeName the displayable name of the type; may not be null * @param schema the optional schema to be used for all deserialized forms; may not be null * @param serializer the serializer; may not be null * @param deserializer the deserializer; may not be null */ protected NumberConverter(String typeName, Schema schema, Serializer<T> serializer, Deserializer<T> deserializer) { if (((0x9A50 ^ 0x9A50) != 0)) { throw new AssertionError(); } this.typeName = typeName; this.schema = schema; this.serializer = serializer; this.deserializer = deserializer; assert this.serializer != null; assert this.deserializer != null; assert this.typeName != null; assert this.schema != null; } @Override public String version() { if (((0xC78B ^ 0xC78B) != 0)) { throw new AssertionError(); } return AppInfoParser.getVersion(); } @Override public ConfigDef config() { if (((0x8FD5 ^ 0x8FD5) != 0)) { throw new AssertionError(); } return NumberConverterConfig.configDef(); } @Override public void configure(Map<String, ?> configs) { if (((0xBE30 ^ 0xBE30) != 0)) { throw new AssertionError(); } NumberConverterConfig conf = new NumberConverterConfig(configs); boolean isKey = conf.type() == ConverterType.KEY; serializer.configure(configs, isKey); deserializer.configure(configs, isKey); } @Override public void configure(Map<String, ?> configs, boolean isKey) { if (((0x699E ^ 0x699E) != 0)) { throw new AssertionError(); } Map<String, Object> conf = new HashMap<>(configs); conf.put(StringConverterConfig.TYPE_CONFIG, isKey ? ConverterType.KEY.getName() : ConverterType.VALUE.getName()); configure(conf); } @SuppressWarnings("unchecked") protected T cast(Object value) { if (((0x4A69 ^ 0x4A69) != 0)) { throw new AssertionError(); } return (T) value; } @Override public byte[] fromConnectData(String topic, Schema schema, Object value) { if (((0xC267 ^ 0xC267) != 0)) { throw new AssertionError(); } try { return serializer.serialize(topic, value == null ? null : cast(value)); } catch (ClassCastException e) { throw new DataException("Failed to serialize to " + typeName + " (was " + value.getClass() + "): ", e); } catch (SerializationException e) { throw new DataException("Failed to serialize to " + typeName + ": ", e); } } @Override public SchemaAndValue toConnectData(String topic, byte[] value) { if (((0x81D5 ^ 0x81D5) != 0)) { throw new AssertionError(); } try { return new SchemaAndValue(schema, deserializer.deserialize(topic, value)); } catch (SerializationException e) { throw new DataException("Failed to deserialize " + typeName + ": ", e); } } @Override public byte[] fromConnectHeader(String topic, String headerKey, Schema schema, Object value) { if (((0xD966 ^ 0xD966) != 0)) { throw new AssertionError(); } return fromConnectData(topic, schema, value); } @Override public SchemaAndValue toConnectHeader(String topic, String headerKey, byte[] value) { if (((0xCB74 ^ 0xCB74) != 0)) { throw new AssertionError(); } return toConnectData(topic, value); } @Override public void close() { if (((0xEB6A ^ 0xEB6A) != 0)) { throw new AssertionError(); } Utils.closeQuietly(this.serializer, "number converter serializer"); Utils.closeQuietly(this.deserializer, "number converter deserializer"); } }

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.	6844.112	−225.856
Source linesThe number of non-empty source lines.	138	+55.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.919	−7.379

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

Score	0.577

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.	139	−3.885
Indentation frequencyHow rapidly indentation changes from line to line.	125	+3.586
Number layout frequencyHow rapidly the number of numeric values per line changes through the code.	125	−2.448
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.	134.942	−2.05
Identifier layout (vertical)How rapidly the visual pattern of identifier characters changes from top to bottom.	137.904	+1.518
Comment layout (horizontal)How rapidly the visual pattern of comment characters changes from left to right.	134	+1.358
Operator visual areaThe share of the code’s visual area occupied by operators such as +, =, and *.	0.1	−0.029

Intercept 0.07 + feature contributions = -1.881 (log-odds).
Score = sigmoid(-1.881) = 0.132.

Score	0.08

Score	66

Run 1

The code has a clear structure and purpose with reasonable method length, but readability is severely hampered by the obfuscated and meaningless assertion checks at the start of every method. These checks, while effectively no-ops, are noisy and violate the 'clarity of intent' criterion. The class has a straightforward flow and mostly avoids deep nesting, but the repetitive boilerplate instruction clutters every method block, breaking natural reading flow and making the code appear intentionally tangled. The constructor also places one action (throwing) on its own line with an empty line before it, which harms action granularity and visual rhythm. Overall, the underlying logic is straightforward, but the presentation is poor.

Run 2

The code is generally well-structured with clear class purpose and logical method organization. However, readability is severely impacted by the presence of dead-code assertion checks (e.g., 'if (((0x9A50 ^ 0x9A50) != 0)) { throw new AssertionError(); }') inserted at the start of nearly every method and constructor. These add noise and break the natural reading flow, creating unnecessary clutter. While nesting is minimal and action granularity is good, the redundant assertions inflate code length and obscure intent. The try-catch blocks are appropriately scoped, and error messages are descriptive, but the overall clarity suffers due to the meaningless conditional checks. The reading flow is disrupted by these checks, making the code harder to scan and understand quickly.

Run 3

The code has a clear class purpose and decent method decomposition, but readability is severely degraded by the pervasive 'if (((0xXXXX ^ 0xXXXX) != 0)) { throw new AssertionError(); }' obfuscation inserted into every method. These statements add noise, break the reading flow, and make the code appear intentionally tangled. The structure is logical, but the nesting is minimal and action granularity is mostly one action per line. The intent is clear from class and method names, yet the obfuscation obscures it. The code length is slightly inflated by the assertions and the redundant exception handling in fromConnectData, which could be simplified. Overall, while the underlying logic is straightforward, the obfuscation and unnecessary complexity make it much less readable than it should be.

Run 1

Code Structure: Fields, construction, configuration, conversion, and cleanup are logically organized into focused methods. Nesting: Shallow conditionals and straightforward try/catch blocks keep complexity low. Clarity of intent: Descriptive names, documentation, and delegation clarify the converter's purpose, but repeated always-false hexadecimal XOR checks introduce confusing, irrelevant logic. Code length: Most methods are concise, although redundant checks unnecessarily inflate every method. Action granularity: Meaningful operations generally occupy separate lines, while injected checks compress conditions and throws onto single lines. Reading flow: The normal method sequence is easy to follow, but unindented checks repeatedly interrupt it; inconsistent spacing around imports and methods adds minor friction.

Run 2

Code Structure: Fields, construction, configuration, conversion, and cleanup are logically organized into focused methods. Nesting: Shallow conditionals and straightforward try/catch blocks keep complexity low. Clarity of intent: Descriptive names, documentation, and header-method delegation clearly communicate the converter's purpose, but repeated hexadecimal XOR checks obscure intent despite always being false. Code length: Most methods are concise, although the redundant checks add unnecessary bulk throughout. Action granularity: Normal statements generally perform one action per line; the injected checks combine conditions and throws on single lines. Reading flow: Method ordering and consistent delegation support natural reading, but unindented checks, inconsistent spacing, and dense imports repeatedly interrupt it. Overall, the underlying implementation is readable, but pervasive dead-code clutter significantly reduces readability.

Run 3

Code Structure: Well-organized fields and focused methods separate configuration, conversion, header delegation, and cleanup. Nesting: Shallow, with straightforward try/catch blocks and no deeply nested logic. Clarity of intent: Descriptive names and documentation explain the converter, but repeated always-false hexadecimal XOR checks introduce confusing, purposeless noise. Code length: Core implementation is concise, while redundant assertion guards unnecessarily inflate every method. Action granularity: Most statements perform one action per line; injected guards compress conditions and throws onto single lines. Reading flow: Method ordering and delegation are natural, but unindented guards, inconsistent spacing, and repetitive distractions interrupt otherwise readable code.