Tagged articles
module
41 articles · Page 1 of 1

liandkJun 2, 2026 · Frontend Development
The article explains why having both a named export and a default export for getToken in a JavaScript/TypeScript module is not a conflict, detailing their distinct syntax, import styles, appropriate use cases, and providing complete code examples for each approach.
JavaScriptTypeScriptdefault export
0 likes · 5 min read

This article clarifies fintech‑specific definitions for platforms, systems, modules, and related architectural concepts such as frameworks, components, artifacts, plugins, controls, and middleware, illustrating their roles, boundaries, and relationships to guide consistent design and implementation across banking technology projects.
@ComponentPlatformSystem
0 likes · 8 min read

This comprehensive guide walks you through Nginx fundamentals, including its advantages, installation methods, core configuration hierarchy, key modules such as stub_status, random_index, sub_filter and gzip, log management, virtual host setup, HTTPS, rewrite rules, and smooth upgrade techniques, empowering you to deploy and optimize a high‑performance web server.
ConfigurationHTTPSload-balancing
0 likes · 32 min read

This article explains the Singleton design pattern in Python, covering various implementation methods—including modules, decorators, classic classes, __new__ method, and metaclasses—while demonstrating thread‑safety concerns and solutions with locking, and provides complete code examples for each approach.
DecoratorDesign PatternMetaclass
0 likes · 10 min read

This article explains how the if __name__ == '__main__' construct distinguishes between running a Python file as a script versus importing it as a module, prevents unintended execution, and provides practical examples for testing, main logic, and avoiding side effects.
PythonScriptif __name__ == '__main__'
0 likes · 5 min read

This article explains the special built‑in identifiers __main__ and __name__ in Python, describing how they indicate a module's execution context, how to use them to separate script and library code, and provides multiple practical code examples.
PythonScriptcode
0 likes · 6 min read

The article presents a front‑end API management approach that organizes CRUD functions into unified export statements, object‑oriented modules, and a central mapping table, demonstrating how these patterns improve code readability, maintainability, and development efficiency for large backend‑driven projects.
APIExportMapping
0 likes · 11 min read

This article explains how Linux kernel drivers use wait queues for process sleep and wake‑up, covering static and dynamic initialization, the various wait_event macros, wake‑up functions, complete driver source code, Makefile setup, and step‑by‑step build and testing instructions.
C++Kernel DriverLinux
0 likes · 16 min read

This article curates key frontend topics—including how CommonJS and ES modules handle circular dependencies, why Proxy must be paired with Reflect, practical bug‑recording and source‑code navigation, building guide pages without third‑party libraries, plus a look at clustering algorithms and a powerful CRUD code generator—offering concise insights for modern web developers.
JavaScriptProxyclustering
0 likes · 4 min read

This article explains five practical ways to use Python's -m option, including launching a simple HTTP server, generating documentation with pydoc, debugging with pdb, timing code snippets via timeit, and reliably installing packages with python -m pip, especially in multi‑version environments.
HTTP serverPythoncommand-line
0 likes · 4 min read

This article traces the evolution of software development—from machine language and assembly to high‑level languages—explores the two software crises, explains why software architecture emerged, and clarifies core concepts such as systems, subsystems, modules, components, frameworks, and architecture itself.
@ComponentDesign PrinciplesSoftware History
0 likes · 13 min read

Terraform enables declarative, code‑driven provisioning of cloud resources such as VPCs, virtual hosts, load balancers, databases, and storage across multiple providers, simplifying infrastructure management through reusable providers and modules, version control, and state tracking, thereby reducing manual configuration effort.
IaCInfrastructure as CodeTerraform
0 likes · 4 min read

This tutorial walks Rust beginners through three practical ways to declare and use modules across files, explains Cargo's file‑placement conventions, and shows how to reference sibling and external modules with the `use` and `super` keywords.
CargoRustcode organization
0 likes · 10 min read


58 TechDec 31, 2021 · Mobile Development
This article details the background, current status, and engineering architecture of introducing Swift into 58 Group’s real‑estate iOS apps, explains the two main mixed‑compilation approaches (bridging header and module), presents practical module setup, discusses reflection pitfalls, binding solutions, and performance comparisons between Swift and Objective‑C implementations.
Mixed DevelopmentObjective-C++Reflection
0 likes · 21 min read

This guide explains Python package structures, demonstrates how implicit and explicit relative imports work, shows when to prefer each style, covers disabling implicit imports with absolute_import, and teaches how to control wildcard imports using __all__ with clear code examples.
Relative Importexplicit-importmodule
0 likes · 8 min read

This article explains Python's implicit and explicit relative import mechanisms, demonstrates directory structures, shows how to use __init__.py, and provides practical code examples illustrating import statements, common pitfalls, and best practices for managing package imports in larger projects.
PackageRelative Importexplicit-import
0 likes · 8 min read

This article explains how to configure Gradle and AndroidManifest files to run individual modules independently in a multi‑module Android project and demonstrates the implementation of ARouter login interceptors to control navigation across modules.
ARouterAndroidGradle
0 likes · 10 min read

This article explains how TypeScript 4.5 adds native support for Node.js ES modules, details the evolution of Node's module system from "main" to "exports", shows the required tsconfig and package.json settings, and provides practical solutions for common import‑export pitfalls.
ESMNode.jsTS4.5
0 likes · 12 min read


58 TechOct 26, 2021 · Mobile Development
This article details 58.com’s Swift migration initiative, describing the background of Swift adoption, the objectives of the mixed‑language project, the practical steps for SDK module‑ization, bridging techniques, nullability annotations, macro handling, +load replacements, and future plans for improving Objective‑C to Swift integration.
InteropObjective-C++SDK
0 likes · 29 min read

This article shares the Kuaishou overseas client team's practical experiences and solutions for improving compilation efficiency through Swift/Objective‑C binary mixed compilation, covering single‑target and multi‑target strategies, moduleization challenges, binary compatibility, and future directions for mobile development.
CocoaPodsMixed CompilationObjective-C++
0 likes · 18 min read

This article shares the Kuaishou overseas client team's experience of improving Swift/Objective‑C mixed compilation through binary packaging, covering single‑target and multi‑target strategies, moduleization challenges, solutions for C++ and header issues, and future best‑practice recommendations for iOS development.
Mixed CompilationObjective-C++SWIFT
0 likes · 18 min read

This tutorial walks you through the Linux kernel source layout, required build tools, cross‑compilation setup, how to compile a kernel image, generate device‑tree blobs, build standalone .ko modules, and integrate those modules into a custom kernel for ARM boards.
ARMCross‑compilationLinux
0 likes · 15 min read

This article explains the fundamental concepts of software architecture—including systems, subsystems, modules, components, frameworks, and architecture itself—by defining each term, illustrating their relationships with real‑world examples, and clarifying common misconceptions for technical professionals.
@Componentarchitecture fundamentalsframework
0 likes · 10 min read

This article explains the built‑in __name__ variable in Python, how its value differs when a script is run directly versus imported as a module, and demonstrates both scenarios with clear code examples and visual diagrams.
PythonScriptexecution
0 likes · 5 min read

This article explains the evolution of software development from machine language to high‑level languages, describes the two software crises and the emergence of structured, object‑oriented, and component‑based design, and clarifies key architectural concepts such as systems, subsystems, modules, components, frameworks, and architecture itself.
@Componentmodulesoftware architecture
0 likes · 11 min read

This article traces the evolution from machine code to high‑level languages, explains the two software crises, defines system, subsystem, module, component and framework, and clarifies the true purpose and goals of software architecture for modern developers.
@Componentmodulesoftware architecture
0 likes · 12 min read

This article explores the evolution of software development from machine language to high‑level languages, explains the two software crises, and defines software architecture by distinguishing systems, subsystems, modules, components, and frameworks, emphasizing architecture as a top‑level structural solution for managing complexity.
@Componentmoduleobject-oriented
0 likes · 11 min read

This article explains the two primary Python import syntaxes—importing an entire module versus importing selected members—detailing their differences, usage of aliases, multiple module imports, and includes runnable code examples that illustrate how each form affects name resolution.
fundamentalsimportmodule
0 likes · 3 min read

This article explains the purpose and behavior of Python's built‑in __name__ variable, showing how its value differs when a script is run directly versus when it is imported as a module, with clear code examples and execution flow diagrams.
PythonScriptimport
0 likes · 5 min read

This article explains how classification thinking—organizing software into modules, components, and packages—forms the foundation of application architecture, illustrates the COLA framework’s evolution, and shows how proper layering and domain‑oriented packaging improve maintainability and scalability.
@ComponentCOLAClassification
0 likes · 15 min read

This article explains how Python’s -m option lets you run modules as scripts, provides dozens of practical command‑line examples, delves into the underlying mechanism of __main__ execution, and shows why using -m is a more convenient way to invoke Python tools.
ScriptTutorialcommand-line
0 likes · 7 min read

This article explains Python's import system, covering absolute and relative import syntax, package structure, execution contexts, and typical errors, while providing clear code examples and practical guidelines for correctly organizing and running modules.
PEP 328PackagePython
0 likes · 11 min read

The article explains the concepts of modules, coupling, and cohesion, outlines key interface design principles such as Single Responsibility and Dependency Inversion, and illustrates these ideas with practical examples of design patterns like Facade, Bridge, and Adapter, including code snippets.
Cohesioncouplingdesign patterns
0 likes · 4 min read

Webpack transforms entry files into modules through four stages—create, add, build, and processDep—where it generates a module instance via factory hooks, registers it in the compilation, runs loaders and parses the source into an AST, groups and resolves dependencies, and finally prepares the modules for bundling.
JavaScriptbuild processdependency
0 likes · 18 min read

This article describes how Ctrip's hotel query home page evolved through three architectural versions—1.0, 2.0, and 3.0—detailing the motivations, design choices, performance considerations, and the final unified module‑based structure that leverages VLayout for improved scalability and maintainability.
AndroidVLayoutmodule
0 likes · 8 min read

This article explains Python's flexible import system, covering regular imports, from‑statement imports, relative imports, optional imports, local imports, and common pitfalls such as circular and shadowed imports, while providing clear code examples and best‑practice recommendations.
PackageRelative Importbest-practices
0 likes · 13 min read

This guide walks beginners through installing Node, npm, a suitable terminal, and create‑react‑app, then demonstrates creating a project, exploring its structure, and using ES6 module syntax (import, export) to build and run a simple React‑ready environment.
ES6Reactcreate-react-app
0 likes · 11 min read

This article explains the evolution of JavaScript module patterns—including CommonJS, AMD, CMD, and ES6—by illustrating their syntax, loading behavior, and practical drawbacks, and shows how to simulate modularity with simple global objects and closures.
AMDCommonJSES6
0 likes · 11 min read


ITPUBOct 18, 2016 · Fundamentals
This article explains the concept of Linux kernel notifier chains, describes the four chain types and their core data structures, details the registration and notification mechanisms, and provides a complete example with three kernel modules and a Makefile to demonstrate building and using a custom notifier chain.
Linuxdrivermodule
0 likes · 14 min read

This article walks through Webpack's overall workflow, from initial configuration and debugging setup to the detailed compilation, module handling, plugin execution, and final asset generation, illustrating each step with code snippets and diagrams for developers seeking deeper insight.
build processloadermodule
0 likes · 17 min read


21CTOApr 2, 2016 · Frontend Development
This article details JD.com's front‑end engineering practices for its 2015 PC homepage, covering challenges, static page generation, overall architecture, modular widget system, build tools, performance optimizations, disaster‑recovery strategies, and a Q&A session that reveals practical implementation insights.
e-commerceengineeringfrontend
0 likes · 22 min read
