Tagged articles
startup performance
23 articles · Page 1 of 1
The author traces a 6-second Java service startup delay to eager initialization of large objects via static final fields, demonstrates how Java 27's LazyConstant API enables thread-safe, one-time lazy initialization with constant semantics, and explains when to use it versus Spring @Lazy, caches, or double-checked locking.
JEP 531Java 27Kubernetes scaling
0 likes · 19 min read

JEP 544 introduces ahead-of-time compilation to HotSpot JVM in JDK 28, allowing Java applications to cache optimized native code from training runs and achieve 65-80% faster startup without sacrificing JIT's dynamic optimization, making Java competitive for serverless and cloud-native deployments.
AOT CompilationGraalVMHotSpot JVM
0 likes · 12 min read

A real-world case study shows how systematic profiling with Spring Boot Actuator and JFR, combined with scan-scope reduction, selective @Lazy on external clients, HikariCP deferred connection, and ApplicationReadyEvent-driven async initialization cut a Spring Boot 3.1.5 order-service startup from 6.2 seconds to 1.8 seconds on Java 17.
Event-Driven InitializationHikariCPSpring Boot
0 likes · 22 min read

The article explains why Linux servers often experience slow boot times, outlines a systematic method to analyze each stage of the boot chain—from firmware to user services—identifies common bottlenecks, and provides concrete systemd, BIOS, GRUB, initramfs, and service‑level optimizations with commands and verification steps.
GRUBLinuxboot optimization
0 likes · 33 min read

This article dissects Claude Code’s 12 ms --version response and its 1.1 MB lazy‑loaded footprint, explaining a four‑layer startup chain that uses fast‑path handling, parallel prefetch, selective lazy imports, memoized global initialization, and compile‑time dead‑code elimination to achieve near‑instant CLI launch.
BunTypeScriptcli
0 likes · 15 min read


21CTONov 5, 2025 · Fundamentals
PEP 810 introduces explicit lazy imports to Python, allowing modules to be loaded only when needed, which can significantly reduce startup time while keeping the feature optional and backward‑compatible, marking a major step forward after years of community debate and earlier failed attempts.
PEP 810language designlazy import
0 likes · 3 min read

This article analyses why Spring Boot startup can take dozens of seconds, breaks down the most time‑consuming phases such as prepareEnvironment and refreshContext, shows profiling code and screenshots, compares a simple MVC demo with a real‑world project, and identifies external client connections and configuration loading as the biggest bottlenecks.
JavaSpringBootbackend development
0 likes · 13 min read

This article explains why a SpringBoot service took 6‑7 minutes to start, shows how to pinpoint the bottlenecks using SpringApplicationRunListener and BeanPostProcessor, and presents concrete optimizations—reducing scan paths, manually registering beans, and fixing cache auto‑configuration—to shrink the local startup time to about 40 seconds.
Auto-configurationBeanPostProcessorCache
0 likes · 18 min read

This article explains what Java Class Data Sharing (CDS) is, walks through training and running a Spring Boot application with CDS, and demonstrates how startup time can be reduced by nearly one second, while comparing CDS with CRaC and GraalVM for Java performance optimization.
Class Data SharingJVMJava
0 likes · 9 min read

This article explains what Java Class Data Sharing (CDS) is, provides detailed commands for training and using a CDS archive with a Spring Boot demo, and shows how startup time can be cut by nearly one second, helping developers choose the right Java startup optimization technique.
CDSClass Data SharingJava
0 likes · 8 min read

Mach‑O is the macOS and iOS binary format whose header, load commands, and __TEXT/__DATA sections define executable, library, and symbol information, enabling developers to understand loading, linking, and startup performance, and to implement custom initialization hooks or modular launch tasks via custom data sections.
Binary FormatClangMach-O
0 likes · 10 min read

This article analyzes Baidu App's Android launch performance, explaining the startup process, identifying bottlenecks, and detailing practical optimizations—including task scheduling, KV storage redesign, lock improvements, and low‑level system tweaks—backed by code samples and measurable results.
AndroidLock RefactoringSharedPreferences
0 likes · 21 min read

Baidu dramatically accelerated its Android app’s launch by dissecting the cold‑start sequence, applying full‑path analysis, leveraging tracing tools, introducing a priority‑aware task‑scheduling framework, replacing SharedPreferences with the binary UniKV store, eliminating lock contention, and tightening thread, I/O, and library loading, which together cut ANR rates and boosted user retention.
ANRAndroidKV storage
0 likes · 24 min read

This article investigates whether Spring’s class‑path bean scanning can be made concurrent, walks through source‑code verification, examines relevant GitHub issues and official responses, and finally offers practical tips for speeding up Spring Boot startup.
AOT CompilationGitHub issuesSpring
0 likes · 13 min read

This article explains how to build a high‑precision Android startup performance pipeline by selecting the right tracing tool, extending Perfetto with custom Gradle instrumentation, handling edge‑case trace mismatches, and using Trace Processor’s Python API for automated wall‑time and CPU‑time regression detection.
AndroidGradlePerfetto
0 likes · 30 min read

This article summarizes the CovalenceConf 2019 talk on VS Code’s startup performance, detailing measurement practices, code‑size reductions, lifecycle re‑ordering, V8 code caching, requestIdleCallback usage, and perceived‑performance tricks that together shrink launch time from seconds to under one second.
ElectronJavaScriptV8
0 likes · 17 min read

This article summarizes the key techniques presented at CovalenceConf 2019 for optimizing Visual Studio Code's startup performance, covering measurement, bundling, V8 code caching, lifecycle phase ordering, requestIdleCallback, and perceived‑performance tricks that together reduce launch time to under one second.
ElectronV8VS Code
0 likes · 13 min read

This article explains how using @Configuration(proxyBeanMethods=false) in Spring Boot 2.2 reduces bean proxy generation, cuts startup time by several seconds, and provides step‑by‑step code examples, performance logs, and best‑practice recommendations for modern Java microservices.
CGLIBConfigurationSpring Boot
0 likes · 7 min read

The article documents a series of Spring Boot 2.1 startup benchmarks on OpenJDK 11, exploring fifteen different tweaks—from using WebFlux instead of WebMVC to enabling AppCDS and disabling unnecessary libraries—showing how each change impacts launch time and culminating in a sub‑second startup.
JavaSpring Bootbenchmark
0 likes · 11 min read

This article walks through a series of practical experiments—ranging from baseline Flux tests to lazy initialization, JVM options, dependency exclusions, and AppCDS—to dramatically reduce Spring Boot application startup time, ultimately achieving sub‑second launch speeds.
JavaSpring Bootbenchmark
0 likes · 10 min read

This article explains how to measure and analyze Android SDK startup performance by defining cold, warm, and lukewarm launches, describing a testing methodology that uses specific device, network, and process conditions, and providing ADB commands and shell scripts to capture total launch time.
AndroidSDK TestingWarm Start
0 likes · 7 min read

This article explains how to measure, analyze, and dramatically improve iOS app launch performance through profiling, removing unused code, compressing assets, and restructuring view controller loading, illustrated with a real‑world WiFi manager case study.
dyldiOSmobile development
0 likes · 18 min read

This article explains how Tencent's myAPM platform provides method‑level injection and monitoring for mobile apps, enabling automatic APK size analysis, lag detection, startup performance tracking, and core‑link analysis to help developers identify and eliminate unused code and performance bottlenecks.
APK size analysisAPMMethod Injection
0 likes · 14 min read
