Tencent Music open-sources Jugg, an Android incremental build tool that achieves sub-3-second iteration by bypassing Gradle's fixed overhead via a sidecar compilation pipeline, using custom AAPT2 incremental linking, bytecode-level impact propagation, and JVMTI-based hot reload with hot-fix fallback, validated across 800k production builds.
Douyin's HarmonyOS team collaborated with DevEco Studio to optimize large-scale monorepo development, cutting code indexing time 80% (10→2 min), reducing IDE memory usage 65% (20→7 GB), and accelerating builds 30% (4.5→3 min), delivering a 50% overall efficiency gain now integrated into DevEco Studio 26.
The article examines how AI can be integrated into CI/CD pipelines to optimize builds, intelligently orchestrate tests, and enhance release decisions, presenting concrete implementations, performance gains, and four common pitfalls with mitigation strategies based on experiences from financial and SaaS projects.
The article examines how AI tackles three major CI/CD bottlenecks—long build times, flaky test failures, and manual release decisions—by introducing intelligent build optimization, test selection and diagnosis, risk‑quantified releases, and autonomous pipeline agents, backed by concrete metrics and case studies.
This article analyzes why Docker builds of Rust projects on Ubuntu get stuck updating the crates.io index for several minutes, explains Docker layer cache invalidation and BuildKit differences, and presents a reliable cargo‑chef based Dockerfile that reduces build time to seconds.
TypeScript 6.0, released in March 2026, introduces a suite of strategic defaults, new language features like Temporal API and RegExp.escape, and performance optimizations that streamline migration to the upcoming Go‑based compiler, boost React Native build times, and reduce silent type errors for modern web and mobile development.
This article explains how Maven‑mvnd accelerates Java project builds by using a long‑running daemon to eliminate JVM startup overhead, reduces resource consumption, improves multi‑module builds, and provides step‑by‑step installation, configuration, and usage instructions with practical command examples.
By tweaking Cargo's configuration to enable incremental compilation, increase codegen units, and employ sccache as a compiler cache, the author reduced a 22‑minute Rust build to under a minute, dramatically speeding up development feedback loops.
Facing 200‑second peak compile times, the FoxFriend iOS team replaced CocoaPods with Swift Package Manager and introduced a three‑layer interface‑implementation‑service architecture, reducing average incremental builds from 120 seconds to 50 seconds, saving 3.1 developer‑hours per day and achieving a 58% overall compile‑time reduction.
This article explains why Rust builds can be slow and provides a comprehensive set of practical techniques—including crate splitting, incremental compilation, linker selection, feature flag pruning, parallel jobs, caching, custom profiles, and Docker optimizations—to dramatically reduce compilation time and improve developer productivity.
This article details a deep engineering effort that transforms Kotlin Multiplatform on iOS into a first‑class development environment, covering the current pain points, root causes, a redesigned Bazel‑based build pipeline, parallel compilation techniques, performance gains, and future roadmap for mobile developers.
Maven‑mvnd, a Maven daemon that keeps a long‑running JVM alive, dramatically speeds up Java project builds by eliminating repeated JVM startup, reducing resource consumption, supporting parallel builds, and offering seamless migration from Maven, making it ideal for large multi‑module projects and CI/CD pipelines.
Maven‑mvnd introduces a long‑running daemon, GraalVM native execution and seamless Maven compatibility to dramatically reduce build time, lower resource consumption, and improve feedback loops for large or multi‑module Java projects.
This article explains how Maven‑mvnd addresses slow build times, high resource consumption, frequent build latency, and multi‑project build inefficiencies by using a long‑running daemon, GraalVM native executables, and seamless Maven compatibility, providing step‑by‑step installation and usage guidance.
The article explains how to build a custom Webpack plugin that uploads compiled static assets to a CDN, rewrites public‑path references to CDN URLs, and employs a hash‑based cache file to skip unchanged files, cutting build time from 40 seconds to 17 seconds in large projects.
This guide shows how to dramatically reduce Docker build times for frontend applications by pre‑installing node dependencies in a custom cache image, cutting the build from over 14 minutes to just over a minute while keeping the final image size unchanged.
This guide explains Docker's build process and offers practical techniques—such as structuring Dockerfiles, using multi‑stage builds, leveraging cache, shrinking images, parallel builds, BuildKit, and .dockerignore—to dramatically reduce build times and improve development efficiency.
This guide explains why IDEA's built‑in Maven builds are slow for large multi‑module projects and provides step‑by‑step instructions to enable multi‑threaded builds, delegate IDE builds to Maven, and add Maven cache extensions and configuration files to dramatically reduce build time.
This article explains why and how to migrate a complex Webpack‑based frontend project to Vite, using Simon Sinek's Golden Circle model, and details the step‑by‑step migration process, configuration changes, code snippets, and the resulting dramatic performance improvements.
This guide explains how to leverage Docker’s layer caching by separating dependency installation from source code copying, using Go as an example, and provides optimized Dockerfile patterns that cut build times and can be adapted to Node.js and Python projects.
Learn how to optimize Dockerfile builds by controlling cache usage, passing build arguments securely, handling special characters in passwords, and ensuring the build stops on errors, with practical code examples and step‑by‑step guidance for creating efficient, reliable container images.
This article details a three‑month, multi‑step migration of a large Android monorepo from AGP 7.2.2 to 8.2.2, covering Transform API deprecation, namespace handling, Gradle and JDK upgrades, build‑feature toggles, third‑party library adaptations, performance optimizations, and the troubleshooting of numerous compilation pitfalls.
By adding the @umijs/plugin-rspack to UmiJS projects and switching build scripts to rspack-dev and rspack-build, the team replaced Webpack with the Rust-based Rspack compiler, achieving over a two-fold reduction in compilation time—from 150 seconds to around 20 seconds—while preserving compatibility with existing plugins and Module Federation setups.
Mvnd, the Apache Maven Daemon built with GraalVM, runs as a native executable that eliminates JVM startup overhead, reduces memory usage, and parallelizes module builds, delivering up to several‑fold speed improvements over traditional Maven, as demonstrated with real‑world performance tests and simple installation steps.
The article analyzes why KAPT consumes 82% of Android‑Kotlin build time and presents three optimization strategies—enabling KAPT incremental compilation, migrating to the faster KSP processor, and creating an Android Studio plugin that generates code at development time—detailing their implementation steps, performance gains, and trade‑offs.
By leveraging native code tools like esbuild, caching strategies, and a custom pre‑compilation workflow that fakes Webpack's DllPlugin output, this article shows how Mars framework teams dramatically cut compilation times—up to 40% faster—while handling module resolution, resource handling, and cross‑platform challenges.
This article explains how to analyze and optimize Spring Boot Docker images by using the new layer‑building feature in Spring Boot 2.3, restructuring Dockerfiles, and employing multi‑stage builds to eliminate duplicate layers, dramatically shrink image size, and speed up image pushes.
This article walks through the author's journey of rebuilding an online resume with Vue 3 and TailwindCSS, explaining core Tailwind concepts, practical code examples, theme switching, and build‑time optimizations to achieve a maintainable, responsive, and lightweight frontend solution.
This article details how SoulAPP reduced its iOS clean‑build time from around 30 minutes to just a few minutes by applying precompiled headers, Xcode build‑setting tweaks, component‑based architecture, binary caching with Rugby, and targeted CI optimizations.
This article presents a step‑by‑step tutorial for creating a Vue 3 project using Vite and TypeScript, covering project scaffolding, routing and permission control, reusable component and directive encapsulation, custom hooks, Axios configuration, build optimization techniques, and essential TypeScript concepts.
Build OptimizationComponent EncapsulationFrontend Development
This article describes how a legacy data‑platform was refactored using a micro‑frontend architecture with Micro‑App, detailed design of main and sub applications, permission handling, routing, build tooling, and a Turborepo‑based monorepo strategy to improve development efficiency and deployment speed.
This article explains how to identify Jetifier warnings during Android compilation, why disabling Jetifier can break functionality, the limitations of the built‑in checkJetifier task, and presents a comprehensive solution using Gradle scripts, jetifier‑standalone, and custom tasks to migrate third‑party libraries to AndroidX while keeping build times low.
This article analyzes the existing issues of the Tencent Docs web‑gateway, explains why dependency versions and monorepo structure caused resource exhaustion, and details a series of engineering improvements using pnpm workspace, custom Docker contexts, lock‑file hooks, and soft‑link strategies to achieve a clean, reproducible build pipeline.
After upgrading Kuaishou's Android project from AGP 3.4.2 to 7.0.1, the APK size unexpectedly grew despite faster builds, leading to a deep investigation of Dex compression, R8 changes, and build tool versions, ultimately revealing a fastutil library mismatch that was resolved by forcing the correct version.
This article details a deep dive into Android Gradle build bottlenecks, analyzes the heavy Transform and dexMerge stages, and presents practical incremental build and hot‑update strategies—including code hooks, bucket handling, and dex reordering—that reduce typical build times from dozens of seconds to just a few.
This article provides an in‑depth overview of Webpack, covering its core concepts, entry and output settings, loaders, plugins, mode configurations, source‑map options, browser compatibility, and performance optimizations for both development and production environments.
The article details Meituan’s Rome front‑end framework, covering its business and technical background, the engineering ecosystem and evolution path, large‑scale upgrades, IDE‑based development assistance, efficiency and quality improvements, metric collection, real‑world adoption across 1,400+ projects, and future trends such as deeper dev‑chain integration and AI‑assisted coding.
maven‑mvnd, an Apache‑backed build tool that embeds Maven and leverages GraalVM, speeds up Java project compilation by reusing JVM processes, caching plugin classloaders, and retaining JIT‑generated code, with parallel module builds and simple mvn‑to‑mvnd command substitution, though JDK version quirks may require workarounds.
The article demonstrates a systematic approach to speeding up large Android Gradle builds by inspecting logs, stack traces, debugging plugins, profiling task execution with a custom plugin, and applying on‑demand configuration, caching, incremental and parallel compilation settings, which together cut build time by roughly 40 %.
This article explains the workings of SwiftLint, a static code analysis tool for Swift, covering its architecture, built‑in rules, configuration options, custom rule creation, UIWebView deprecation detection, and advanced build‑time optimizations to improve linting efficiency in mobile development projects.
The article explains Svelte’s plan to replace TypeScript with JSDoc, confirms the move with Rich Harris’s tweet, outlines benefits for compiler debugging and type safety, and compares the decision to Deno’s earlier internal migration to JavaScript to cut build time and bundle size.
This article describes how Ctrip's Train Ticket Android project reduced its clean Gradle build time by more than half using a module‑AAR approach, custom dependency substitution, Maven publishing, and automated tooling, while detailing the challenges, code changes, and performance results.
The article introduces Remote Execution Protocol, a solution to address challenges in Monorepo environments by enabling distributed compilation and building on centralized infrastructure, improving build efficiency and reliability.
This article explains how WeChat Android moved from Proguard to R8, detailing the performance and size gains, the new build workflow, the numerous optimization pitfalls encountered, and the concrete fixes applied to ensure stable releases and smaller Tinker patches.
This article details how the Omega platform reduced compilation time by up to 60% by adding Maven -am -pl flags, leveraging GoTemplate custom functions, and adjusting GitLab‑CI variables, providing a step‑by‑step verification of each attempt and the final solution.
FishUI is a cross‑platform React component library designed for Xianyu’s kun and web containers, offering unified APIs, automated environment detection, monorepo architecture with pnpm, lerna + nx versioning, custom build loaders, comprehensive testing, and documentation tooling to boost developer efficiency and maintainability.
A curated collection of recent frontend articles covering a code‑submission script, the Remesh DDD framework, CSRF security basics, GraphQL BFF implementation for cloud music, build‑time reduction tricks, and the Intl.Enumeration proposal reaching Stage 4, offering valuable insights for web developers.
This guide details how a massive music‑artist web application reduced its full build time from 140 seconds to 55 seconds and its incremental compile time from up to 80 seconds down to about 1 second by migrating from Webpack 4 to Webpack 5, including preparation steps, configuration changes, and common pitfalls.
The B‑Cut video‑editing app was transformed from a monolithic single‑project codebase into a component‑based modular architecture—introducing clear layers, Gradle‑driven unified configuration, independent library/application modules, strict dependency and resource conventions, and a fast‑compile system—thereby cutting build times, eliminating merge conflicts, and enabling reusable components across teams.
This article describes ByteDance's cloud‑based CocoaPods dependency analysis service, explaining its background, architecture, caching mechanisms, material pruning, and decision‑making strategies that together reduce iOS build dependency resolution time by over 60% while maintaining correctness and low integration cost.
This article details how the CTrip iOS team streamlined componentized development by introducing binary debugging, automating source‑code linking, solving M1 simulator clipboard issues, and building a visual ZTPodTool that reduces pod install time and accelerates test‑package generation.
This collection highlights recent front‑end engineering insights, covering bundle‑less approaches with tools like Snowpack and Vite, dramatic build‑time reductions for large Vue/TypeScript applications, low‑code platform implementation for multi‑tenant CRM, and design strategies that enhance information‑reading experiences.
By disabling Jetifier through a custom Gradle plugin, fully migrating all Support libraries to AndroidX, and adding CI guardrails to block legacy dependencies, the team cut Android Studio sync time by roughly two and a half minutes and improved incremental build speed by 28% without sacrificing build stability.
This article describes the challenges of handling massive art assets in the Nishuihan MMO, introduces a distributed build pipeline that separates resource processing, incremental packaging, and multi‑machine scheduling, and details a series of optimizations that reduced the overall build time from over ten hours to about one and a half hours while supporting multiple functional teams.
Covering webpack’s evolution from early module systems to modern code‑splitting, the article explains core concepts—entries, loaders, plugins, and chunks—then contrasts the deprecated CommonsChunkPlugin with the heuristic‑driven SplitChunksPlugin, offering configuration tips and best practices for efficient vendor, async, and route‑based bundling.
This article details JD's Android app migration to the R8 compiler, explains differences between ProGuard and R8, analyzes the impact of the -useuniqueclassmembernames rule, addresses v1 signing loss after AGP 3.6.4 upgrade, and provides practical solutions for build‑process ordering and packaging pitfalls.
This article examines the challenges of managing large monorepos, outlines the essential capabilities such as dependency management, task orchestration and version publishing, compares popular tools like Turborepo, Rush and pnpm, and provides practical guidance on scope definition, parallel execution, and cloud caching to accelerate builds.
Zhang Yang explains how Bilibili’s massive Android monorepo was accelerated by a fast‑build Gradle plugin that replaces unchanged modules with cached AARs versioned by Git SHA, validates them with an R8‑based A8 check, and leverages cloud compilation and independent build units, cutting full builds from ~30 minutes to under 6 minutes locally and about 3 minutes in the cloud.
This article explains how Umi 4 accelerates the build phase by replacing traditional terser and cssnano compressors with esbuild, details configuration for JS and CSS minifiers, describes dependency compilation optimizations, and introduces remote caching to further reduce build times.
The article explains how Youku tackled explosive module growth by introducing an iOS plugin system that decouples components, improves compile times, reduces disk and memory usage, enables simulator support, and provides automated dependency management, ultimately boosting development efficiency and product quality.
Youku tackled explosive module growth and tangled dependencies by decomposing its iOS app into independent, Xcode‑based plugins that define modules and relationships, dramatically speeding compilation, enabling hot‑reload and simulator builds, cutting disk usage, and improving debugging, monitoring, and specialized app development.
This article explains how a large cloud‑based project reduced its 14‑minute Webpack build to a fraction of the time by upgrading Node, enabling Webpack 5's filesystem cache, adopting Rust‑based SWC, and applying advanced cache strategies such as unsafeCache, safeCache, and LRU management.
This article analyzes the slow build process of Dada's massive frontend platform, identifies bottlenecks in dependency installation and webpack compilation, and presents practical optimizations such as node_modules caching, cp command adjustments, Babel loader caching, and other webpack tweaks that reduced average build time from 600 seconds to around 100 seconds.
At SEE Conf 2022, Ant Group’s frontend lead Yun Qian detailed Umi’s evolution, covering its compilation-time architecture, dependency pre‑bundling, multi‑build engine, performance optimizations like MFSU, and the balance between community openness and internal constraints, offering practical lessons for modern frontend development.
The article introduces mvnd, a GraalVM‑based Maven daemon that accelerates builds by reusing processes, leveraging JIT compilation, and supporting parallel execution, then details installation across Linux, macOS and Windows, configuration tips, and usage commands, showing how it narrows the performance gap with Gradle.
This article explains how to use Webpack's stats object to generate a JSON report of module dependencies and compilation performance, enabling developers to visualize the dependency graph, identify impact of changes, and fine‑tune build speed and bundle size.
This article outlines four practical strategies to accelerate CI/CD pipelines—using a self‑hosted GitLab Runner, caching build dependencies, employing lightweight Alpine images for CI jobs, and conditionally running jobs only when relevant files change—to improve developer efficiency.
The article introduces ARK, a dynamic development mode for iOS that replaces traditional CocoaPods‑Xcode workflows with a lightweight 2 MB repository and real‑time library conversion, dramatically cutting pod install and compile times, improving build success, and enabling fast, component‑focused development using ByteDance’s MBox tool.
RocketX is an open‑source Gradle plugin that speeds up large Android projects by dynamically swapping unchanged modules with pre‑built AAR artifacts, compiling only the changed modules and the app module, thereby reducing full‑build times by over 300% while preserving project integrity.
The article introduces ARK, a dynamic iOS development mode that replaces traditional CocoaPods‑Xcode workflows with a lightweight repository and on‑demand component fetching, dramatically cutting pod install, compile, and index times while preserving full development capabilities.
Facing 8‑minute Gradle syncs, frequent GC‑over‑limit errors, and excessive memory usage, the team diagnosed severe memory leaks in Android build configurations, applied variantFilter filtering, tuned JVM arguments, and optimized daemon settings, ultimately reducing sync time to 1.5 minutes and cutting CI build time in half.
This article analyzes a Maven multi‑module project where a static constant change in a shared API module caused unexpected Redis key errors at runtime due to JDK compile‑time constant folding, outlines the investigation steps, identifies the root cause, and provides best‑practice recommendations for version management.
This article explains why Webpack 4 generates an unnecessary base.js file when extracting common CSS with mini‑css‑extract‑plugin, analyses the underlying bootstrap dependency issue, and presents a custom plugin that adjusts the compilation graph to move the empty JS module, suppress the extra chunk, and correctly emit the shared base.css file.
An in‑depth case study of Alibaba.com’s iOS client reveals how architectural decay—manifested as tangled module dependencies, slow builds, and outdated tooling—drains developer productivity, and outlines data‑driven, layered, and automated strategies—including dependency analysis, modular refactoring, and CI safeguards—to restore a healthy, scalable mobile codebase.
Upgrading a project from Android Gradle Plugin 3.5 to 4.1.3 required applying official migration steps, adjusting deprecated fields, resource paths, manifest tasks, ASM version, disabling configure‑on‑demand and the new zipflinger packager, and fixing NDK configuration, which together yielded roughly 36 % faster builds and a 5 MB smaller APK.
Upgrading from AGP 3.5.0 to 4.1.0 dramatically simplifies R class generation, removes redundant R files via R8‑based inlining, reduces APK size by ~7 MB, and speeds up release builds by over ten minutes, as demonstrated through detailed build‑artifact comparisons and Gradle task analysis.
The article examines why software architectures inevitably degrade as projects grow, outlines the stages of decay, critiques common quick fixes, and proposes strategic solutions such as adopting new technologies, refactoring into isolated components, using separate processes, and building loosely coupled platforms to sustain long‑term maintainability.
This article explains how replacing a Webpack‑based React component workflow with Vite and its plugins enables on‑demand type extraction, markdown‑driven usage docs, instant hot‑module replacement, and efficient build processes for large component libraries.
To cut full‑build times in large Android projects, the team pre‑compiles each library module into an AAR, publishes it to a Maven repository, computes a content‑plus‑dependency‑graph hash to detect existing AARs, and automatically swaps project dependencies for matching AARs while addressing duplicate‑class and version conflicts.
Taro 3.2 introduces a revamped compilation pipeline that eliminates intermediate code, adds native source‑map support, supports React Native 0.64 with Hermes, expands APIs and components, enables on‑demand imports, and provides clear migration steps for both new and existing projects, while outlining future roadmap and community resources.
The article shares how Ant Group's frontend engineering team improves build speed with cloud functions and multi‑process webpack, adopts Apple M1 hardware, tackles Android cloud‑device debugging, and launches a lightweight IDE, illustrating the challenges, innovations, and future directions of modern frontend development.
Facing sluggish Gradle builds for a large Android news app, the team applied componentized compilation, Artifactory caching, minimal compile mode, parameter tuning, and remote compilation via SSH, achieving up to 90% faster non‑incremental builds and 75% faster incremental builds while maintaining stability across the CI pipeline.
This article explains the inner workings of #import, precompiled headers (PCH), header maps (hmap), Clang modules, and Swift‑Objective‑C interop, showing how they affect compilation speed, robustness, and scalability in large iOS projects and offering practical optimization techniques.
The article presents Meituan’s cocoapods‑hmap‑prebuilt plugin, which creates per‑pod and shared header‑map files to replace CocoaPods’ default header search paths, eliminates duplicate headers and disables Xcode’s native map, delivering over 45 % faster builds and more than 50 % shorter packaging times in large iOS projects.
This article describes how the iOS team reduced build times by binaryizing nearly 100 CocoaPods components, detailing macro handling, packaging with cocoapods‑packager, storage strategies, dependency switching mechanisms, and CI integration to streamline development and deployment.
This guide explains how misusing Maven's optional and scope elements can bloat JAR/WAR files and slow compilation, and shows practical configurations—including code examples and dependency inheritance scenarios—to reduce artifact size, improve build speed, and avoid version conflicts.
The team built a low‑intrusion Gradle plugin that detects changed source and resource files, performs precise dependency analysis, leverages aapt2 for incremental resource compilation, and injects updated Dex and assets into the running app, cutting full Android builds from 418 seconds to 13 seconds and boosting daily developer productivity on large projects such as QQ Music.
By profiling the idle‑local Java backend, the author cut build, deployment, and startup times by over 30 seconds per cycle through asynchronous Spring bean initialization, selective dependency pruning, layered Docker image construction, and streamlined shutdown, demonstrating a comprehensive, reusable optimization strategy for faster releases.
The article details how the Anjuke iOS client was transformed into a platform‑shared architecture through the “Jupiter Plan”, describing background challenges, multi‑endpoint reuse, shell project separation, build‑speed optimizations, and supporting tools that together boosted development efficiency.
This article analyzes the pain points of iOS development at Xianyu—complex environment setup, massive CocoaPods downloads, and slow branch‑switch builds—and details a hybrid Docker‑based solution plus artifact caching that reduces build time from half an hour to under five minutes.
Spring Boot’s shift from Maven to Gradle, introduced in version 2.3.0.M1, dramatically cuts build times—from over an hour with Maven to under ten seconds on average with Gradle—by enabling incremental and parallel builds, while still supporting Maven for dependency management.
The Tongtian Tower visual CMS team optimized its build, dependency packaging, and pre‑release workflows in Q1 2020 by migrating to webpack 4, parallelizing template builds, and improving FTP uploads, cutting total release time from 358 seconds to 160 seconds and saving roughly 7 hours of developer effort per week.
This article presents a complete iOS app slimming strategy that combines official App Thinning techniques, detailed build‑time optimizations, file‑type specific reductions, and a git‑hook based resource compression workflow, demonstrating a reduction from 154.7 MB to 90 MB in a real project.
The article explains how a Maven plugin can automatically compile only changed files and skip unit tests when code is unchanged, dramatically reducing build time, and provides step‑by‑step instructions with the necessary pom.xml configuration and a sample XML snippet.
Long‑running software projects inevitably see their initially clean architectures degrade as codebases grow, teams expand, and build times increase, but by understanding the stages of architectural decay and applying practices such as modular isolation, incremental builds, tooling upgrades, and disciplined refactoring, teams can slow or reverse this corrosion.
By migrating all Dada front‑end projects to an automated CI build platform, introducing Docker volume caching and internal npm mirrors, we eliminated manual steps, reduced build time by more than half, and saved roughly 40 hours of developer time each month.