Tencent shares four kernel-level Elasticsearch optimizations: memory-based smooth rate limiting to prevent cluster avalanches, Rollup pre-aggregation cutting storage costs 10x, moving FST off-heap to manage 50TB per node, and metadata scalability improvements supporting million shards with sub-5-second index creation.
Rolldown 1.0, a Rust‑rewritten JavaScript bundler that fully mimics Rollup's API, is now the default engine in Vite 8, delivering 10‑30× speed gains, real‑world build‑time reductions of up to 64%, seamless plugin compatibility, and a roadmap of new features while relying heavily on the Vite ecosystem.
Vite 8 replaces Rollup with the Rust‑written Rolldown, delivering dramatically faster build times, drastically lower memory usage, and near‑zero migration effort, which many early adopters describe as a surprisingly smooth and powerful upgrade for frontend projects.
This article details how a modern frontend logging system was dramatically improved by implementing intelligent database cleanup, asynchronous module loading, dynamic JSZip imports, log queue throttling, and Rollup build‑time fixes, resulting in a much smaller bundle and smoother user experience.
This article details how the open‑source SREWorks frontend evolved through a monorepo restructure, selective use of Webpack and Rollup, remote component loading, and build optimizations to achieve a more extensible, plug‑in‑friendly low‑code platform for cloud‑native operations.
This article provides a concise overview of tree shaking mechanisms in major JavaScript bundlers—Webpack/Rspack, esbuild, Turbopack, and Rollup—explaining their implementation stages, static analysis techniques, optimization trade‑offs, and practical code examples that highlight each tool's strengths and limitations.
This article explains how to reduce bundle size and improve load speed of large micro‑frontend projects by sharing common dependencies through CDN externalization, using tools such as qiankun, vite‑plugin‑cdn‑import, and Rollup plugins for HTML generation.
This article compares Rollup and Webpack for bundling JavaScript component libraries, demonstrates how to configure each tool for ESM, CJS, and UMD outputs, shows CSS extraction with plugins versus loaders, and explains why Rollup is preferred for library builds and how Vite leverages it.
This article walks through initializing a vue-mini mini‑program project, explains the build.js workflow, details how TypeScript, HTML and CSS files are processed with Babel, Rollup and PostCSS, compares its performance to Taro, and evaluates vue-mini’s current strengths and limitations.
This article explores the beta release of Taro 4.0, examines its new HarmonyOS support, CompileMode for mini‑programs, and Vite‑based build chain, then details the configuration pitfalls, debugging steps, source‑code analysis, and practical recommendations for a stable development workflow.
This article explains how Vite achieves fast development by serving ES modules directly, using a connect‑based dev server with plugin‑driven transforms, pre‑bundling dependencies via esbuild, generating hash‑based cache keys, and reusing the same plugins in Rollup for production builds.
This article explains how Vite speeds up frontend development by serving unbundled ES modules, using a plugin‑based transform pipeline, performing on‑the‑fly compilation, pre‑bundling dependencies with esbuild, and finally leveraging Rollup for production builds while maintaining consistent behavior across dev and prod environments.
This article explains why and how to build a reusable business component library for frontend teams, compares single‑package and multi‑package architectures, details the build process using webpack and Rollup, describes version‑control strategies, outlines a SOP for component development, and provides practical code examples.
This guide walks through creating a Chrome extension using Vue and Vite, covering project initialization, multi‑entry Rollup configuration for background scripts, UI development with tdesign‑vue‑next, debugging hash‑related loading issues, and final deployment steps.
This article explores the history, underlying mechanisms, and practical comparisons of frontend build tools—from early YUI and Ant scripts through AMD/CMD, Grunt/Gulp, Webpack, Rollup, esbuild, and Vite—illustrating how they transform development code into optimized production assets and addressing common performance and configuration challenges.
This article explores the evolution, core principles, and comparative analysis of frontend build tools—from early YUI/Ant and AMD/CMD to modern solutions like Webpack, Rollup, esbuild, and Vite—detailing their functionalities, implementations, performance considerations, and common challenges for developers.
The article describes building a Taro component library whose components, documentation and live demos are generated from a single Markdown source, using Rollup‑built ES modules, a Vite‑based static site, a custom webpack markdown loader, and an isolated H5 demo project to ensure maintainable, reusable code and synchronized documentation.
This article demonstrates how to build multi‑dimensional data cubes on JD's big‑data platform using Hive, comparing UNION ALL with the more concise WITH CUBE, GROUPING SETS, and WITH ROLLUP functions, and discusses practical pitfalls and optimization tips.
This article explains the purpose and ES6‑module basis of tree‑shaking, compares the implementation details of Rollup and Webpack, provides configuration and code examples, and shows real‑world bundle size and build‑time results to help developers choose the right bundler for optimal output.
Vite is a modern frontend build tool that combines a development server with hot module replacement (HMR) and a Rollup‑based bundler, enabling rapid development and efficient packaging of code for web applications.
This article introduces Apache Doris, a high‑performance, real‑time analytical database built on an MPP architecture, covering its simple FE/BE design, three data‑model types (Aggregate, Unique, Duplicate), partitioning and bucketing strategies, rollup tables, and the limitations and best practices of row‑level updates.
This article explains Doris database enhancements including Rollup indexes, Broadcast/Shuffle/Colocation joins, dynamic partition management, bitmap aggregation, and materialized view creation, providing syntax examples and operational principles for each feature.
This article provides a comprehensive guide to Apache Doris, covering how to create databases and tables with single and composite partitions, import data via broker and routine loads, understand its aggregate, uniq, and duplicate data models, and leverage rollup and prefix index features for optimized querying.
This article provides a comprehensive overview of Vite, covering its definition, advantages over traditional bundlers like Webpack and Snowpack, the underlying ESM‑based development server, hot‑module replacement mechanisms, esbuild pre‑bundling, Rollup integration, plugin architecture, and a balanced summary of its strengths and limitations.
This article explains how to design, build, and publish reusable module packages—including shared configuration libraries, UI component libraries, and native language modules—within a monorepo, covering package.json configuration, multiple entry formats (ESM, CJS, UMD), tooling choices, and publishing workflows for both frontend and Node.js projects.
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.
This article walks through MySQL 8.0’s SQL optimizer, explaining how a raw SQL statement is parsed, transformed, and optimized through stages such as Setup, Resolve, Derived‑table merging, materialization, window‑function handling, and ROLLUP processing, illustrated with diagrams and code examples.
This article compares the tree‑shaking mechanisms of Rollup and Webpack, explains the three stages Webpack uses (UglifyJS, BabelMinify, Terser), details side‑effects handling, configuration tips, and performance benchmarks, providing practical guidance for optimizing bundle size in modern JavaScript projects.
This article explains the fundamentals and implementation details of Rollup's tree‑shaking feature, showing how unused JavaScript code is identified and removed through static ES6 module analysis, with practical code examples and visual demonstrations of variable, function, and class elimination.
This article explains how Vite improves development experience over traditional bundlers by leveraging native ESM support for a fast dev server, efficient hot‑module replacement, pre‑bundling of Node modules, and seamless integration with Rollup plugins for production builds and SSR.
Explore the evolution of frontend build systems—from early manual bundling and IIFE modules through AMD/CMD, webpack, Vite, and rollup—while learning key interview questions, practical optimization techniques, and how to build a comprehensive, future‑ready construction framework for modern web development.
Vite is a native ES Module‑driven frontend build tool that offers lightning‑fast cold starts, instant hot module replacement, and on‑demand compilation by eliminating bundle steps during development, while still using Rollup for production builds, providing a performance‑focused alternative to Webpack.
The article explains why adopting modern JavaScript (ES2017) and publishing packages with the new exports field, combined with proper bundler configurations such as Webpack or Rollup, dramatically reduces bundle size and improves performance while still supporting legacy browsers when needed.
This article examines the Element‑Plus Vue3 component library, detailing its TypeScript refactor, Composition API usage, Teleport implementation, global‑instance API changes, internationalization support, and the multi‑tool build pipeline involving Rollup, Webpack, and Gulp.
This article compares Webpack and Rollup, explains why Rollup’s tree‑shaking and ES6 module support make it better for a lightweight JavaScript utility library, and provides a step‑by‑step guide to set up the project with TypeScript, ESLint, Prettier, Husky, Commitlint and Jest testing.
This article explains MySQL 8.0's new GROUPING() function, demonstrates how it works with GROUP BY ... WITH ROLLUP to differentiate regular NULL values from roll‑up summary rows, and provides multiple SQL examples and usage tips.
This article explains how to design and implement a TypeScript utility package with complex type declarations for functions like setDefaults and getProperty, demonstrates unit testing using ts‑mocha and chai, and details the compilation and packaging process for CommonJS, ES modules, type declarations, and UMD bundles using Rollup.
This article explains how modern browsers now support native ES2015 modules, why earlier performance concerns were based on outdated tests, and provides detailed guidance on using Rollup, code‑splitting, dynamic imports, modulepreload, and polyfills to achieve faster, smaller, and future‑proof web applications.
The article examines modern frontend engineering by detailing its four‑stage lifecycle—development, testing, deployment, maintenance—and reviewing modularization of JavaScript and CSS, component‑based frameworks and Web Components, code and workflow standardization, automation tools, and a real‑world migration to ES6 modules, Rollup, CSS Modules, Jest, and CI pipelines.
This article introduces Rollup as a modern JavaScript bundler, explains its advantages over CommonJS and Webpack, demonstrates quick-start commands for browsers, Node.js, and UMD formats, covers tree‑shaking with ES modules, and provides a complete TypeScript‑React library setup with configuration and publishing steps.
This article explains the concept of Tree Shaking, compares CommonJS and ES6 module formats, shows how to configure npm's pkg.module field and bundler settings (Webpack and Rollup) so that a package can be tree‑shakable while remaining compatible with existing tooling.
