Tagged articles
build automation
84 articles · Page 1 of 1
This article explains Maven's role as a Java project manager, covering its core concepts, lifecycle, repositories, plugins, scopes, inheritance, practical setup steps, common use cases, advantages, drawbacks, real‑world project examples, and typical pitfalls.
JavaMavenbuild automation
0 likes · 17 min read

This tutorial explains why a private Maven repository is useful for Java teams, walks through downloading and installing Nexus on Linux, configuring repositories, managing firewall rules, setting up anonymous access, and publishing and retrieving artifacts using Maven settings and commands.
JavaLinuxMaven
0 likes · 12 min read

Meta has spent four and a half years building a custom, six‑stage Kotlinator pipeline to automatically translate its massive Android Java codebase to Kotlin, tackling null‑safety, build‑time, and headless J2K challenges, and now reports that only half the work is complete while the hardest problems remain.
AndroidJavaKotlin
0 likes · 20 min read

This guide walks through Makefile fundamentals—including targets, dependencies, commands, variables, pattern rules, automatic variables, functions, conditional statements, includes, custom functions, multi‑target handling, phony targets, and debugging techniques—providing concrete examples and code snippets that enable readers to build and manage both small and large projects efficiently.
DebuggingMakefileautomatic variables
0 likes · 6 min read

The article examines Maven 4’s major upgrades—including a new 4.1.0 POM model, Build POM/Consumer POM separation, explicit artifact types, subproject renaming, tree‑based lifecycle, and richer configuration expressions—while also noting the tool’s migration assistance and its impact on modern Java development.
DevOpsJavaMaven
0 likes · 10 min read

Maven 4 introduces a revamped POM model, native flattening, explicit artifact types, subproject support, a tree‑based lifecycle for parallel builds, and richer configuration options, making it a timely upgrade for modern Java development pipelines.
JavaMavenMaven4
0 likes · 8 min read

Learn how to avoid creating a fat JAR by packaging your own Java classes into a standalone jar while placing third‑party dependencies in a dedicated lib folder, using Maven plugins and configuration steps demonstrated with a sample project, pom.xml, and runtime command.
Jar packagingJavaMaven
0 likes · 6 min read

This article introduces Jpom, a lightweight Java‑based tool that streamlines project building, automated deployment, server management, and monitoring, offering an easier alternative to Jenkins for individuals and small teams, with detailed feature lists, architecture overview, and step‑by‑step installation instructions.
CI/CDDevOpsJava
0 likes · 7 min read

This guide explains Maven's core plugin architecture, demonstrates practical configurations for flatten‑maven‑plugin and exec‑maven‑plugin, details the MOJO concept behind plugins, and walks through creating, installing, and binding a custom Maven plugin to the build lifecycle.
Flatten PluginJavaMaven
0 likes · 17 min read

This tutorial explains how to use the Maven Versions plugin to automate dependency upgrades, integrate them into CI pipelines, handle snapshots, filter unwanted versions, and apply various update goals, providing a reliable and repeatable approach to keep Java projects up‑to‑date.
CIMavenVersions Plugin
0 likes · 11 min read

Learn how to use Makefile to automate compilation, testing, formatting, static analysis, dependency installation, and Docker image creation for Go projects, providing a concise, reproducible workflow that integrates smoothly with CI/CD pipelines.
BackendMakefilebuild automation
0 likes · 6 min read

This article walks you through why CMake is a more elegant, cross‑platform alternative to hand‑written Makefiles, explains its core benefits, and provides a complete, hands‑on tutorial that covers the basic workflow, a minimal project example, multi‑source handling, and multi‑directory organization with clear code snippets.
C++CMakeMakefile
0 likes · 13 min read

This article provides a comprehensive guide to Apple's XCFramework format, covering its core features, step‑by‑step integration methods, internal hierarchy, creation processes from source or Fat frameworks, dependency handling, and best‑practice recommendations for robust multi‑platform iOS development.
SWIFTXCFrameworkbuild automation
0 likes · 17 min read

Jpom is a simple, low‑intrusion Java‑based platform that provides online project building, automatic deployment, daily operations, and monitoring features, offering node management, SSH terminal, Docker handling, and a one‑click installation process suitable for individuals and small enterprises.
DevOpsJavaJpom
0 likes · 9 min read

Google's research demonstrates that a machine‑learning model trained on build logs and code snapshots can automatically suggest safe, high‑quality fixes for broken builds, boosting developer productivity by about two percent without introducing detectable security risks.
Code safetyML-assisted debuggingMachine Learning
0 likes · 10 min read

Learn how to use Maven Archetype to create standardized project skeletons, customize templates, generate and share archetypes, and integrate them into IDEs, streamlining Java project initialization, reducing manual setup errors, and improving development efficiency across teams.
ArchetypeJavaMaven
0 likes · 6 min read

This guide demonstrates how to use Makefile for automating builds by retrieving the current date, exploring different variable assignment operators, looping over multiple hosts, and encapsulating reusable targets with parameter passing, complete with practical code examples and execution steps.
LoopingMakefileShell Commands
0 likes · 6 min read

Java developers can quickly establish a Go development environment by installing Homebrew, Go, and the Delve debugger, configuring essential environment variables, choosing an IDE such as GoLand or VS Code, organizing projects with standard cmd/internal layouts, managing dependencies via go.mod, automating builds with a Makefile, and debugging or packaging the resulting binaries.
DebuggingGoIDE
0 likes · 20 min read

This article walks through configuring AppVeyor to compile Windows PHP extensions, covering repository forking, token encryption, custom .appveyor.yml matrix settings, artifact packaging, GitHub deployment, and troubleshooting remote build issues, providing a practical CI/CD solution for PHP developers.
AppVeyorCI/CDGitHub
0 likes · 8 min read

This article explains the essential Makefile concepts—including targets, dependencies, commands, variables, pattern and implicit rules, includes, conditionals, functions, special variables, and parallel execution—through clear explanations and real‑world code examples to help developers automate and streamline their build processes.
MakefileParallel Buildbuild automation
0 likes · 5 min read

This comprehensive guide walks you through Makefile fundamentals, covering basic syntax, variables, pattern rules, automatic variables, functions, conditional statements, multi-target handling, phony targets, debugging techniques, and advanced custom functions to help you automate and streamline complex build processes.
Continuous IntegrationMakefilebuild automation
0 likes · 6 min read

This article describes a systematic approach to reducing mobile app package size by detecting oversized resources, scanning unused assets, enforcing size checkpoints during development, and integrating automated validation into the CI/CD pipeline, illustrated with tools, workflows, and results.
CI/CDPackage SizeResource Optimization
0 likes · 10 min read

This comprehensive guide walks through Gradle fundamentals—including the initialization, configuration, and execution phases—explains task creation, ordering, and incremental builds, demonstrates custom tasks and small examples, and shows three ways to build and publish Gradle plugins with ASM bytecode instrumentation for Android projects.
ASMAndroidGradle
0 likes · 16 min read

This article explains how Guming's frontend team unified development across multiple backend subsystems by abandoning qiankun, defining strict routing and deployment conventions, automating enforcement through a custom build tool, and providing SDKs, sandboxing, and local development support to boost efficiency and user experience.
architecturebuild automationfrontend
0 likes · 19 min read

Setuptools is a Python packaging tool that manages dependencies, bundles source code, installs scripts, and provides command-line utilities, and when combined with Sphinx it can automatically generate project documentation, which can be integrated into the build process via a custom build command in setup.py.
Python packagingbuild automation
0 likes · 4 min read

The article shares a developer's practical experience of transitioning from backend to frontend by learning Vue and React, exploring component libraries, tackling layout and styling challenges, and integrating the frontend build into a backend Maven project for a complete gateway console.
MavenReactVue
0 likes · 15 min read


DevOpsSep 2, 2022 · Operations
Scaling a configuration management team from a small startup to a large enterprise reveals seven key lessons about managing tool costs, customization control, infrastructure scalability, build environment governance, early adoption of third‑party solutions, ensuring traceability with many developers, and continuously evaluating tool costs versus market alternatives.
Configuration ManagementDevOpsScaling
0 likes · 10 min read

This guide shows two reliable Maven techniques—using the versions-maven-plugin and a placeholder with the flatten-maven-plugin—to safely update version numbers across dozens of modules without manual errors or risky global replacements.
Mavenbuild automationflatten-maven-plugin
0 likes · 6 min read

This article explains how to invoke other Groovy scripts and all Groovy files within a directory from a build.groovy file, providing concrete example code that demonstrates calling a Print method in hello.groovy and using it inside mytools.groovy.
DevOpsGroovybuild automation
0 likes · 2 min read

This article introduces Taskfile, a YAML‑based build tool written in Go that simplifies task automation compared to Makefile, covering installation methods, basic and advanced features such as environment variables, vars, task dependencies, includes, defer handling, and dynamic detection for CI pipelines.
CITaskfileYAML
0 likes · 14 min read

This comprehensive tutorial explains why Maven is essential for Java projects, walks through installation, project structure, common commands, repository management, dependency scopes, lifecycle phases, Eclipse integration, and advanced features, providing code examples and visual diagrams for clear understanding.
EclipseJavaMaven
0 likes · 17 min read

This guide compiles the most useful Maven commands and IDE tips for creating, building, packaging, and deploying multi‑module Java projects, covering project structure, command syntax, advanced combinations, and IntelliJ IDEA integrations.
IDEAJavaMaven
0 likes · 7 min read

This article details the evolution of JD.com’s HarmonyOS app from a monolithic project to a modular componentized architecture, describing the existing structure, encountered build and resource issues, the Android plugin reference solution, the proposed HarmonyOS componentization scheme, implementation steps, and release packaging.
ComponentizationGradleHarmonyOS
0 likes · 18 min read

The AirForce platform unifies component architecture, baseline and release management, and automated packaging for a large Android app, eliminating information silos and cumbersome configuration files by enforcing hierarchical dependencies, tracking component metadata, providing fine‑grained conflict detection, and enabling shuttle releases that streamline coordination, improve traceability, and reduce manual effort.
AndroidComponent Architecturebaseline management
0 likes · 12 min read


转转QADec 17, 2021 · Operations
This article provides a comprehensive walkthrough of how ZuanZuan uses Jenkins together with the custom Beetle platform to automatically generate jobs, configure config.xml, optimize front‑end builds, manage compile packages, and address Sonar scan performance issues, complete with diagrams and script examples.
CI/CDConfig XMLDevOps
0 likes · 12 min read

This article explains Gradle's fundamentals, compares it with Maven, introduces Groovy's abstract syntax tree (AST) concepts, and provides a step‑by‑step demo that parses a Gradle script into an AST, modifies it to inject a dependency, and attempts to write the changes back to the original build file.
ASTGradleGroovy
0 likes · 16 min read

This article explains how Gradle 7's Version Catalog feature lets you centralize and share dependency versions, bundles, and plugin declarations across modules and projects, offering type‑safe accessors, version separation, and easy publishing through Maven, with practical code examples and configuration steps.
GradleJavaKotlin
0 likes · 14 min read

This guide explains how to use Maven's archetype plugin to create, customize, install, and share project templates, enabling rapid initialization of new Java projects while excluding unwanted files, and shows both command‑line and IntelliJ IDEA integration for consistent backend development.
ArchetypeJavaProject Template
0 likes · 7 min read

This article outlines Baidu's evolution of build practices, presenting a group-level continuous delivery pipeline solution that includes a dual-engine ecosystem—standard plugin engine and non-standard containerized engine—and describes the intelligent build platform that enables dynamic, policy-driven, resource-efficient software delivery.
CI/CDContainerizationContinuous Delivery
0 likes · 17 min read


政采云技术Jul 20, 2021 · Frontend Development
This article explains why a dedicated frontend build platform is needed, describes its core capabilities such as automated build, pluggable pipelines, audit‑based release, and external plugin exposure, and details the Docker‑in‑Docker architecture, process‑pool design, and sample Node.js code for a scalable CI/CD solution.
CI/CDProcess Poolbuild automation
0 likes · 20 min read

This article explains why Android developers need Gradle, describes the structure of a default Android project, details Gradle concepts such as projects, tasks, and the wrapper, and walks through dependency configurations, conflict resolution, and the complete build and packaging pipeline for APK generation.
AndroidGradlebuild automation
0 likes · 17 min read


转转QAJul 16, 2021 · Operations
This article explains how ZheZhe leverages Jenkins as an open‑source, plugin‑rich CI scheduler to classify projects, manage unified build scripts and config files, orchestrate job creation, execution, and cleanup, and scale a mixed Linux/macOS build farm supporting thousands of daily compilations.
Build SchedulingCI/CDDevOps
0 likes · 5 min read

This article introduces and compares fourteen widely used Jenkins alternatives—including BuildMaster, Microtica, GitLab, CircleCI, Bamboo, TravisCI, Semaphore, Buddy, Drone.io, GoCD, TeamCity, Buildkite, and Zuul—highlighting their key features, project URLs, and typical use cases for modern CI/CD pipelines.
CI/CDContinuous IntegrationDevOps
0 likes · 10 min read

This article compares fourteen popular Jenkins alternatives, detailing each tool's key features, strengths, and drawbacks, and provides project URLs so teams can choose a CI/CD solution that best fits their workflow and cost requirements.
CI/CDContinuous IntegrationDevOps
0 likes · 11 min read

This article explains how to invoke another Groovy script and all Groovy scripts in a directory from a build.groovy file, providing clear example code that demonstrates defining a method in one script and calling it from another within a DevOps automation context.
DevOpsGroovyJenkins
0 likes · 2 min read

This article explains how software build processes have progressed from simple manual compilation to sophisticated, automated, cloud‑native platforms, covering the distinction between build and compile, the rise of tools like Ant, Maven and Gradle, containerization, Kubernetes‑based orchestration, and the challenges and future directions of large‑scale build infrastructures.
CI/CDContainerizationbuild automation
0 likes · 21 min read

This article explains why Gradle is essential for Android development, walks through the default project structure, details how Gradle tasks, dependency configurations, and the wrapper work together to compile Java sources, generate resources, resolve dependencies, transform classes, and finally package an APK.
APK PackagingAndroidGradle
0 likes · 17 min read

San CLI UI provides a beginner‑friendly graphical layer for San CLI, enabling visual project, configuration, dependency, and plugin management, intuitive build task control with real‑time statistics, and customizable dashboard widgets, all built on a plugin architecture that lowers entry barriers and enhances developer productivity.
San CLI UIbuild automationfrontend tooling
0 likes · 12 min read

This article explains why Maven is essential for Java projects, describes its lifecycle and standard directory layout, shows how to install and configure Maven, create a project in IntelliJ, manage dependencies, use plugins, build multi‑module projects, and package Spring Boot applications.
Continuous IntegrationMavenbuild automation
0 likes · 9 min read

This guide explains how to restructure a Maven project to isolate unit and integration tests, configure Maven Surefire, Failsafe, Build‑Helper, and JaCoCo plugins for separate execution and combined coverage reports, and finally display the results in SonarQube.
JaCoCoMavenSonarQube
0 likes · 8 min read

The article explains continuous integration as a software development practice where developers frequently merge changes, outlines essential practices such as a single source repository, automated builds, automated testing, rapid feedback, and deployment, and details the tangible benefits of reduced risk, faster bug detection, and smoother releases.
Continuous Integrationautomated testingbuild automation
0 likes · 36 min read


DevOpsSep 16, 2020 · Operations
Continuous Integration is a software development practice where team members frequently integrate their work, typically multiple times per day, with each integration automatically built and tested to quickly detect errors, improve collaboration, reduce risk, and enable faster, more reliable delivery of high‑quality software.
Continuous Integrationbuild automationsoftware development
0 likes · 33 min read

This article explains why Java developers should consider Gradle over Maven, covering installation methods, the Gradle wrapper, concise dependency management, customizable tasks and plugins, mirror and proxy configuration, and the performance, flexibility, and simplicity advantages that make Gradle a modern build solution.
GradleIDE integrationJava
0 likes · 13 min read

Gradle 6.6 introduces experimental configuration caching, runtime classpath normalization, and a new credentials API, all aimed at dramatically speeding up builds, improving cache hit rates, and simplifying secure artifact publishing for Java projects.
Configuration CachingCredential ManagementGradle
0 likes · 6 min read

Gradle 6.6 RC6 introduces experimental configuration caching for faster builds, runtime classpath normalization to improve cache hits, and a new credentials API that externalizes authentication details, while also adding Java compilation support, file‑system watch stability, dependency improvements, and various bug fixes.
Configuration CachingGradlebuild automation
0 likes · 6 min read

This guide walks through configuring iOS certificates, installing Fastlane, handling common installation issues, and using Fastlane or a build script to package and install an iOS app on a real device, complete with command‑line examples and troubleshooting tips.
Xcodebuild automationfastlane
0 likes · 5 min read

This tutorial introduces Maven integration, outlining its key features, installation and configuration steps, and how to manage dependencies via coordinate repositories, targeting learners interested in DevOps and build automation.
DevOpsJenkinsMaven
0 likes · 1 min read

This article demonstrates how to define and run custom Gradle tasks using the Groovy DSL, explains the difference between configuration and execution phases, shows task dependencies, and provides examples such as copy tasks and packaging tasks for Java projects.
CI/CDCustom TasksGradle
0 likes · 6 min read

The article explains how to streamline Flutter Engine customization by rewriting build and release scripts—linking engine versions to Flutter tags, using gclient, gn, and ninja to fetch dependencies, generate Ninja files, compile, debug locally, package the framework, and automate publishing with version‑locked .gclient templates, enabling one‑click builds and future storage‑mirroring.
CI/CDFlutter Enginebuild automation
0 likes · 13 min read

This guide explains the Gradle --continue option, shows a sample build script with a deliberately failing task, demonstrates command‑line runs with and without the flag, and reveals how Gradle executes remaining tasks while reporting all failures.
DevOpsGradlebuild automation
0 likes · 5 min read

This article explains how Groovy, combined with Gradle, can serve as a native application server to synchronize environment‑specific property files with a MySQL registry, demonstrating practical build‑script configuration, file‑system traversal, and Groovy‑SQL database operations for robust CI/CD workflows.
Configuration ManagementGradleGroovy
0 likes · 9 min read

This article examines the current Flutter build workflow, identifies manual intervention points, and proposes automation strategies—including command‑line parameters, flavor configurations, and IOSDeploy options—to streamline Android and iOS development while weighing effort against maintainability.
Android Studiobuild automationiOS
0 likes · 4 min read

This article explains two practical approaches for handling private JAR dependencies in a Gradle‑based Jenkins CI pipeline, including fixed path assignment and automated network‑based retrieval, and provides a complete Gradle script example illustrating the implementation.
CIGradleJenkins
0 likes · 6 min read

This guide explains how to install Apache Ant, configure a build.xml file to run JMeter tests and generate HTML reports, and execute the Ant build to produce performance test results, including troubleshooting common permission errors.
AntJMeterXML
0 likes · 9 min read

Using Lerna, the article shows how to convert a multi‑package JavaScript project into a production‑ready monorepo by initializing Lerna, hoisting dependencies, automating versioning and publishing, integrating commit‑linting, code‑style tools, Babel builds, and VSCode debugging for streamlined development.
CIGitLerna
0 likes · 19 min read

The author explains why JaCoCo coverage failed after changing file paths, reveals that class file paths are flexible but source paths must point to the package root (usually src/main/java), and provides a complete, working Ant build.xml example to generate accurate coverage reports.
AntJaCoCoJava
0 likes · 5 min read

This article explains Maven's role as a Java build and dependency management tool, covering its repository concepts, mirrors, lifecycle phases, coordinates, conflict resolution strategies, aggregation and inheritance mechanisms, plugin configuration, and common command-line usage to improve developer productivity.
Java Build ToolMavenMaven Lifecycle
0 likes · 19 min read

Zhihu built a Docker‑based Jenkins Pipeline system that now runs over 3,000 jobs daily, offering low entry cost, high customizability, language openness, fast stable builds, and a highly available, extensible cluster while reducing debugging effort and enforcing quality standards.
CI/CDContinuous IntegrationDevOps
0 likes · 14 min read

This guide walks you through Gradle’s core concepts, from installing the tool and initializing a project to creating custom tasks, managing plugins and dependencies, using the Kotlin DSL, and leveraging the Gradle Wrapper for reliable builds across environments.
GradleJavaKotlin
0 likes · 13 min read

This article introduces Makefile as a powerful build tool, recommends beginner-friendly books, and outlines a series of practical articles covering basic concepts, step‑by‑step guides, enterprise examples, and multi‑target techniques to help readers master build automation.
Makefilebuild automationprogramming tools
0 likes · 6 min read

This tutorial presents a complete enterprise‑level Makefile example, detailing version numbering, dynamic library integration, macro definitions, include paths, compilation flags, output directory handling, and clean targets, while also showing the associated source code layout and how to retrieve the full project from the public account.
C++Dynamic LibraryMakefile
0 likes · 6 min read

This article explains a practical approach for managing common C source files shared by several applications by placing the shared code in a dedicated folder and using a Makefile that automatically discovers, compiles, and links both the common and application‑specific files, reducing redundancy and simplifying maintenance.
C++MakefileShared Code
0 likes · 6 min read

This step‑by‑step tutorial shows how to write a Makefile for a tiny C program, then progressively improves it with separate object files, variables, pattern rules, and built‑in functions like wildcard and patsubst, while explaining each concept and its benefits.
GCCMakefileMakefile Tutorial
0 likes · 9 min read

This guide explains what a Makefile is, its advantages, naming conventions, basic syntax, workflow, common commands, special symbols, variable types, pattern rules, and built‑in functions, providing clear code examples to help developers automate compilation in Linux projects.
Makefilebuild automationc-programming
0 likes · 10 min read

This comprehensive guide explains Maven's core concepts, project structure, repository types, installation steps, common commands, lifecycle phases, creating new Maven projects, POM file details, dependency management, and various Maven project types, providing developers with a complete reference for effective build automation.
MavenPOMbuild automation
0 likes · 17 min read


DevOpsDec 13, 2017 · Operations
This guide explains how to set up a VSTS (Azure DevOps) project, connect it to a GitHub repository, configure a CI/CD pipeline with build triggers, customize build options, and display the build status badge in the repository’s README, enabling fully automated builds for .NET projects.
Azure DevOpsCI/CDContinuous Integration
0 likes · 6 min read

This article explains how to replace repetitive manual Go commands like "go build" and "go test" with a well‑structured Makefile, covering variable definitions, common targets, cross‑compilation, Docker builds, and usage examples to streamline and automate Go project workflows.
Cross-compilationGoMakefile
0 likes · 5 min read

This guide explains how to set up Jenkins to run Maven builds for different environments (dev, beta, prod), including commands to skip tests, deploy to Nexus, and specify profile parameters, with screenshots illustrating the correct configuration to avoid common errors.
CI/CDDevOpsEnvironment Profiles
0 likes · 3 min read

This article explains how adopting continuous integration principles—such as a single source repository, automated builds, frequent mainline commits, fast builds, environment isolation, and automated deployment—can streamline development, testing, and release processes, reduce manual effort, and enhance overall software quality and efficiency.
DevOpsbuild automationdeployment
0 likes · 13 min read

To shrink the QQ Music Android APK, the team replaced manual image compression with a multithreaded pngquant workflow that compresses PNGs at 90 % quality, integrates into the RDM build, cuts the res directory by 1.97 MB and the overall package by 2.22 MB, delivering faster, maintainable builds.
AndroidGradleResource Optimization
0 likes · 14 min read

This article provides a comprehensive guide to Android app compilation, detailing the step‑by‑step build process, the use of Ant and Gradle tools, configuration of build.xml and build.gradle files, and essential settings such as obfuscation, signing, multidex, and code coverage to streamline CI pipelines.
AndroidAntCI
0 likes · 17 min read


Aotu LabJul 22, 2016 · Frontend Development
This article explains how the Athena toolset addresses growing frontend complexity by introducing standardized project structures, componentization, automated builds, and performance optimizations such as first‑screen rendering, on‑demand loading, resource tables, and static preloading, ultimately improving developer experience and page speed.
Componentizationbuild automationtooling
0 likes · 23 min read


DevOpsJul 12, 2016 · Operations
The article narrates a junior developer’s struggle with a tedious manual build workflow, his creation of a Java‑based BuildTool to automate compilation, packaging, and deployment, and the evolution toward an XML‑driven DSL that eventually inspired the naming of Apache ANT.
AntDSLDevOps
0 likes · 8 min read

This article explains Bootstrap's overall architecture and development workflow, covering requirements such as CSS/JS development with Less, comprehensive testing, compilation, and release packaging, and details how Grunt automates tasks like compilation, linting, testing, and distribution.
Gruntbootstrapbuild automation
0 likes · 4 min read
