This article explains the fundamentals of Linux dynamic linking, compares .so shared objects with static libraries, walks through creating and compiling a simple math library, shows how to link and run an executable, and details runtime loading, library path configuration, and common troubleshooting techniques.
This guide walks you through designing, constructing, version‑controlling, testing, and governing enterprise‑grade Jenkins Shared Libraries so you can treat your pipelines as reusable, maintainable software projects and accelerate CI/CD across teams.
Learn how to integrate Go and Java by compiling Go code into a shared library, exposing functions via cgo and JNI, and invoking them from Java with detailed setup, code examples, handling of primitive and complex data types, and full build‑and‑run instructions.
This article explains the memory layout of a program, the compilation and linking processes, and compares static and dynamic libraries, highlighting how static linking duplicates code while dynamic linking shares libraries to reduce disk and memory usage.
This article explains why reusable code should be packaged into libraries, compares static (.a) and dynamic (.so) libraries on Linux, and provides detailed commands, code examples, and troubleshooting steps for building and linking both types of libraries in C++ projects.
This article introduces PHP 8.0's built‑in FFI extension, explains its key features, demonstrates how to compile a simple C library into a shared object, and shows step‑by‑step PHP code to load the library, call its functions, and display the results.
This tutorial explains how to use Jenkins shared libraries to consolidate repetitive pipeline code, set up Jenkins with Docker Compose, define reusable Groovy methods, create Docker build files, and configure pipeline jobs for maintainable, version‑controlled CI/CD workflows.
This article explains how Jenkins shared libraries enable team collaboration by allowing Groovy scripts to be shared and version‑controlled, demonstrates how to call a specific Groovy file and all Groovy files in a directory from build.groovy, and lists the operational benefits of using shared libraries.
This tutorial explains how to call C and C++ code from Python by compiling source files into shared libraries, using the ctypes module to load and invoke functions, and demonstrates both simple C functions and C++ class methods with complete code examples and compilation instructions.
This article investigates Linux's handling of files that are in use—whether opened for reading, running as executables, or loaded as shared libraries—by experimenting with deletion, replacement, and modification, revealing how the kernel preserves file contents via inode references until all processes release them.
This tutorial explains how to create and configure a Jenkins shared library, organize its directory structure, set it up in Jenkins global settings, and reference it from a Jenkinsfile to simplify pipeline management across multiple projects.
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 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 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 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 why Python's ctypes returns incorrect values when invoking Go-compiled shared libraries, shows how to map C types correctly, and provides step‑by‑step code examples for handling both integer and string return values using proper restype declarations.
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.
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 tutorial explains how to configure Jenkins shared libraries, create Groovy utility classes, and integrate them into pipelines, covering library structure, code examples, required plugins, and usage within Jenkinsfiles to enhance DevOps workflows.
This article shares a DevOps engineer's practical experience of deploying a container‑based build resource pool on OpenShift, managing an artifact repository, and optimizing Jenkins shared libraries with parameterized pipelines to improve CI/CD efficiency and reliability.
The article explains how Jenkins' multi‑branch pipelines can be extended for enterprise‑scale CI/CD by using dynamic pipeline creation, centralized shared libraries, governance practices, and the Remote File Plugin to centralize, secure, and simplify pipeline script management across many projects.
The article outlines a systematic method for structuring native‑layer code and using dlopen, dlsym, and dlclose to dynamically load and unload .so libraries on Android, enabling selective loading, reduced memory usage, hot‑fix updates, and solutions to STL version, permission, and C++ name‑mangling challenges.
This guide explains Linux library types, naming conventions, and step‑by‑step commands for creating static (.a) and shared (.so) libraries, managing symbolic links, checking dependencies, runtime search paths, dynamic loading, and using GNU Libtool.
This guide explains the naming conventions, source code, compilation commands, and linking techniques for creating a Linux shared library (.so) using GCC, including options like -fpic, -shared, absolute‑path linking, and the -l flag after copying the library to /usr/lib.
