This article explains Tekton’s core CRDs—Task, TaskRun, Pipeline, PipelineRun, PipelineResource, and Condition—how they are implemented on Kubernetes, how pipelines are built and executed, and how to manage secrets and service accounts for secure CI/CD workflows.
The article details how DaJia's recommendation system progressed through three architectural versions—V1.0's simple strategy‑factory design, V2.0's vertical business split and configurable pipeline, and V3.0's dynamic configuration service and modular pipeline—addressing scalability, fault isolation, and personalization challenges while outlining future directions for explainable AI recommendations.
The article examines a puzzling StackOverflow case where sorting a random array before summation yields a six‑fold speedup, explains the phenomenon through CPU five‑stage pipeline fundamentals, structural, data, and control hazards, and shows how branch prediction and operand forwarding mitigate the performance loss.
This comprehensive guide walks you through Redis basics, its data structures, commands, installation steps, high‑concurrency principles, persistence mechanisms, replication, caching strategies, Lua scripting, pipelines, distributed locks, and cluster concepts, providing practical examples and best‑practice recommendations for developers and operators.
This comprehensive guide explains what GitLab CI is, how to configure shared or custom runners with Docker, register them, create and write a .gitlab-ci.yml file using YAML syntax, and demonstrates basic and advanced pipeline demos with full code examples and images.
This article details the evolution of an e‑commerce recommendation system through three architectural versions, highlighting the initial simple design, the challenges that prompted vertical and horizontal splits, the introduction of a configurable pipeline and AB testing, and the final micro‑service‑based, dynamically configurable V3.0 architecture.
This guide explains why and how to use the Git Parameter plugin in Jenkins to enable dynamic branch selection for both Freestyle and Pipeline jobs, covering configuration steps, parameter definitions, and example Jenkinsfile scripts for various pipeline setups.
This article describes the progressive redesign of an e‑commerce recommendation platform—from a simple strategy‑factory V1.0 through a vertically split V2.0 to a fully configurable, pipeline‑driven V3.0—highlighting architectural challenges, Redis clustering, dynamic configuration, recall and prediction services, and future directions for fine‑grained, explainable recommendations.
This article details the three‑stage evolution of an e‑commerce recommendation framework—V1.0’s simple strategy‑factory design, V2.0’s vertical business split, and V3.0’s configurable pipeline with dynamic server‑client configuration, addressing scalability, isolation, and AB‑testing challenges.
This article details the evolution of the "到家" recommendation system across three major versions, describing the initial strategy‑factory prototype, the problems it faced, the vertical and horizontal splits introduced in V2.0, the dynamic pipeline configuration and service separation in V3.0, and the future outlook for finer‑grained personalization.
PipelineRecommendation Systemconfiguration service
This article examines the step‑by‑step evolution of the recommendation framework used by a major e‑commerce service, detailing the shortcomings of the initial V1.0 design, the vertical and modular refinements introduced in V2.0, and the dynamic configuration, pipeline, and service‑oriented enhancements implemented in V3.0 to improve scalability, stability, and fine‑grained experimentation.
Configuration ManagementPipelineRecommendation System
This guide introduces GitLab CI/CD by explaining pipelines, jobs, stages, runner registration, and SSH‑based deployment, providing a complete example .gitlab-ci.yml and Docker‑based runner setup for beginners who want to automate build, test, and release processes.
This article demonstrates how to build a reproducible fraud‑detection workflow using scikit‑learn's Pipeline class, comparing a manual script with a pipeline‑based approach on the IEEE‑CIS Kaggle dataset and showing the benefits of modular, repeatable ML code.
This article details a structured GitLab CI/CD setup using job templates for build, test, code analysis, artifact handling, and Kubernetes deployment, combined with a default-pipeline.yml that defines includes, global variables, workflow rules, stages, and environment‑specific deployment configurations for Java applications.
This guide walks through installing Jenkins and Nexus Repository Manager with Docker, configuring a Maven hosted repository, adding Nexus credentials and Maven tools in Jenkins, and creating a Jenkins pipeline that builds a Java project and publishes its artifacts to Nexus, illustrating a complete CI/CD workflow.
This article explains why and how to convert Jenkins Freestyle projects to Pipeline jobs, covering trigger mechanisms, global and repository configurations, shell build steps, and a complete scripted pipeline example that automates building, testing, reporting, and email notifications.
To enhance decision‑making for users and quality monitoring for merchants, Meituan’s to‑restaurant platform implements fine‑grained aspect‑based sentiment analysis that extracts dish, attribute, opinion and polarity tuples from reviews, employing both a BERT‑CRF pipeline and a joint Dual‑MRC model which raise F1 scores from 0.61 to 0.68, and are deployed in dashboards and review‑management tools, with future work targeting efficiency and broader four‑tuple extraction.
This article introduces the Jenkins Deploy Dashboard plugin, explains its purpose for visualizing deployment status across environments, and provides step‑by‑step instructions—including adding deployments to the dashboard, creating the dashboard view, and adding deployment buttons—using both scripted and declarative pipelines.
This article introduces Jenkins Pipeline fundamentals, explains stages, nodes, and steps, compares Declarative and Scripted syntaxes, and provides detailed code examples for Windows, Docker, and Git operations to illustrate building, testing, and deploying applications.
The article examines Jedis 3.5.0’s three Redis access modes—single‑node via Jedis, sharding via ShardedJedis, and cluster via JedisCluster—detailing their class hierarchies, connection handling, consistent‑hashing and slot logic, and how pipelines boost throughput while respecting mode‑specific constraints.
Learn how to install Jenkins inside Docker using the jenkinsci/blueocean image, configure ports and volumes, unlock the instance, set up credentials for Git and SSH, create a multi‑branch pipeline with Blue Ocean, and write a Jenkinsfile that automates build, test, and deployment steps.
This case study describes how a rendering middle‑platform team tackled complex micro‑service chains, inconsistent data rules, and massive 3D data to create a full‑link location and visualization platform that enables self‑service debugging, reduces developer effort by over 30 %, and serves more than 170 monthly users.
This guide explains how to set up a Gerrit instance, configure SSH keys and permissions, install the Gerrit Trigger plugin in Jenkins, and create a Jenkins pipeline that automatically runs when a review is merged, providing a complete end‑to‑end CI/CD workflow.
This tutorial walks you through the fundamentals of Scrapy, covering its architecture, project setup, spider creation, item and pipeline definitions, pagination techniques, and multiple ways to store scraped data such as JSON files and MongoDB, all with clear code examples.
This article demonstrates how to set up a GitLab CI pipeline trigger token, use curl or Postman to invoke the pipeline via API, embed the trigger in .gitlab-ci.yml, and pass custom variables to the job, with example scripts and best‑practice tips.
This tutorial explains HTTP fundamentals, shows how to install and configure the Jenkins Generic Webhook Trigger plugin, and demonstrates parsing GET, POST, and header parameters using curl, Postman, and Jenkinsfile Groovy scripts for automated CI/CD pipelines.
The article reviews how deep learning models have grown deeper and wider, discusses the memory and bandwidth limits of single GPUs, and explains pipeline and sharding techniques—including GPU clusters and TPU pods—to efficiently train large‑scale models in industrial settings.
This tutorial explains how to use Jenkins to integrate command‑line tools and webhooks for automating GitLab branch creation, covering API discovery, Postman testing, pipeline scripting, credential handling, shared library implementation, and final system configuration.
This guide explains what Tekton is, outlines its core CRDs, shows how to deploy it on a Kubernetes cluster, and provides a step‑by‑step example that builds, containers, and deploys a Spring Boot application using Maven, Docker, and Tekton pipelines.
This article explains the fundamentals of CI/CD and pipelines, identifies eight common anti‑patterns such as lack of code‑as‑pipeline, slow execution, unstable results, misuse of production data, excessive complexity, tight coupling, zombie pipelines, and manual intervention, and provides practical causes and remediation strategies for each.
This guide walks through automating a Go project's build, handling private repository credentials, and deploying the compiled binary to a remote server using a Jenkins pipeline, covering project structure, build steps, credential management, and a complete pipeline script.
The article emphasizes that a CI/CD pipeline must be the exclusive route for deploying immutable artifacts to production, warning against direct local deployments, highlighting risks of lost traceability, and urging strict network-level controls to ensure only the pipeline can release code.
This article presents the design, implementation, and optimization of a deep‑learning‑based ranking system for NetEase News, covering pipeline architecture, feature‑processing enhancements, custom TensorFlow operators, and modular model frameworks such as DCN and DIEN to improve recommendation performance.
This article explains how to build a real‑time game leaderboard using Redis sorted sets, covering ranking categories, composite scoring formulas, dynamic updates, efficient data retrieval with pipelines, and provides a complete PHP class implementation.
This guide explains why Jenkins Shared Libraries are essential for reducing repetitive pipeline code in micro‑service projects, walks through creating and configuring a shared library, and demonstrates advanced usage with parameters, multi‑branch pipelines, and environment variable handling.
This article explains how to implement a real‑time ranking system for a mobile tank game using Redis sorted sets, covering ranking categories, composite scoring formulas, dynamic updates, efficient data retrieval with pipelines, and a complete PHP class example.
Learn how to configure a Jenkins single‑branch pipeline to accept a branch name as a parameter, enabling dynamic code checkout by setting up a String parameter, using ${BranchName} in the pipeline script, and handling potential Lightweight checkout errors.
The article explains why artifacts should be built only once and treated as immutable, using containers as the ideal vehicle, and warns against the anti‑pattern of rebuilding from source code at each pipeline stage, which slows pipelines and creates inconsistent production releases.
The article explains why comprehensive artifact management and strict version control of all application‑related files—including source code, scripts, configurations, and database assets—are essential for reliable DevOps pipelines, and outlines practical guidelines and common anti‑patterns to avoid.
This article explains the origins of DevOps, its evolution from agile practices, its deep integration with containers and Kubernetes, and demonstrates a complete CI/CD pipeline using tools like Jenkins, Gogs, Nexus, and SonarQube to achieve automated, end‑to‑end software delivery.
This guide introduces Tekton, a cloud-native CI/CD framework, explains its benefits, components, installation steps, core concepts, and provides a complete example that defines tasks, pipelines, Docker image building, and execution on a Kubernetes cluster.
This tutorial explains how to create a Jenkins Pipeline that builds a Go application, packages it into a Docker image, pushes it to a private Harbor registry, and deploys it to a Kubernetes cluster using Helm, covering node labeling, pod templates, credentials, and optional rollback.
This article introduces Jenkins shared libraries, explaining their structure, how to create a library with Groovy classes, configure it in Jenkins, and use it in pipelines, including sample code for colored log output and step-by-step setup instructions for DevOps practitioners.
This article explains how Ctrip’s NFES framework adopts a GitDev CI/CD pipeline—detailing the Install, Verify, and SonarAndImage stages, their constituent steps, and the .gitlab-ci.yml configuration—to streamline web development, improve code quality, and accelerate delivery of front‑end projects.
This article provides a detailed tutorial on Jenkins Pipeline environment variables, covering how to list, read, set, override, store boolean values, and capture shell command output within pipelines, complete with practical code examples and best‑practice tips.
This article details China Life Property & Casualty Insurance's agricultural insurance claims system achieving Level 3 DevOps continuous‑delivery assessment, shares insights from an interview with the R&D center head on motivations, implementation, metrics, challenges, and future plans, and explains the DevOps maturity model and pipeline architecture.
This guide walks you through installing the DingTalk and Build User Vars plugins, configuring a DingTalk robot, creating a Groovy shared library, and integrating it into a Jenkins pipeline to automatically push build notifications and change logs to DingTalk.
This article explains the fundamentals of Node.js streams, including basic concepts, stream types, pipe and pipeline usage, handling backpressure, and demonstrates how async iterators can simplify stream processing with detailed code examples and visual animations.
This article details the design and evolution of the ReX Dev front‑end engineering platform used by Alibaba's Hema, covering its layered architecture, robust metadata model, flexible pipeline engine, SPI‑based service extensions, LowCode/ProCode interconversion, and practical guidelines for building a high‑productivity, extensible development platform.
This article explains what a CI/CD pipeline is, why it is essential for DevOps, outlines its standard stages, discusses implementation steps and tool‑selection principles, highlights current cloud‑native trends, and warns against common anti‑patterns that can hinder continuous delivery.
This article introduces the Jenkins Deploy Dashboard plugin, explains how to visualize deployment status across environments, and provides step‑by‑step instructions with code examples for adding deployments to the dashboard, creating the view, and adding deployment buttons to pipelines.
This article explains how Spinnaker enables continuous delivery on Kubernetes by describing its role, architecture, pipeline design, workflow steps, and best practices for deploying applications across multiple cloud providers in a cloud‑native environment.
This article explains how Spark transforms a logical execution graph into a physical job by partitioning stages, applying pipeline concepts, and generating tasks, while illustrating the process with detailed code examples and the internal workflow of job submission.
This article explains how the invention of assembly‑line manufacturing parallels modern CPU pipelines, why processing an ordered array can be nearly ten times faster than an unordered one, and shows a practical bit‑wise optimization to eliminate costly if‑statements for high‑performance code.
This article presents a comprehensive study on generating recruitment job titles by combining a rule‑based pipeline with advanced seq2seq models—including BiLSTM‑Attention, Pointer‑Generator, and a Field‑Gate Dual‑Attention architecture—demonstrating significant performance gains on real‑world hiring data.
This guide walks you through installing GitLab Runner via Docker, configuring its types and states, registering it with a GitLab instance, and creating a simple .gitlab-ci.yml pipeline to verify end‑to‑end CI/CD functionality.
This article introduces Pipcook, a machine‑learning framework designed for front‑end developers, explains its architecture and integration with TensorFlow.js, Boa, and Node.js, and discusses how it lowers the barrier to building intelligent front‑end applications through pipelines, plugins, and cloud‑native deployment.
This guide explains GitLab CI/CD concepts, configuration files, runner setup, pipeline stages, and advanced features like Auto DevOps, providing step‑by‑step examples and code snippets for practical implementation.
This tutorial walks you through setting up Jenkins with Docker, exploring built‑in and custom pipeline environment variables, overriding rules, Boolean handling, and capturing shell command output, providing practical code examples for each step.
This article explains GitLab CI/CD fundamentals, how continuous integration, delivery, and deployment work, shows how to configure .gitlab-ci.yml files, set up runners, visualize pipelines, and leverage Auto DevOps for automated build‑test‑deploy cycles.
This guide explains how to use Jenkins pipeline shared libraries to create a flexible DingTalk robot notifier, covering message types, template design, Groovy implementation, and integration into pipeline post‑steps for automated build alerts.
This article explains how DevOps principles are adapted for mobile app delivery, detailing the unique challenges of fragmented build environments, device diversity, longer release cycles, and massive scale, and describes Alibaba Cloud’s EMAS Mobile DevOps solution, its architecture, security, scalability, and future roadmap.
Java 8’s Stream API builds a lazy pipeline where each intermediate operation is recorded as a stage and only a terminal operation triggers a single-pass execution, using internal classes like ReferencePipeline, Slink, and Sink to efficiently combine stateless, stateful, and short‑circuiting operations.
This article explains how to set up a Laravel route and controller that leverages the Pipeline class to pass a request through three custom pipe classes—LeftWords, RightWords, and BothSidesWords—modifying the input and storing the result as a new user record.
This article explains the internal mechanics of Java Stream’s pipeline, covering how operations are recorded as stages, how intermediate and terminal operations are composed via the Sink interface, and why the implementation achieves lazy evaluation and efficient parallel execution.
The Continuous Delivery Architect (CDA) course teaches DevOps pipeline design, implementation, and management, covering continuous integration, delivery, testing, deployment, monitoring, security, and the cultural practices needed to boost speed, reduce risk, and earn a certification.
This article provides a comprehensive overview of GitLab CI/CD, explaining continuous integration, delivery, and deployment concepts, detailing the .gitlab-ci.yml configuration, pipeline workflow, runner setup, Auto DevOps features, and includes practical code examples for building, testing, and deploying applications.
This guide explains what Tekton is, why a Kubernetes‑native CI/CD solution is advantageous, and provides step‑by‑step instructions—including required images, YAML manifests, and command‑line examples—to install Tekton, define tasks and pipelines, run a Go test pipeline, and troubleshoot common issues.
This guide walks you through creating a dedicated GitLab account for Jenkins, generating and registering SSH keys, installing required GitLab plugins, configuring credentials and tokens, writing a Jenkins pipeline script, and automating deployment with password‑less SSH between servers.
This tutorial walks you through using Pipcook to train an object‑detection model that automatically identifies and locates front‑end UI components in screenshots, covering data preparation in Pascal VOC format, pipeline configuration, model training, and inference with sample code.
This guide walks you through preparing data, configuring a Pipcook pipeline, training a TensorFlow MobileNet model, and using the resulting model to automatically recognize frontend UI components such as buttons, charts, and tables from screenshots.
This article introduces Pipcook, a machine‑learning framework designed for front‑end developers, explains its flexible pipeline architecture, showcases the Boa bridge that lets JavaScript call Python libraries, and outlines the upcoming PipApp concept for building end‑to‑end AI applications.
This article explains how Java Stream pipelines are built and executed, covering operation recording, the role of stages and sinks, differences between intermediate and terminal operations, and how the library achieves efficient single-pass processing while avoiding common pitfalls.
This guide walks through installing Jenkins Blue Ocean via Docker, setting up the Jenkins home directory, launching the server, and creating pipelines using both the classic Jenkins UI with a declarative Jenkinsfile and the visual Blue Ocean plugin, covering configuration, triggers, stages, and artifact handling.
This guide details a complete GitLab‑based CI/CD workflow—from issue creation and feature‑branch handling through build, test, code‑analysis, Docker image creation, and Kubernetes deployment—illustrating pipeline configuration, variable management, and trigger rules for reliable end‑to‑end project delivery.
This article explains two practical methods—using a custom linter.sh script that calls Jenkins's REST API and employing the Jenkins Pipeline Linter Connector VS Code extension—to validate declarative pipeline syntax before committing, reducing repeated build failures caused by syntax errors.
This article provides a step‑by‑step guide on installing Jenkins Blue Ocean via Docker, creating pipelines using both the classic UI and the Blue Ocean visual plugin, and configuring pipeline stages, triggers, and environment variables with example Groovy scripts.
This presentation walks through a step‑by‑step approach that blends real‑world business needs, design patterns, and Jenkins features to demonstrate how a shared‑library‑based pipeline engine can support large‑scale, complex CI/CD scenarios, from native solutions to structured atomic units and dynamic execution refactoring.
This article provides a comprehensive introduction to Apache Beam, covering its unified batch‑and‑stream processing architecture, programming model, workflow patterns, Lambda and Kappa architectures, the characteristics of PCollection, pipeline construction, core transforms, I/O handling, and includes practical code examples.
This tutorial explains how to use GitLab CI's only/except parameters and the newer rules syntax—including if, changes, exists, and allow_failure clauses—to control job execution, configure branch restrictions, and define workflow-level pipeline creation, illustrated with comprehensive YAML examples.
This article explains how WebRTC builds the video processing pipeline by detailing the capture module, internal data flow, VideoTrack construction, rendering, and encoder integration, and it outlines the key API calls such as AddTrack, CreateOffer, and SetLocalDescription that establish the end‑to‑end video stream.
This tutorial explains how to use GitLab CI keywords such as tags, allow_failure, when, manual, delayed, retry, timeout, and parallel to control runner selection, job execution conditions, failure handling, scheduling, retry policies, time limits, and concurrent job instances within CI/CD pipelines.
This guide explains how to configure GitLab CI/CD pipelines using the .gitlab-ci.yml file, covering job definitions, script syntax, before_script and after_script hooks, stage ordering, .pre/.post stages, and variable scopes with practical YAML examples.
This guide explains how to periodically synchronize Bitbucket master branches to GitHub repositories using a Jenkins pipeline, detailing branch policies, a simplified workflow for feature and bugfix branches, and a reusable Jenkinsfile that leverages parameterized builds to control repository syncing.
This article describes how to build a CI/CD pipeline using TFS for source control and Jenkins for automation on a Red Hat OpenShift‑based PaaS, covering code management, automated builds, testing, container image creation, deployment, and the necessary Jenkins and TFS configurations.
This article provides a comprehensive guide to Redis, covering atomic transactions, command pipelining, publish/subscribe messaging, data replication, high‑availability with Sentinel, and the distributed architecture of Redis Cluster, complete with code examples and configuration steps.
This tutorial explains how to set up Docker‑in‑Docker for Jenkins, mount the Docker socket, run containers as root, and create multi‑stage pipelines that use different Docker images for Maven and Node builds, including troubleshooting tips.
This article explains why and how to adopt the open‑source Cppcheck tool for C/C++ static analysis, covering installation on Linux, building from source, command‑line usage, Jenkins plugin integration, pipeline scripting, and report visualization to prevent new warnings from entering the codebase.
This article explains what Jenkins and pipelines are, then guides you through installing Docker, running a Jenkins container, retrieving the initial admin password, and completing the Jenkins setup via the web interface, including plugin installation and user creation.
This article presents a complete Jenkinsfile that defines choice parameters for selecting an environment and dynamically populates a server list using Groovy scripts, then demonstrates a simple pipeline stage that validates and echoes the chosen values, aborting the build if validation fails.
This guide explains how to use Jenkinsfile Runner to execute Jenkins pipelines locally via the command line or Docker, covering prerequisite downloads, building the runner, command‑line options, a sample Jenkinsfile, and tips on plugin management for efficient testing.
This guide explains how to install and configure the Jenkins Active Choices plugin to create dynamic, parameterized builds in Pipeline projects, including using Groovy scripts for checkbox, radio button, and multi-select UI widgets, and handling reactive parameters with conditional logic.
The article explains that shared libraries, a familiar concept from languages like Python, are implemented in Jenkins as Groovy classes containing methods, helping to centralize pipeline code, avoid bloated Jenkinsfiles, and improve maintainability, while also promoting a live broadcast and group chat.
The article explains the concept of shared libraries, compares them to Python modules, describes how Jenkins Groovy shared libraries store classes and methods, and discusses their role in simplifying and standardizing pipeline code to avoid overly complex Jenkinsfiles.
The article explains the concept of shared libraries, compares them to Python modules, describes how Jenkins uses Groovy classes for reusable pipeline code, and highlights their role in simplifying and standardizing Jenkinsfile management while also promoting an upcoming live event.
This guide lists Jenkins REST API endpoints for project management tasks such as retrieving information, creating, disabling, enabling, deleting, and building jobs, and demonstrates how to wrap HTTP requests with the httpRequest step in a Jenkins pipeline using authentication tokens.