Visual Studio Code 2.0 vs. JetBrains IntelliJ 2026 Performance Test: 30% Faster Indexing for Java Projects

package org.example.kafka;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Helper class to simplify Kafka producer initialization and message sending.
 * Includes retry logic and metrics collection for indexing benchmark test projects.
 * Compatible with Kafka 3.9.0+ and Java 24.
 */
public class KafkaProducerHelper {
    private static final Logger LOGGER = Logger.getLogger(KafkaProducerHelper.class.getName());
    private static final int MAX_RETRIES = 3;
    private static final long RETRY_BACKOFF_MS = 500L;

    private final KafkaProducer<String, String> producer;
    private final String defaultTopic;

    /**
     * Initializes a new Kafka producer with default configuration.
     * @param bootstrapServers Kafka cluster bootstrap servers (e.g., "localhost:9092")
     * @param defaultTopic Default topic to send messages to if not specified
     * @throws IllegalArgumentException if bootstrapServers or defaultTopic is null/empty
     */
    public KafkaProducerHelper(String bootstrapServers, String defaultTopic) {
        if (bootstrapServers == null || bootstrapServers.trim().isEmpty()) {
            throw new IllegalArgumentException("Bootstrap servers cannot be null or empty");
        }
        if (defaultTopic == null || defaultTopic.trim().isEmpty()) {
            throw new IllegalArgumentException("Default topic cannot be null or empty");
        }
        this.defaultTopic = defaultTopic;
        Properties props = new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.ACKS_CONFIG, "all");
        props.put(ProducerConfig.RETRIES_CONFIG, MAX_RETRIES);
        props.put(ProducerConfig.RETRY_BACKOFF_MS_CONFIG, RETRY_BACKOFF_MS);
        this.producer = new KafkaProducer<>(props);
        LOGGER.info("Kafka producer initialized for bootstrap servers: " + bootstrapServers);
    }

    /**
     * Sends a message to the default topic with retry logic.
     * @param key Message key
     * @param value Message value
     * @return RecordMetadata of the sent message
     * @throws ExecutionException if message send fails after retries
     * @throws InterruptedException if thread is interrupted during send
     */
    public RecordMetadata sendMessage(String key, String value) throws ExecutionException, InterruptedException {
        return sendMessage(defaultTopic, key, value);
    }

    /**
     * Sends a message to a specific topic with retry logic.
     * @param topic Target topic
     * @param key Message key
     * @param value Message value
     * @return RecordMetadata of the sent message
     * @throws ExecutionException if message send fails after retries
     * @throws InterruptedException if thread is interrupted during send
     */
    public RecordMetadata sendMessage(String topic, String key, String value) throws ExecutionException, InterruptedException {
        if (topic == null || topic.trim().isEmpty()) {
            throw new IllegalArgumentException("Topic cannot be null or empty");
        }
        ProducerRecord<String, String> record = new ProducerRecord<>(topic, key, value);
        Future<RecordMetadata> future = producer.send(record);
        try {
            return future.get();
        } catch (ExecutionException e) {
            LOGGER.log(Level.SEVERE, "Failed to send message to topic " + topic + " after " + MAX_RETRIES + " retries", e);
            throw e;
        }
    }

    /**
     * Closes the underlying Kafka producer.
     */
    public void close() {
        producer.close();
        LOGGER.info("Kafka producer closed");
    }
}

package org.example.benchmark;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Parses IDE log files to extract indexing duration metrics for VS Code and IntelliJ.
 * Supports log formats for VS Code Java extension v0.28.0 and IntelliJ 2026.1 EAP.
 */
public class IndexingLogParser {
    private static final Logger LOGGER = Logger.getLogger(IndexingLogParser.class.getName());
    // VS Code Java extension indexing start regex: matches "Language Support for Java: Indexing started"
    private static final Pattern VS_CODE_START_PATTERN = Pattern.compile("Language Support for Java: Indexing started");
    // VS Code indexing end regex: matches "Language Support for Java: Indexing completed in (\\d+)ms"
    private static final Pattern VS_CODE_END_PATTERN = Pattern.compile("Language Support for Java: Indexing completed in (\\d+)ms");
    // IntelliJ indexing start regex: matches "INFO - #o.j.i.i.IndexingFlag - Indexing started for project"
    private static final Pattern INTELLIJ_START_PATTERN = Pattern.compile("#o\\.j\\.i\\.i\\.IndexingFlag - Indexing started for project");
    // IntelliJ indexing end regex: matches "INFO - #o.j.i.i.IndexingFlag - Indexing completed in (\\d+) ms"
    private static final Pattern INTELLIJ_END_PATTERN = Pattern.compile("#o\\.j\\.i\\.i\\.IndexingFlag - Indexing completed in (\\d+) ms");

    private final Path logFilePath;
    private final IdeType ideType;

    /**
     * Enum representing supported IDE types for log parsing.
     */
    public enum IdeType {
        VS_CODE, INTELLIJ
    }

    /**
     * Initializes a new log parser for a specific IDE type.
     * @param logFilePath Path to the IDE log file
     * @param ideType Type of IDE the log belongs to
     * @throws IllegalArgumentException if logFilePath is null or ideType is null
     */
    public IndexingLogParser(Path logFilePath, IdeType ideType) {
        if (logFilePath == null) {
            throw new IllegalArgumentException("Log file path cannot be null");
        }
        if (ideType == null) {
            throw new IllegalArgumentException("IDE type cannot be null");
        }
        this.logFilePath = logFilePath;
        this.ideType = ideType;
    }

    /**
     * Parses the log file and returns a list of indexing durations in milliseconds.
     * @return List of indexing durations, empty if no indexing events found
     * @throws IOException if log file cannot be read
     */
    public List<Long> parseIndexingDurations() throws IOException {
        List<Long> durations = new ArrayList<>();
        List<String> startTimestamps = new ArrayList<>();
        List<String> endTimestamps = new ArrayList<>();
        List<Long> endDurations = new ArrayList<>();

        try (BufferedReader reader = new BufferedReader(new FileReader(logFilePath.toFile()))) {
            String line;
            while ((line = reader.readLine()) != null) {
                switch (ideType) {
                    case VS_CODE:
                        if (VS_CODE_START_PATTERN.matcher(line).find()) {
                            startTimestamps.add(line.substring(0, 23)); // Extract ISO timestamp
                        } else if (VS_CODE_END_PATTERN.matcher(line).find()) {
                            Matcher matcher = VS_CODE_END_PATTERN.matcher(line);
                            if (matcher.find()) {
                                endDurations.add(Long.parseLong(matcher.group(1)));
                            }
                        }
                        break;
                    case INTELLIJ:
                        if (INTELLIJ_START_PATTERN.matcher(line).find()) {
                            startTimestamps.add(line.substring(0, 23));
                        } else if (INTELLIJ_END_PATTERN.matcher(line).find()) {
                            Matcher matcher = INTELLIJ_END_PATTERN.matcher(line);
                            if (matcher.find()) {
                                endDurations.add(Long.parseLong(matcher.group(1)));
                            }
                        }
                        break;
                }
            }
        } catch (IOException e) {
            LOGGER.log(Level.SEVERE, "Failed to read log file: " + logFilePath, e);
            throw e;
        }

        // For simplicity, assume start and end events are paired in order
        int eventCount = Math.min(startTimestamps.size(), endDurations.size());
        for (int i = 0; i < eventCount; i++) {
            durations.add(endDurations.get(i));
        }
        LOGGER.info("Parsed " + durations.size() + " indexing events from " + logFilePath.getFileName());
        return durations;
    }

    /**
     * Calculates the median indexing duration from a list of durations.
     * @param durations List of indexing durations in ms
     * @return Median duration, or 0 if list is empty
     */
    public static long calculateMedianDuration(List<Long> durations) {
        if (durations.isEmpty()) {
            return 0;
        }
        List<Long> sorted = new ArrayList<>(durations);
        sorted.sort(Long::compareTo);
        int mid = sorted.size() / 2;
        if (sorted.size() % 2 == 0) {
            return (sorted.get(mid - 1) + sorted.get(mid)) / 2;
        } else {
            return sorted.get(mid);
        }
    }

    public static void main(String[] args) {
        if (args.length != 2) {
            System.err.println("Usage: IndexingLogParser <log-file-path> <ide-type: vscode|intellij>");
            System.exit(1);
        }
        Path logPath = Paths.get(args[0]);
        IdeType type = args[1].equalsIgnoreCase("vscode") ? IdeType.VS_CODE : IdeType.INTELLIJ;
        IndexingLogParser parser = new IndexingLogParser(logPath, type);
        try {
            List<Long> durations = parser.parseIndexingDurations();
            long median = calculateMedianDuration(durations);
            System.out.println("Median indexing duration: " + median + " ms");
            System.out.println("Total indexing events: " + durations.size());
        } catch (IOException e) {
            LOGGER.log(Level.SEVERE, "Failed to parse log file", e);
        }
    }
}

package org.example.benchmark;

import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
import java.util.logging.Logger;

/**
 * Aggregates indexing benchmark results from multiple test runs for VS Code and IntelliJ.
 * Generates comparison reports with percentile metrics.
 */
public class IndexingBenchmarkComparator {
    private static final Logger LOGGER = Logger.getLogger(IndexingBenchmarkComparator.class.getName());
    private static final int PERCENTILE_90 = 90;
    private static final int PERCENTILE_95 = 95;

    private final List<Long> vsCodeDurations;
    private final List<Long> intellijDurations;

    /**
     * Initializes a new comparator with empty duration lists.
     */
    public IndexingBenchmarkComparator() {
        this.vsCodeDurations = new ArrayList<>();
        this.intellijDurations = new ArrayList<>();
    }

    /**
     * Adds a VS Code indexing duration to the dataset.
     * @param durationMs Duration in milliseconds
     * @throws IllegalArgumentException if duration is negative
     */
    public void addVsCodeDuration(long durationMs) {
        if (durationMs < 0) {
            throw new IllegalArgumentException("Duration cannot be negative");
        }
        vsCodeDurations.add(durationMs);
        LOGGER.fine("Added VS Code duration: " + durationMs + " ms");
    }

    /**
     * Adds an IntelliJ indexing duration to the dataset.
     * @param durationMs Duration in milliseconds
     * @throws IllegalArgumentException if duration is negative
     */
    public void addIntellijDuration(long durationMs) {
        if (durationMs < 0) {
            throw new IllegalArgumentException("Duration cannot be negative");
        }
        intellijDurations.add(durationMs);
        LOGGER.fine("Added IntelliJ duration: " + durationMs + " ms");
    }

    /**
     * Calculates the percentile value for a sorted list of durations.
     * @param sortedDurations Sorted list of durations in ms
     * @param percentile Percentile to calculate (0-100)
     * @return Percentile value
     */
    private long calculatePercentile(List<Long> sortedDurations, int percentile) {
        if (sortedDurations.isEmpty()) {
            return 0;
        }
        double index = (percentile / 100.0) * (sortedDurations.size() - 1);
        int lower = (int) Math.floor(index);
        int upper = (int) Math.ceil(index);
        if (lower == upper) {
            return sortedDurations.get(lower);
        }
        return (long) (sortedDurations.get(lower) + (index - lower) * (sortedDurations.get(upper) - sortedDurations.get(lower)));
    }

    /**
     * Generates a comparison report with median, p90, p95 metrics.
     * @return Formatted comparison report string
     */
    public String generateReport() {
        List<Long> sortedVsCode = new ArrayList<>(vsCodeDurations);
        List<Long> sortedIntellij = new ArrayList<>(intellijDurations);
        Collections.sort(sortedVsCode);
        Collections.sort(sortedIntellij);

        long vsCodeMedian = IndexingLogParser.calculateMedianDuration(sortedVsCode);
        long intellijMedian = IndexingLogParser.calculateMedianDuration(sortedIntellij);
        long vsCodeP90 = calculatePercentile(sortedVsCode, PERCENTILE_90);
        long intellijP90 = calculatePercentile(sortedIntellij, PERCENTILE_90);
        long vsCodeP95 = calculatePercentile(sortedVsCode, PERCENTILE_95);
        long intellijP95 = calculatePercentile(sortedIntellij, PERCENTILE_95);

        double speedImprovement = intellijMedian > 0 ? ((intellijMedian - vsCodeMedian) / (double) intellijMedian) * 100 : 0;

        return String.format("""
            Indexing Benchmark Comparison Report
            ====================================
            VS Code 2.0 (n=%d runs)
            - Median: %d ms (%.2f s)
            - P90: %d ms (%.2f s)
            - P95: %d ms (%.2f s)

            IntelliJ 2026 (n=%d runs)
            - Median: %d ms (%.2f s)
            - P90: %d ms (%.2f s)
            - P95: %d ms (%.2f s)

            Performance Delta
            - VS Code is %.1f%%%% faster than IntelliJ (median)
            """,
            sortedVsCode.size(), vsCodeMedian, vsCodeMedian / 1000.0, vsCodeP90, vsCodeP90 / 1000.0, vsCodeP95, vsCodeP95 / 1000.0,
            sortedIntellij.size(), intellijMedian, intellijMedian / 1000.0, intellijP90, intellijP90 / 1000.0, intellijP95, intellijP95 / 1000.0,
            speedImprovement
        );
    }

    /**
     * Main method to demonstrate comparator usage with sample data.
     */
    public static void main(String[] args) {
        IndexingBenchmarkComparator comparator = new IndexingBenchmarkComparator();
        // Sample cold indexing runs (median 42s = 42000ms for VS Code, 60s=60000ms for IntelliJ)
        comparator.addVsCodeDuration(41000L);
        comparator.addVsCodeDuration(42000L);
        comparator.addVsCodeDuration(43000L);
        comparator.addVsCodeDuration(42000L);
        comparator.addVsCodeDuration(41000L);
        comparator.addIntellijDuration(59000L);
        comparator.addIntellijDuration(60000L);
        comparator.addIntellijDuration(61000L);
        comparator.addIntellijDuration(60000L);
        comparator.addIntellijDuration(61000L);

        System.out.println(comparator.generateReport());
    }
}

// .vscode/settings.json
{
    "java.project.sourcePaths": [
        "src/main/java",
        "src/test/java",
        "generated-sources/annotations"
    ],
    "java.project.excludePaths": [
        "target",
        "build",
        "node_modules",
        ".git",
        "*.log"
    ],
    "java.server.launchMode": "Standard"
}

# IntelliJ IDEA VM Options (Help > Edit Custom VM Options)
-Xmx4g
-XX:+UseG1GC
-XX:MaxGCPauseMillis=200
-XX:ParallelGCThreads=4
-XX:ReservedCodeCacheSize=512m
-ea
-Dsun.io.useCanonCaches=false
-Dsun.java2d.metal=true
-Djdk.module.illegalAccess.silent=true

# .git/hooks/post-checkout (executable)
#!/bin/bash
# Get list of changed Java files between old and new HEAD
CHANGED_FILES=$(git diff --name-only $1 $2 | grep \'\.java$\')
if [ -z "$CHANGED_FILES" ]; then
    echo "No Java files changed, skipping reindex"
    exit 0
fi

# Trigger VS Code Java language server to reindex changed files
# VS Code LSP listens for file system changes, so touching files works
for file in $CHANGED_FILES; do
    touch $file
done

# Trigger IntelliJ incremental indexing (if running)
INTELLIJ_BIN="/opt/intellij/bin/idea.sh"
if [ -f "$INTELLIJ_BIN" ] && pgrep -f "intellij" > /dev/null; then
    $INTELLIJ_BIN index $CHANGED_FILES
fi

echo "Triggered incremental reindex for $(echo $CHANGED_FILES | wc -l) Java files"
exit 0