Tagged articles
build system
43 articles · Page 1 of 1
Phoronix benchmarks reveal Linux kernel defconfig compilation dropped to ~15 seconds on dual AMD EPYC 9575F servers (128 cores) thanks to Kbuild optimizations by Lorenzo Stoakes, including AI-assisted bottleneck analysis, with allmodconfig down to 134 seconds; next-gen hardware may push defconfig under 10 seconds.
AI-assisted optimizationAMD EPYCKbuild
0 likes · 8 min read

This tutorial walks through configuring the Python interpreter in Sublime Text by editing the Python.sublime-build file to add the Python path and UTF-8/GBK encoding, resolving decode errors and enabling script execution via Ctrl+B or the Build menu.
ConfigurationPythonSublime Text
0 likes · 5 min read


21CTOOct 4, 2026 · Fundamentals
Zig 0.17.0 introduces a two-phase build system separating configuration and execution, a Build Server Protocol for editor integration, a self-hosted incremental ELF linker on x86_64-linux, and a thread-safe SafeAllocator cutting memory use by 50% and test time by 25%, alongside breaking language semantic changes like @bitCast redefinition.
ELF linkerSafeAllocatorSystems Programming
0 likes · 7 min read


TonyBaiAug 4, 2026 · Backend Development
Wails v3 Beta, released after three years of development, introduces an explicit application lifecycle API, native multi‑window capabilities, static‑analysis‑driven Go‑to‑TypeScript bindings, a readable Taskfile build system, experimental iOS/Android support, and a detailed migration path from v2, all illustrated with step‑by‑step code examples.
Beta ReleaseGoWails
0 likes · 24 min read

The article contrasts Bun's 11‑day AI‑driven rewrite of 500 k lines of Zig to Rust with Roc's 487‑day manual rewrite of a 300 k‑line Rust compiler to Zig, analyzing the engineering motivations, performance benchmarks, memory‑safety bug counts, and ecosystem trade‑offs that led each team to choose its language.
CompilerRocRust
0 likes · 19 min read

This article details Kuaishou's systematic compiler and build‑system optimizations—including AutoFDO, ThinLTO, BOLT, and a newly improved Propeller—showing how they reduced compilation time from hours to seconds, cut CPU usage by 10%, and achieved up to 15% performance gains while solving profile‑staleness and integration challenges.
AutoFDOBoltCompiler
0 likes · 25 min read

The article explains why the traditional setup.py build script is outdated, outlines the problems it causes, and shows how adopting a declarative pyproject.toml file modernizes Python packaging, improves maintainability, and unifies tool configuration.
Pythonbuild systempackaging
0 likes · 3 min read

This article walks readers through the inner workings of Linux kernel module Makefiles, demonstrating how to clone example projects, interpret build logs, and apply three powerful debugging techniques—including recursive vs. non‑recursive make, detailed variable tracing, and on‑the‑fly warnings—to demystify the compilation process.
DebuggingMakefilebuild system
0 likes · 38 min read

The article explains how Google tackles the costly problem of dead code in its massive monorepo by using the Sesenmann automated deletion system, which leverages build‑system dependency graphs, activity signals, and graph‑analysis algorithms to safely identify and remove unused C++ code while addressing cultural resistance among engineers.
Dead Codeautomationbuild system
0 likes · 10 min read

Meson and Bazel are modern build systems with distinct design philosophies, target users, and features; Meson emphasizes simplicity, Python‑like DSL, and fast incremental builds for beginners, while Bazel, developed by Google, focuses on scalability, reproducibility, remote caching, and complex dependency management for large‑scale projects.
BazelMesonbuild system
0 likes · 4 min read

This article provides a step‑by‑step guide to using CMake for cross‑platform builds, covering fundamental concepts, basic project setup, adding versioning and configuration headers, creating libraries, optional components, installation, testing, packaging with CPack, dashboard integration, and practical usage within JetBrains CLion for C/C++ development.
C++CI/CDCMake
0 likes · 33 min read

This article outlines a browser‑based real‑time build, compile, and preview solution for front‑end material management, detailing its background, core requirements, development and compilation workflows, usage process, and the benefits of a unified, efficient platform for reusable UI components.
build systemcomponent librarymaterial management
0 likes · 8 min read

Bilibili’s iOS team migrated from the cumbersome WORKSPACE model to Bazel Modules, adopted the community‑maintained rules_xcodeproj to replace Tulsi, and built a custom Fastbuild rule that hashes source files to reuse binaries, cutting incremental build times from dozens of minutes to under two.
BazelFastbuildModules
0 likes · 22 min read

This article provides a comprehensive comparison of Bazel and Gradle build systems, examining their design philosophies, concurrency, incremental compilation, configuration phases, performance benchmarks, and ecosystem support, particularly in the context of large‑scale Android monorepo projects, to help developers choose the appropriate tool.
AndroidBazelGradle
0 likes · 26 min read

The article details ByteDance's transition from CocoaPods‑based component management to a Bazel‑driven monorepo build system, describing the problems faced, the two‑stage migration process, the BitSky build service architecture, custom plugin mechanisms, and the performance gains achieved after the migration.
BazelCI/CDautomation
0 likes · 24 min read

The article examines Google’s massive monorepo, the challenges of dead code, the Sensenmann project’s automated deletion using build‑graph analysis and Tarjan’s algorithm, discusses whitelist handling and communication strategies, and concludes with a brief promotion for a Python continuous‑deployment course.
Dead CodeTarjan algorithmbuild system
0 likes · 11 min read


21CTOMay 14, 2023 · Operations
Google’s massive monorepo contains billions of lines of code, and the Sesenmann project automatically identifies and removes dead code by analyzing build dependencies, runtime logs, and test coverage, dramatically cutting maintenance costs while navigating technical and cultural challenges.
build systemcode cleanupmonorepo
0 likes · 11 min read

This article examines the drawbacks of multi‑repo development for large mobile apps, explains the concepts of monorepo and full‑source, and details ByteDance's BitSky implementation—including migration phases, Bazel build migration, dependency management, developer tools, and measurable efficiency gains.
BazelDependency ManagementDevOps
0 likes · 17 min read

This article explains how Xcode organizes projects through xcworkspace and xcodeproj bundles, details the structure of the project.pbxproj file, describes the role of PBX objects such as PBXFileReference and PBXGroup, and shows how to manipulate Xcode projects programmatically using the Xcodeproj Ruby gem.
RubyXcodeXcodeproj
0 likes · 24 min read

This article details the challenges and step‑by‑step solutions the NetEase Cloud Music iOS team used to modularize legacy Objective‑C libraries, enabling seamless Swift interop through modulemap generation, CocoaPods configuration, and custom build scripts while addressing macro, header, and static‑library issues.
CocoaPodsInteropModules
0 likes · 14 min read

This article details Baidu Live's transformation from a monolithic Xcode project into a modular, EasyBox‑driven SDK with multi‑repo support, automated integration tools, and differentiated builds, highlighting the engineering challenges, step‑by‑step refactor, and measurable efficiency gains.
EasyBoxMulti-repoSDK Architecture
0 likes · 9 min read

Bilibili migrated its iOS codebase from a fragmented polyrepo to a unified monorepo and adopted Google‑backed Bazel, enabling clear BUILD files, atomic commits, fast parallel and cached builds, reliable dependency resolution, easy Xcode integration via Tulsi, and extensible custom rules for scalable, maintainable development.
BazelCI/CDbuild system
0 likes · 21 min read

This article introduces the fundamentals of Gradle as a universal build automation tool and explains how the Android Gradle Plugin integrates with it, covering project structure, build files, tasks, the three build lifecycle phases, DSL syntax, and provides example Groovy/Kotlin scripts for configuring Android applications.
AGPAndroidDSL
0 likes · 8 min read

The article explains how Google and Facebook avoid Docker images by using monolithic repositories and unified build systems, detailing alternative packaging methods like tarballs, XAR, overlay filesystems, and the challenges of achieving efficient layered caching without containers.
Docker-alternativeXARbuild system
0 likes · 18 min read

The article explains how Google and Facebook’s monolithic repositories and unified build systems let them avoid Docker images by using direct module transfer, tarballs, XAR files, and overlay filesystems, while highlighting the technical trade‑offs and challenges of layered caching in large‑scale clusters.
Dockerbuild systemcontainer
0 likes · 20 min read

CMake 3.19.2 introduces Apple ARM support, new variables for host processor selection, enhanced error handling, updated FindHDF5, Java test controls, CI job updates, and numerous bug fixes across compilers, PCH, and platform detection, making the cross‑platform build system more robust and flexible.
Apple SiliconCMakeVersion 3.19.2
0 likes · 3 min read


phodalDec 14, 2020 · Mobile Development
This article examines the end‑to‑end workflow of Android app development, detailing how IDEs interact with Gradle, how tasks and dependency resolution are orchestrated, and what infrastructure underlies modern language tooling and build systems.
AndroidDependency ManagementGradle
0 likes · 8 min read

iQIYI Knowledge implemented a three‑layer componentization architecture—base, functional, and business components—combined with protocol‑based service registration, URL routing, and an automated build pipeline, enabling cross‑platform code reuse, independent testing, and faster integration while reducing coupling and maintenance overhead.
AndroidComponentizationarchitecture
0 likes · 14 min read


Aotu LabJan 9, 2020 · Frontend Development
This article explains the motivations behind Taro 2.0’s CLI overhaul, details how the custom build system was replaced by Webpack, provides step‑by‑step migration instructions, showcases new hooks, loader and plugin configurations, and outlines future plans for the framework.
CLIJavaScriptTaRO
0 likes · 11 min read


Aotu LabDec 4, 2019 · Frontend Development
The article explains how Taro's fast‑evolving 1.x series led to a disruptive redesign of its CLI, replacing the custom build system with webpack in version 2.0, and outlines the resulting maintenance, stability, and extensibility benefits along with upgrade guidance.
Mini ProgramsTaRObuild system
0 likes · 5 min read

Senior Baidu engineer Guo Jin explains how the company tackles large‑scale front‑end challenges through a “big” engineering approach, using architectural splitting, componentization frameworks, advanced dependency tools, and the EasyBox solution—integrating MGIT, binary management, and a build system—while the Tekes platform automates version publishing and streamlines development across matrix products.
binary managementbuild systemengineering platform
0 likes · 11 min read

At the 2019 Hangzhou Yunqi Conference, Amap’s technical team detailed how they fused separate car‑machine and mobile clients into a unified engine, instituted architecture governance that cut compile and release times dramatically, and built a C++‑based dynamic rendering system that unifies Android and iOS, enabling rapid, cross‑platform feature delivery.
architecturebuild systemdynamic
0 likes · 11 min read


21CTOOct 22, 2019 · Fundamentals
This article translates and summarizes the key software engineering practices at Google, covering their unified source repository, build system, code ownership, automated testing, code review process, error tracking, language policies, debugging tools, release engineering, project and personnel management, and training, illustrating how these practices contribute to the company's success.
Googlebuild systemcode review
0 likes · 32 min read

This step‑by‑step tutorial shows beginners how to set up the Python interpreter in Sublime Text, modify the build file with the correct path and encoding, and run Python scripts instantly using Ctrl+B or the Build menu, eliminating common decode‑error issues.
IDE configurationPythonSublime Text
0 likes · 4 min read

The article describes a comprehensive CI/CD platform built on Jenkins and JBPM that streamlines compilation, process control, and external system integration for a large‑scale, plugin‑driven mobile app, addressing challenges such as build speed, code download, and task tracking.
CI/CDJBPMJenkins
0 likes · 9 min read

This tutorial shows how to write a concise Makefile that automatically discovers all .c files in a directory, builds each into an executable with matching names, and supports easy addition of new programs with a single make command.
GCCMakefileautomation
0 likes · 4 min read

PEP 518 introduces a declarative pyproject.toml file that lets Python projects explicitly declare build‑system dependencies, solving the paradox of needing to run setup.py to discover its own requirements and enabling tools like pip to ensure necessary packages are installed before building.
PEP 518build systempackaging
0 likes · 13 min read

Meituan’s Android plugin framework combines MultiDex‑style dex loading, global AssetManager replacement, component proxies, and a four‑phase Gradle integration to enable stable AAR‑based development while dynamically loading plugins across Android versions and OEM ROMs, handling resources, bytecode, and native libraries with minimal compatibility issues.
AndroidPlugin Frameworkbuild system
0 likes · 15 min read

Didi’s self‑developed “Jianmu” build system replaces Jenkins with a master‑slave architecture that colocates build scripts with source code, offering stable, high‑performance, permission‑controlled builds across multiple OSes via lightweight scheduling, workspace reuse, two‑level caching, Docker image management, and an “Env As Code” approach, while roadmap plans auto‑upgrades, elastic scaling, and further 30% efficiency gains.
CI/CDContainerized BuildContinuous Integration
0 likes · 9 min read

This article explains the Android Soong build system, its JSON‑like Android.bp file format, module definitions, variables, comments, types, operators, default modules, formatting tools, conversion from Android.mk, build logic, and common questions for mobile developers.
AndroidAndroid.bpSoong
0 likes · 7 min read

This article outlines Google’s comprehensive software engineering practices—including monolithic source repository management, the Blaze build system, automated testing, code review processes, defect tracking, language policies, debugging tools, release engineering, and project and personnel management—providing a concise overview for organizations seeking to adopt similar methods.
Googlebuild systemcode review
0 likes · 35 min read

This article outlines Baidu's continuous integration methodology, detailing how test coverage types, build system reuse and pipeline design, and team habits are coordinated to achieve efficient, stable, and product‑line‑aligned software delivery.
DevOpsTeam Practicesbuild system
0 likes · 8 min read

This article explains Baidu's continuous integration (CI) journey, detailing the CI capability model, its three core factors—test coverage, build system, and team habits—along with metrics, scoring, and how the CI team supports product lines to improve development efficiency.
BaiduCIDevOps
0 likes · 8 min read
