This tutorial walks through creating a simple Java module, packaging it into a JMOD file, and using jlink to build a custom runtime image that shrinks the size from roughly 400 MB to 28 MB, then demonstrates compiling, inspecting, and running the application.
This article explains why Java modularization was introduced, outlines the problems with the pre‑Java 9 classpath, introduces the Java Platform Module System (JPMS) and its core file module-info.java, and provides detailed guidance on concepts, syntax, best practices, real‑world examples, IDE setup, and common pitfalls.
Node.js now marks require(esm) as stable in LTS releases, allowing CommonJS files to require synchronous ESM modules without extra flags, simplifying package.json configuration, eliminating the need for dual packages, and resolving the long‑standing CJS‑ESM split for the vast majority of projects.
This article traces the history and reasons behind JavaScript’s module formats—from early AMD and UMD to Node’s CommonJS and the modern ECMAScript modules—explains migration challenges, tooling, testing nuances, and best practices for managing dual builds in contemporary projects.
This article outlines the motivations, challenges, and step‑by‑step solutions for migrating over 100 Java applications to JDK 21, covering dependency conflicts, module system adjustments, Maven plugin compatibility, garbage‑collector selection, and practical build and deployment practices to ensure a smooth upgrade.
This article explains the purpose and mechanics of the new React directives ‘use client’ and ‘use server’, showing how they let developers express client‑server boundaries directly in the module system, turn server functions into type‑safe RPC calls, and embed client components as scripts for seamless full‑stack integration.
This article reviews the historic use of Immediately Invoked Function Expressions (IIFEs) in JavaScript, explains their drawbacks, and demonstrates how native ES modules provide a cleaner, more maintainable, and standards‑based alternative for organizing code in modern front‑end development.
ROFF is a Rust‑implemented, seven‑layer gateway that delivers high‑throughput load balancing with memory‑safe performance, TLS hardware offload, native QUIC/HTTP3 support, a hot‑reload/upgrade mechanism, and an extensible module system allowing over thirty built‑in filters and custom Rust macros.
The Java Module System (Project Jigsaw) introduced in Java 9 defines uniquely named modules with descriptors that declare dependencies, exported and opened packages, and services, enabling clear dependency management, smaller custom runtimes, stronger encapsulation, improved performance, security, and easier maintenance, while supporting migration strategies and best‑practice guidelines.
This article explains how upgrading Java and Groovy dependencies caused an IllegalAccessException in Caffeine's asynchronous cache due to module encapsulation, and details the attempted fixes including JVM '--add-opens' arguments and dependency version adjustments.
This article provides a thorough analysis of upgrading Java applications from JDK 8 to JDK 11, covering performance improvements, garbage collector comparisons, new language features, module system changes, practical migration steps, common pitfalls, and best‑practice recommendations for enterprise backend development.
This article explains front‑end engineering, tracing its evolution from simple page building to modern modular architectures, and details how tools like npm, CommonJS, AMD, CMD, ESModules and webpack address challenges such as scope pollution, code standards, resource optimization, testing, CI/CD, and team collaboration.
This article explains why frontend projects historically needed bundling, describes the evolution of module systems such as CommonJS, AMD, CMD, and ESM, compares bundlers like Webpack and Rollup, and introduces bundle‑less tools like Vite that leverage native ES modules to improve development experience and performance.
This article explains the concept of Native‑ESM, traces the evolution of JavaScript module systems from IIFE to ES Modules, and shows how Vite leverages native ES modules, ESBuild, and caching to achieve dramatically faster cold starts and hot updates compared to traditional bundlers like Webpack.
This article provides a comprehensive overview of front‑end modularization, covering the definition of modules, the evolution from early script tags through AMD/CMD to CommonJS and ES6, and explains why modern module syntax enables better dependency management and tree‑shaking.
This article explains the need for JavaScript modularization, compares major module standards such as CommonJS, AMD, CMD, UMD and ES Modules, and traces their historical evolution, highlighting benefits, drawbacks, and practical usage examples for modern front‑end development.
This article explains how Node.js implements module loading using the CommonJS wrapper, demonstrates the role of the built‑in vm module for isolated execution, and walks through building a custom Require function with path resolution, file reading, extension handling, caching, and automatic extension resolution.
Node.js implements the CommonJS module system by using global require and module objects that, when a module is requested, resolve its absolute path, load and wrap the file, evaluate it to populate module.exports, cache the result, and handle exports, circular dependencies, JSON and native addons.
This article explains Java's parent delegation class‑loading model, describes the four built‑in class loaders, details why delegation is needed, shows the loadClass implementation, and discusses how and why the mechanism can be overridden in frameworks such as JDBC, Tomcat, OSGi, and the Java 9 module system.
Continuing the Baidu App mixed‑language guide, this article explains how EasyBox‑generated component targets (frameworks and libraries) are organized into modules, configured for Objective‑C/Swift interoperability, unit‑tested, linked across components, and packaged as binaries using module maps, build settings, and lipo merging, while recommending frameworks for smoother distribution.
This article outlines the preparation, framework redesign, and common challenges of integrating Swift into an existing Objective‑C iOS client, covering ABI stability, mixed compilation, module configuration, code standards, and future migration plans.
The article explains how Taobao’s front‑end team created the Industry Cube platform—a data‑driven, component‑based system that streamlines the rapid construction, operation, and maintenance of industry pages, addressing scalability, performance, and customization challenges encountered during large‑scale events like the 618 promotion.
The article traces JavaScript’s module evolution from inline scripts to CommonJS’s file‑scoped exports and require system, explains its minimal bundler implementation, compares AMD and CMD alternatives, and finally introduces native ES6 import/export syntax, highlighting key differences and the gradual deprecation of CommonJS.
This article explains the evolution of Alibaba’s Tianma build platform—from early WordPress sites to modern Rax‑based modular UI—covering its design principles, module concepts, data standardization, dependency de‑duplication, rendering services, multi‑terminal caching, and future directions for front‑end development.
This article explains how Alibaba’s Tianma building system evolved from early WordPress sites to a modular, flat, cross‑terminal architecture that separates front‑end and operations, standardizes data schemas, manages dependencies with a seed mechanism, and delivers high‑performance rendering across devices.
The article explains how, with Swift 5.1’s ABI stability, teams can combine Swift and Objective‑C in iOS apps by preferring CocoaPods‑based modular development over bridging headers, detailing the LLVM module system, modulemap setup, namespace and linking issues, and best‑practice steps for a smooth migration.
This article delves into Node.js’s module system, explaining the CommonJS specification, how Node implements module loading, resolution, caching, and execution, and provides detailed analysis of core source code including Module constructor, require, _load, _resolveFilename, and file extension handling.
James M. Snell explains the fundamental differences between CommonJS and ES6 modules in Node.js, why loading and execution timing matter, the challenges of supporting both systems, and the roadmap for native ES6 module support.
Redis 4.0 introduces a groundbreaking module system for custom data types, improves replication with tag‑based PSYNC, adds an LFU eviction policy, provides non‑blocking UNLINK deletion, and expands memory introspection commands, collectively enhancing performance, flexibility, and extensibility of this popular in‑memory database.
An in‑depth overview of KISSY, Alibaba’s home‑grown front‑end framework, covering its origins, architectural layers, modular system, component library, tooling, mobile support, testing, CI, and real‑world deployment examples such as shop and product detail pages, highlighting strengths and current challenges.
