Tagged articles
plugin development
91 articles · Page 1 of 1
The article introduces DeepSeek Harness's Creative Mode, which lets users create custom plugins by describing them in chat; the author demonstrates building a token usage tracker, a paper reader with ArXiv support, and a reasoning process viewer, while comparing Creative Mode with Standard, PTC, and Minimal modes across tool access, Skills, sub-agents, workflows, and plugin management.
AI coding assistantCreative ModeDeepSeek Harness
0 likes · 9 min read

DeepSeek awarded 999 yuan to the creator of dsh-layerfs, a plugin that uses LayerFS to achieve 27x–166x storage deduplication in multi-agent coding experiments, and integrates with DeepSeek Harness via SDK, CLI, and new visualization tabs.
AI agentsDeepSeekDeepSeek Harness
0 likes · 9 min read

This tutorial explains DeepSeek Harness's Cordis plugin architecture, shows how to discover and install community plugins via GitHub and Awesome DSH Plugin, recommends three essential plugins (dsh-web-ui, dsh-agent-teams, dsh-market), and demonstrates creating persistent custom plugins using natural language in creation mode.
AI agentsDeepSeek HarnessNatural Language Programming
0 likes · 13 min read

This tutorial completes the wechat-publisher plugin series by extracting publish logic into a reusable Service, using events for decoupled notifications, and packaging the plugin as an installable Bundle for distribution via dsh plugin commands.
BundleDeepSeek HarnessEvent
0 likes · 20 min read

This tutorial shows how to replace hardcoded values with a schema-driven configuration system for DeepSeek Harness plugins, covering TypeScript interfaces, Schemastery validation, cordis.yml setup, environment variable secrets, load-time validation, tool integration, common pitfalls, and HMR behavior.
ConfigurationDeepSeek HarnessHMR
0 likes · 14 min read

This tutorial introduces 10 practical DeepSeek Harness (DSH) plugins that extend the AI agent platform with capabilities like prompt optimization, cost tracking, plugin marketplace, web UI aggregation, Codex/Claude/Grok subscription integration, conversation mapping, office document automation, multi-agent team collaboration, and context visualization — each with installation commands and usage walkthroughs.
AI agentsAgent WorkbenchContext Visualization
0 likes · 17 min read

This article introduces nine practical DeepSeek Harness plugins—detailing their functions, installation commands, and usage examples—while also showing how to convert a Skill into a DSH plugin, publish it on GitHub, and safely test community extensions.
AI automationDSH pluginsDeepSeek Harness
0 likes · 15 min read

This guide explains why pytest surpasses unittest as the most popular Python testing framework, walks through installation, writing and running tests, explores core features such as fixtures, parameterization, markers, and plugins, and demonstrates a complete API‑automation suite with advanced fixture techniques and custom plugin development.
API automationPython testingfixtures
0 likes · 14 min read

The article explains how Amper has been integrated into the Kotlin Toolchain as an Alpha feature, replacing its commands with a unified kotlin CLI, adding Maven publishing, C‑interop improvements, and IDE‑CLI consistency, and discusses the implications for Gradle’s role in Kotlin projects.
GradleKotlinKotlin Multiplatform
0 likes · 9 min read

The article explains that Claude Code skills are full‑folder toolkits, not simple markdown steps, and shows how description length, progressive disclosure, classification, memory, hooks, and usage metrics determine whether a skill is triggered and useful.
AI assistant skillsClaude CodePrompt engineering
0 likes · 21 min read

This article provides a detailed walkthrough of SpringBoot plugin development, covering the benefits of modular decoupling, common implementation approaches such as Java SPI, custom configuration, Spring factories, and practical code examples that demonstrate how to create, load, and use plugins for extensible SMS services.
Java SPIServiceLoaderSpringBoot
0 likes · 20 min read

This article walks you through the entire process of creating Claude Code plugins—from understanding why plugins are needed, setting up the directory structure, writing commands, agents, skills, and hooks, to testing, debugging, advanced features, and publishing—providing concrete code examples, configuration files, and best‑practice recommendations.
AI assistantAgentsClaude Code
0 likes · 19 min read

This guide explains how to create a lightweight Vite plugin and a Tampermonkey script that embed absolute file paths into Vue components, enabling developers to click any element in the browser and instantly locate its source file in the project.
ASTSource Code TracingTampermonkey
0 likes · 15 min read

This article walks through building an Obsidian plugin that converts long‑form notes into platform‑specific articles using Claude Code and the Doubao‑Seed‑Code model, covering tool selection, repository setup, AI‑driven code generation, configuration, UI design, and the final multi‑platform output.
AI code generationClaude CodeContent Distribution
0 likes · 11 min read

The article chronicles the author's deep technical journey of adapting Tailwind‑Merge to work within WeChat mini‑programs, detailing the obstacles posed by illegal class‑name characters, failed compile‑time workarounds, a complete rewrite of the escape utility, and the final release of a robust, configurable merge plugin.
ASTBuild ToolsTailwindCSS
0 likes · 13 min read

This step‑by‑step guide explains why you might need a custom Jenkins plugin, walks you through setting up Java 21 and Maven, generating a plugin project with the Jenkins archetype, building and locally testing it, and finally publishing it to the Jenkins Marketplace with best‑practice tips for security, CI, versioning, and community engagement.
CI/CDDevOpsJava
0 likes · 19 min read

This article explains how to develop a custom plugin that automatically captures Git metadata during build time, injects it into the bundled code, and exposes the information via a console command, with step‑by‑step guidance for both Webpack and Vite projects using Trae‑Builder.
GitJavaScriptTrae-Builder
0 likes · 12 min read

This article walks through the Model Context Protocol (MCP) as an AI‑centric "USB‑C" for tool integration, explains its core capabilities, shows how to register and call MCP tools using the TypeScript SDK, details the end‑to‑end workflow from ZIP file handling to React code generation, and shares practical implementation tips and future improvements.
AI IntegrationMCPTypeScript
0 likes · 23 min read

This article guides pure frontend developers with little or no Node.js experience through the fundamentals of creating Vite plugins, covering concepts such as code injection, file operations, and file routing, and provides practical examples and best‑practice tips to enhance development efficiency.
Node.jscode injectionfrontend
0 likes · 14 min read

An automatically applied Babel plugin scans JavaScript AST nodes and rewrites risky property accesses and logical‑AND chains into optional‑chaining expressions, letting developers prevent TypeError crashes without modifying source code, while offering include/exclude filters, optional short‑circuit optimization, and compatibility with older browsers via downstream transforms.
AST transformationBabelJavaScript
0 likes · 11 min read

The article explains how to create a custom Babel plugin that automatically transforms risky member and call expressions into optional‑chaining equivalents during bundling, using configurable include/exclude patterns and short‑circuit optimizations, thereby preventing TypeError in large JavaScript codebases while noting a modest bundle‑size increase.
BabelJavaScriptOptional Chaining
0 likes · 14 min read

This article provides a comprehensive guide to the Hvigor build tool—its core features, integration with DevEco Studio, consistent build processes, lifecycle stages, typical usage scenarios, task and product structures, as well as step‑by‑step instructions for creating custom tasks, plugins, and routing plugins using TypeScript, enabling efficient and flexible development on HarmonyOS.
HarmonyOSHvigorTypeScript
0 likes · 19 min read

Hvigor is a TypeScript‑based build orchestration tool for HarmonyOS that manages tasks, project models, and configurations, integrates with DevEco Studio for consistent command‑line and IDE builds, supports lifecycle phases, custom tasks, plugins, and routing plugins, and provides detailed development guides and code examples.
DevEco StudioHarmonyOSHvigor
0 likes · 16 min read

The article explains how PostCSS parses CSS into an abstract syntax tree composed of Declaration, Rule, Root, AtRule and Comment nodes, describes the rule‑ and hook‑based event listeners and depth‑first traversal used in PostCSS 8 versus the walk methods of PostCSS 7, and shows how this knowledge lets developers create custom plugins for tasks such as unit conversion, vendor prefixing, or dark‑mode generation.
CSS ASTCSS ProcessingFrontend Development
0 likes · 9 min read

AspectPro is a lightweight HarmonyOS runtime hook framework that, together with aspectProPlugin, enables comprehensive AOP capabilities such as method interception, parameter manipulation, and handling of non-writable properties, while the article details its core functions, limitations of system Aspect, and step‑by‑step implementation strategies.
AOPAspectProHarmonyOS
0 likes · 22 min read

This guide explains safe and efficient WordPress code modification techniques—including using child themes, avoiding direct core edits, creating plugins, and applying style changes—while emphasizing backup strategies, version control, and recovery methods to protect site stability and data.
WordPresschild themecode modification
0 likes · 10 min read

The article explains Sermant's classloader architecture, plugin mechanism, class isolation, unified dynamic configuration, and logging capabilities, providing step‑by‑step guidance for building service‑governance plugins from basic to advanced features.
Class IsolationDynamic ConfigurationSermant
0 likes · 6 min read

Using Adobe’s CEP platform, this tutorial shows how to set up a Photoshop extension, employ the Action Manager API to extract text layer properties such as color, font size, and shadow, and then recreate the design in HTML/CSS, streamlining marketing asset creation.
Action ManagerCEPJavaScript
0 likes · 9 min read

This article explains MySQL’s logical architecture, details the pluggable storage‑engine API, lists the default engines, and provides step‑by‑step guidance with code examples on how to create a custom MySQL storage engine.
APIDatabase ArchitectureMySQL
0 likes · 12 min read

This guide introduces CozeIDE, explains its main features such as code editing, dependency management, AI programming assistant, testing and publishing, and walks you through two complete plugin development examples—including a stock‑price lookup plugin—showing how to create, test, and release plugins using Node.js or Python runtimes.
AI assistantCozeIDENode.js
0 likes · 12 min read

This article explains how to extend the Higress cloud‑native gateway with WebAssembly plugins written in Go, C++ or Rust that call Redis for global rate limiting, token‑based AI usage control, and cookie‑based caching, including full code samples, configuration steps, and test results.
RedisWasmplugin development
0 likes · 9 min read


LouZaiMar 20, 2024 · Operations
The article explains the principles and benefits of distributed tracing, introduces OpenTracing standards, details SkyWalking’s architecture and sampling strategies, compares its performance with Zipkin and Pinpoint, and shares practical implementation experiences and custom plugin development within a micro‑service environment.
Distributed TracingMicroservicesOpenTracing
0 likes · 19 min read


LouZaiDec 19, 2023 · Cloud Native
This article explains the principles and benefits of distributed tracing, introduces the OpenTracing standard, details SkyWalking's architecture and solutions for automatic span collection, context propagation, unique trace IDs, sampling strategies, performance impact, and shares practical customizations and plugin development experiences.
Distributed TracingMicroservicesObservability
0 likes · 17 min read

This article walks developers through Sermant’s architecture, explaining its plugin mechanism, class isolation, and how to build practical plugins with basic capabilities, unified dynamic configuration, and unified logging, while showcasing real‑world examples and tips for efficient development.
Dynamic ConfigurationJavaSermant
0 likes · 6 min read

This article explores Jira's plugin ecosystem, detailing how the Forge platform lets developers create, integrate, and deploy extensions using CLI tools, UI kit or custom UI, with server‑driven rendering, sandboxed security, and a marketplace for distribution.
Custom UIForgeJira
0 likes · 14 min read


政采云技术Jul 27, 2023 · Big Data
This article explains how to develop, package, and deploy custom Trino plugins—illustrated with an access‑control plugin—by using Java SPI, Maven dependencies, implementing the Plugin and SystemAccessControl interfaces, and configuring the plugin in Trino’s configuration files.
Java SPIplugin developmenttrino
0 likes · 11 min read

This article recounts the author's journey of creating a Figma plugin that transforms Markdown text into AutoLayout, detailing the challenges faced, iterative problem‑solving with AI assistance, code integration, and the final functional solution for seamless text conversion.
AutoLayoutFigmaJavaScript
0 likes · 5 min read

This guide explains how to configure a uTools plugin project, create the required plugin.json, build the settings panel with Vue3, integrate the Cheetah core module, implement search and open commands, handle platform‑specific app launching, manage cache, and submit the plugin for review.
Cheetah coreElectronTypeScript
0 likes · 15 min read

This article presents the motivation, architecture, component selection, user authentication flow, micro‑service integration, and technical details—including custom Lua plugins and NGINX phases—of an automated operations platform built on the cloud‑native API gateway Apache APISIX.
API gatewayApache APISIXautomation
0 likes · 14 min read

The article examines how to boost personal efficiency by developing cross‑platform plugins for macOS productivity tools such as Alfred, Raycast, and uTools, describing their architectures, a shared core module, the use of the lightweight txiki.js runtime, and practical implementation details.
AlfredJavaScriptRaycast
0 likes · 8 min read

The IntelliJ platform has moved its source code to Java 17, requiring IDE 2022.3 to run on Java 17 while still supporting some modules for older Java versions, and this shift impacts plugin development, version compatibility, and build processes for developers.
Backend DevelopmentIDEIntelliJ
0 likes · 3 min read

IntelliJ’s source code has moved to Java 17, meaning most platform and plugin modules now target Java 17, the 2022.3 IDE release requires it, and developers can use new language features by setting plugin.xml to 223, while still supporting older versions with Java 11.
Backend DevelopmentIDE MigrationIntelliJ
0 likes · 3 min read

This article explains Baidu Smart Program Developer Tools 4.0, covering its design shift from Electron to VSCode, step‑by‑step migration from local VSCode environments, plugin creation and integration, and practical tips for faster mini‑program development.
BaiduIDETool Migration
0 likes · 12 min read


SQB BlogJun 16, 2022 · Backend Development
This article describes how ShouQianBa standardized its API gateway stack by adopting Apache APISIX, detailing the reasons for selection, custom plugin development, logging enhancements, a bespoke management platform, version‑upgrade strategy, deployment model, and the resulting improvements in reliability and developer productivity.
API gatewayApache APISIXDevOps
0 likes · 13 min read

This guide explains how to create Docker images that bundle custom or demo plugins for Traefik Proxy 2.5, covering local, public, and private Git sources, Docker‑Compose development setups, and optional local DNS configuration with dnsmasq for testing complex routing rules.
DockerLocal DNSTraefik
0 likes · 18 min read

This tutorial walks through building a PostgreSQL audit plugin for the SQLE platform using Go, covering project setup, minimal plugin code, adding a SELECT‑star prohibition rule, and implementing a configurable rule that limits table column counts, complete with deployment and testing instructions.
Audit PluginGoPostgreSQL
0 likes · 11 min read

JetBrains announced the removal of Log4j from the IntelliJ platform in the 2022.1 release, explaining that the IDE’s minimal logging needs and Log4j’s complexity prompted the change, and offering plugin developers migration guidance to standard platform logging APIs, SLF4J, or java.util.logging alternatives.
IntelliJJavalog4j
0 likes · 6 min read

This article walks through the fundamentals of Figma plugin development, explaining the architecture of main and UI threads, demonstrating core features of the lego‑quiz‑figma plugin, and providing a complete workflow from creating the manifest to publishing the plugin, complete with code examples and best‑practice tips.
FigmaJavaScriptUI design
0 likes · 19 min read


政采云技术Nov 23, 2021 · Frontend Development
This article provides a comprehensive tutorial on developing Sketch plugins using JavaScript, CocoaScript, and skpm, covering background motivation, required knowledge, quick start steps, project structure, manifest configuration, menu nesting, API usage, actions, WebView integration, debugging, hands‑on examples, and best practices for front‑end engineers seeking to bridge design and code.
SketchWebViewplugin development
0 likes · 16 min read

This article provides a comprehensive guide to Rollup plugins, explaining why plugins are needed, detailing hook types and their execution timing, showing how to create simple plugins with example code, and exploring internal mechanisms such as PluginDriver, hook loading, and caching.
JavaScript bundlerRollupbuild hooks
0 likes · 23 min read

The article explains how to design and implement ESLint and StyleLint plugins for the San‑Native framework, detailing AST generation, processor creation, rule definitions for JavaScript and CSS, configuration sharing, and how these tools provide real‑time linting feedback for developers.
ASTESLintJavaScript
0 likes · 24 min read

This article walks developers through creating the StopCoding IntelliJ IDEA plugin—a Java‑based extension that reminds you to rest, drink water, and pause coding—covering IDE fundamentals, Gradle project setup, plugin.xml configuration, action implementation, UI dialogs, and usage instructions.
GradleIDE extensionsIntelliJ IDEA
0 likes · 14 min read

StopCoding is an IntelliJ IDEA plugin designed to curb prolonged coding sessions by periodically displaying an unclosable reminder dialog with a countdown, and the article provides installation instructions, usage guide, and a detailed development tutorial covering plugin structure, Swing UI, timer implementation, and key Java code snippets.
IntelliJ IDEAJavaSwing
0 likes · 7 min read

The article introduces San CLI—a command‑line tool for the San front‑end framework—explaining its purpose, core commands for project scaffolding, development, building, and inspection, as well as how to extend it with command and service plugins for customizable, production‑ready workflows.
Command Line InterfaceFrontend DevelopmentSan CLI
0 likes · 14 min read

This guide walks you through setting up the IntelliJ IDEA development environment, cloning the Community Edition source, configuring the IntelliJ Platform SDK, creating a simple plugin project, writing a custom Action class, registering it in plugin.xml, and running the plugin to see its effect.
ActionIDE extensionIntelliJ IDEA
0 likes · 7 min read

This article introduces StopCoding, an IntelliJ IDEA plugin that forces developers to take regular breaks by displaying an unclosable dialog with a countdown timer, and provides step‑by‑step installation, usage instructions, and a complete walkthrough of its Java‑based Swing and Timer implementation.
IntelliJ IDEAJavaProductivity
0 likes · 7 min read

The article walks through the complete workflow for building a Flutter plugin—using native_image_view as an example—including platform channel communication, Dart and native (iOS/Android) implementation, testing via an example app, and publishing to public or private Pub repositories.
AndroidDartFlutter
0 likes · 19 min read

This article introduces San CLI, explains why a command‑line interface boosts front‑end productivity, walks through project initialization, development server, production build, remote deployment, inspection, UI, and demonstrates how to extend the tool with custom command and service plugins.
Build ToolsCommand Line InterfaceFrontend Development
0 likes · 16 min read

This article introduces the fundamentals of IntelliJ IDEA plugin development, covering plugin types, project structure, essential components, a complete development workflow with Gradle, action registration, extension points, live templates, Dubbo integration, publishing procedures, common pitfalls, and how to include local JARs.
DubboGradleIDEA Plugin
0 likes · 11 min read

This article explains how Kubernetes' Kube‑scheduler has evolved from early Extender and multiple‑scheduler approaches to the modern Scheduling Framework, detailing its architecture, extension points, and a step‑by‑step guide to building a custom QoS plugin with code examples.
KubernetesScheduling Frameworkcloud native
0 likes · 15 min read

The article explains how Harbor Front‑End extends Lighthouse with a custom plugin—defining gatherers, audits, and categories—to uniformly monitor web pages and mini‑programs, illustrating setup, a sample native API‑call logger, and configuration steps that produce detailed performance reports alongside standard Lighthouse metrics.
JavaScriptLighthouseWeb Performance
0 likes · 14 min read

This tutorial walks you through setting up the development environment, cloning the IDEA Community source, configuring the SDK, creating a simple plugin project, writing a custom action, registering it in plugin.xml, and running the plugin inside a new IDEA instance, all with clear code examples and screenshots.
IDEA PluginIntelliJJava
0 likes · 9 min read

This tutorial shows how to use the open‑source APISIX API gateway—built on OpenResty and etcd—to create a dynamic rate‑limiting plugin in Lua, configure route matching with a radix tree, and demonstrate the feature with a test endpoint that enforces one request per second and returns HTTP 503 when exceeded.
API gatewayAPISIXDynamic Rate Limiting
0 likes · 14 min read

This tutorial walks you through setting up the development environment, configuring the IntelliJ Platform SDK, creating a simple plugin project, adding a custom Action, and running the plugin, providing all necessary code snippets and screenshots for building IntelliJ IDEA plugins.
IDE extensionsIntelliJ IDEAJava
0 likes · 8 min read

This article introduces Kong, a cloud‑native API gateway, outlines its key features such as high performance, plugin architecture, and traffic control, explains why it solves common microservice challenges, and provides detailed deployment, clustering, plugin development, and troubleshooting guidance with practical code examples.
API gatewayKongKubernetes
0 likes · 10 min read

This article introduces Kong, a cloud‑native API gateway, outlines its key features such as high performance, plugin architecture, and built‑in security, explains why it solves common microservice challenges like unified entry, scalability and CI/CD, and provides step‑by‑step guidance for deployment, clustering, custom plugin development, and troubleshooting.
API gatewayCI/CDKong
0 likes · 11 min read

This article explains how to develop extensible Chimee H5 video player plugins using React, covering plugin specifications, code examples, integration of React components via Context, event handling, and strategies for managing asynchronous behavior and plugin ordering.
Context APIReactchimee
0 likes · 9 min read

This article details the 360 team’s decision to adopt Apache APISIX for their gateway layer, describes the production architecture, containerized deployment steps, plugin development workflow, and operational metrics, providing a practical guide for building and managing a high‑performance API gateway.
API gatewayApache APISIXDocker
0 likes · 16 min read


政采云技术Sep 15, 2019 · Frontend Development
This article explains the inner workings of Babel, the JavaScript compiler, outlines what syntax it transpiles versus what requires polyfills, describes its three compilation stages, demonstrates AST generation and tokenization, and provides step‑by‑step examples of creating simple Babel plugins for code transformation.
ASTBabelCompiler
0 likes · 13 min read


58 TechSep 12, 2019 · Backend Development
This article explains the concept of PSI (Program Structure Interface) in IntelliJ IDEA, demonstrates how to obtain PsiFile objects, manipulate PsiJavaFile, PsiClass, PsiField, and add annotations and parameters, providing a practical guide for plugin developers.
IDEIntelliJ IDEAJava
0 likes · 6 min read

This comprehensive guide explains what Flutter plugins are, why they are essential, the MethodChannel communication model, step‑by‑step plugin creation, common pitfalls, testing strategies, publishing to public or private repositories, and a real‑world case study of a routing plugin, providing all the code and configuration details developers need to build and distribute their own Flutter plugins.
AndroidDartFlutter
0 likes · 20 min read

This article details the development of Kirby, a Sketch plugin created by Ctrip's front‑end team to manage design resources, enforce design language standards, and provide a full stack of features—including design token handling, static scans, WebView GUIs, and native integrations—while explaining the underlying Sketch plugin architecture, APIs, and tooling.
Sketchdesign-systemfrontend
0 likes · 15 min read

This tutorial provides a comprehensive guide to developing plugins for IntelliJ IDEA, covering environment setup, project structure, actions, components, services, persistence mechanisms, dependency management, and GUI creation using the built-in designer for developers.
ActionsIDE extensibilityIntelliJ IDEA
0 likes · 21 min read


JD TechSep 7, 2018 · Backend Development
This article provides a comprehensive guide to developing IntelliJ IDEA plugins, covering environment configuration, project structure, component and service creation, action implementation, extension points, state persistence, GUI design, and packaging, with detailed code examples and screenshots.
ActionsGUIIntelliJ IDEA
0 likes · 21 min read

This article explains Pinpoint’s architecture, its plugin system, key data structures like ServiceType and AnnotationKey, and demonstrates how to develop a custom bytecode‑injection plugin for Java applications to achieve low‑overhead distributed tracing.
Distributed TracingJava AgentPinpoint
0 likes · 11 min read


JD TechJun 26, 2018 · Backend Development
This article describes the motivation, design, implementation, and deployment of an IntelliJ IDEA plugin that automatically inserts semicolons and braces, formats code, and uses a chain‑of‑responsibility pattern to decouple business logic, providing developers with a smoother coding experience.
IDEIntelliJcode completion
0 likes · 18 min read

This article explains how RePlugin maps plugin-defined custom‑process activities to host placeholder processes, retrieves component information from the plugin APK, generates static or dynamic process‑mapping tables, adjusts component process names, and orchestrates the launch and lifecycle of these activities on Android.
AndroidRePluginmobile development
0 likes · 11 min read

This article explains how RePlugin enables a host app to recognize, map, and start custom plugin processes—including static and dynamic process mapping, adjusting component process names, launching processes via injected providers, handling process reclamation, and managing activity slot allocation for seamless plugin activity execution.
Activity LaunchAndroidRePlugin
0 likes · 11 min read

This article explains how to extend a Jenkins plugin by creating a custom Action class to pass data to job pages, adding a sidebar option, and implementing a new configuration page using Jelly templates, with step‑by‑step code examples and deployment instructions.
CI/CDJavaJenkins
0 likes · 4 min read

This article explains how the two essential Gradle plugins—replugin-host-gradle and replugin-plugin-gradle—generate configuration files, inject AndroidManifest components, create built‑in plugin descriptors, and use Transform API to modify bytecode, enabling seamless plugin development and integration in Android projects.
AndroidGradleRePlugin
0 likes · 10 min read

This tutorial walks you through creating a Drone CI plugin in Node.js that sends Telegram notifications, covering environment variable handling, plugin code, Dockerfile optimization, image building, testing, secret management, and common pitfalls for seamless CI integration.
CI/CDDockerDrone CI
0 likes · 7 min read

Pinpoint is a full‑stack, non‑intrusive tracing platform that visualizes service topology, active threads, request latency, and application health, and this article explains its architecture, data model, and step‑by‑step process for creating custom plugins—including ServiceLoader configuration, TraceMetadataProvider, and ProfilerPlugin implementations with code examples.
APMJavaObservability
0 likes · 22 min read

This guide explains how to set up the development environment, create a C# class‑library project, add Fiddler references, implement required interfaces, enable debugging, and build a custom Fiddler plugin that automatically decrypts encrypted SDK HTTP requests and displays them in clear text for testing.
Backend DevelopmentC#Fiddler
0 likes · 7 min read

This article provides a thorough overview of Babel, covering its core concepts, installation and configuration methods (including Webpack, fis3, command‑line, and programmatic usage), preset and plugin options, the compilation pipeline, AST fundamentals, and step‑by‑step instructions for creating and testing custom Babel plugins.
ASTBabelplugin development
0 likes · 13 min read

This article explores how jQuery constructs its $ objects by wrapping a simplified implementation, detailing prototype assignments, the init function, extension mechanisms, and best practices, while providing code snippets and diagrams to help developers deepen their understanding of JavaScript and frontend development.
frontendjQueryobject encapsulation
0 likes · 10 min read

This article provides a comprehensive tutorial on creating, configuring, and publishing an Android Studio plugin, covering environment setup, project creation, plugin.xml configuration, action implementation, packaging, and uploading to the JetBrains marketplace, with detailed screenshots and code examples.
Android StudioIDEIntelliJ Platform
0 likes · 7 min read

This tutorial walks readers through setting up the development environment, generating a Jenkins plugin skeleton with Maven, understanding the project structure and Jelly view files, writing the plugin code, debugging, and finally packaging and deploying the custom plugin to a Jenkins server.
EclipseJavaJelly
0 likes · 7 min read

Learn how to create, customize, and extend jQuery plugins—from basic concepts and simple color-changing examples to chainable calls, avoiding $ symbol conflicts, handling parameters, and using $.extend and $.fn.extend—while understanding the underlying prototype mechanism and best practices.
JavaScriptjQueryplugin development
0 likes · 8 min read

This article explains how Babel parses ES6 code into an AST, traverses and modifies nodes using visitors and paths, and demonstrates a practical plugin that replaces a custom abs function with Math.abs, providing a solid foundation for building advanced JavaScript transformations.
ASTBabelJavaScript
0 likes · 9 min read

This guide explains how to develop custom Gradle plugins by using the three supported approaches—directly in build.gradle, within the buildSrc directory, or in an independent module—covering plugin implementation in Groovy, extension creation, resource setup, and publishing to a local Maven repository for reuse in Android projects.
Groovybuildsrcplugin development
0 likes · 7 min read


21CTOMar 11, 2016 · Backend Development
This article explains how WordPress uses the wp_postmeta table for flexible metadata storage and the hook (action) system for dynamic code insertion, illustrating both the benefits and trade‑offs of these extensibility techniques for plugin development.
ExtensibilityMetaWordPress
0 likes · 8 min read
