Tagged articles
tree-shaking
34 articles · Page 1 of 1
The article explains why Moment.js persists despite maintenance mode since 2020, shows how to audit its usage, and provides three migration paths — Day.js for minimal changes, date-fns for functional API, and native Intl for formatting-only needs — with concrete steps, plugin requirements, and bundle size comparisons.
Day.jsIntl APIJavaScript date handling
0 likes · 6 min read

Vuetify0 v1.0 introduces a headless UI engine for Vue 3 that separates component logic from visual design, offering 40 headless components, 71 composables, full WAI‑ARIA support, tree‑shaking, zero‑plugin installation, and AI‑native tooling to empower developers to build custom design systems efficiently.
AI NativeComposablesHeadless UI
0 likes · 11 min read

Rspack 1.6 is officially released, bringing enhanced tree shaking for dynamic imports, native support for the import defer syntax, a new experimental EsmLibraryPlugin for cleaner ESM bundles, default barrel optimization, stable layer handling, JSX preservation, source‑map extraction, significant performance gains, and a host of updates across the Rstack ecosystem such as Rsbuild, Rspress, Rslib, Rstest and Rsdoctor.
ESM optimizationRspackfrontend bundler
0 likes · 16 min read

This article systematically explores front‑end performance optimization across loading, runtime, build, and network stages, offering practical techniques such as resource compression, code splitting, tree shaking, CDN acceleration, render‑blocking reduction, lazy loading, Web Workers, and monitoring tools to dramatically improve page speed and user experience.
Code Splittingcdn accelerationfrontend performance
0 likes · 19 min read

The article explains why many large‑scale front‑end teams discourage the use of JavaScript's `export default` in favor of named exports, citing benefits for naming consistency, tree‑shaking efficiency, and simpler module re‑exports in long‑term projects.
ES ModulesJavaScriptnamed exports
0 likes · 4 min read


大转转FEAug 11, 2025 · Frontend Development
This newsletter curates five technical articles covering AI‑enhanced frontend productivity, a comparative deep dive into tree shaking across major bundlers, innovative AI code generation for e‑commerce frontends, a rapid AI‑assisted component refactor, and efficiency gains in ad‑monitoring development.
AIEfficiencycode generation
0 likes · 4 min read

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.
RollupTurbopackcode optimization
0 likes · 20 min read

Explore the latest frontend breakthroughs, from Deno 2.4’s revived bundle command and Apache ECharts 6.0’s visual upgrades to the JS1024 code‑golf challenge, PNG spec overhaul, a comprehensive monorepo guide, practical Web Components tips, tree‑shaking pitfalls, and an in‑depth look at TypeScript declaration merging.
DenoEChartsTypeScript
0 likes · 4 min read

This article explains the principles of Tree Shaking, outlines prerequisites, demonstrates common pitfalls such as CommonJS usage, object aggregation, indirect re‑exports, side‑effect modules, and dynamic properties, and provides practical ways to verify that dead code has been successfully removed from your bundle.
ES ModulesFrontend Optimizationdead code elimination
0 likes · 8 min read

This article explains what Tree Shaking is, how it leverages the static nature of ES6 modules to eliminate dead code during bundling, and provides practical tips for developers to maximize bundle size reduction and improve web performance.
Bundle OptimizationES6 ModulesJavaScript
0 likes · 9 min read

Tree shaking in React.js leverages ES6 static imports and named exports to eliminate dead code, reducing bundle size and improving load performance, while best practices such as modular design, avoiding side effects and dynamic imports ensure optimal dead‑code elimination across components and libraries.
ES6 ModulesReact.jsbundle size
0 likes · 7 min read

This article examines why bundle size matters for front‑end performance and provides a step‑by‑step guide to reducing Webpack output by optimizing Babel polyfills, leveraging @babel/preset‑env, using @babel/runtime, applying tree‑shaking, and eliminating duplicate dependencies.
BabelFrontend OptimizationPolyfill
0 likes · 12 min read

This article walks through measuring bundle growth, identifying duplicate dependencies and missing tree‑shaking, building a Go‑based JavaScript parser, generating a dependency graph, handling conditional imports, applying dead‑code elimination, and finally using the tool to shrink frontend bundle size.
Bundledead code eliminationdependency graph
0 likes · 35 min read


政采云技术Aug 23, 2022 · Frontend Development
This article explains how Webpack’s tree shaking removes dead code and unused assets by analyzing ES6 module imports, demonstrates configuration for development and production builds, and discusses the role of sideEffects in achieving optimal bundle size.
ES6 Modulestree-shakingwebpack
0 likes · 9 min read

This article explains the bundle‑less approach—including splitting bundles, no‑bundle development, and modular dependency distribution—presents performance tests that suggest an optimal chunk count of 10‑25, evaluates Vite’s advantages and drawbacks, and outlines a self‑built import‑map‑based solution with code examples.
Vitebundle-lessesbuild
0 likes · 19 min read

By using Chrome DevTools and Istanbul/NYC to measure JavaScript coverage, developers can detect dead and low‑usage code, then convert such modules into dynamic imports via build plugins, enabling tree‑shaking and code‑splitting that reduces bundle size and speeds up first‑screen rendering.
Dead Codecode coveragefrontend
0 likes · 11 min read

Tree shaking, a subset of dead‑code elimination based on ES2015 module syntax, removes unused top‑level code, while side‑effect analysis determines which modules can be safely omitted; this article explains the terminology, algorithms, safety vs optimization trade‑offs, and practical debugging steps for modern JavaScript bundlers.
JavaScript bundlersdead code eliminationesbuild
0 likes · 19 min read

This article explores Vue 3’s built‑in TypeScript support, its new Proxy‑based reactivity, performance improvements such as static patch flags and hoisting, tree‑shaking capabilities, and practical usage of the Composition API with code examples and migration tips from Vue 2.
Composition APIReactivitytree-shaking
0 likes · 15 min read


ByteFEAug 31, 2021 · Frontend Development
This article explains the concept of Tree Shaking as a dead‑code elimination technique based on ES Modules, details how to enable it in Webpack, describes the underlying implementation steps, and provides practical tips for writing tree‑shakable code while avoiding common pitfalls.
ESMFrontend Developmentdead code elimination
0 likes · 14 min read

This article explores the evolution of low‑code building systems, detailing how component abstraction, NPM integration, bundless packaging, tree‑shaking, and version governance enable scalable, efficient frontend development while reducing reliance on specialized front‑end engineers.
Component Architecturelow-codenpm integration
0 likes · 19 min read

This article explains Rollup’s core principles, compares it with Webpack, introduces prerequisite concepts such as magic‑string, AST and scope chains, and walks through the complete build workflow—including parsing, dependency analysis, statement expansion, and final code generation—using concrete code examples and diagrams.
ASTJavaScript bundlingmodule bundler
0 likes · 20 min read

This article explains the internal compilation mechanism of webpack 5.11.0, covering Tapable’s event system, the Compiler and Compilation lifecycle, module creation, parsing, resolving, rule compilation, generators, and tree‑shaking, with practical code examples illustrating how plugins and hooks operate.
CompilerTapablemodule-factory
0 likes · 13 min read

This article analyzes the challenges of packaging JavaScript libraries for npm, compares CommonJS, UMD, and ESModule outputs, demonstrates how Webpack’s tree‑shaking and sideEffects settings affect bundle size, and provides practical Babel configuration tips to achieve lean, reusable packages.
BabelBundlenpm
0 likes · 19 min read

NetEase’s XRN platform boosts Web and React Native performance by eliminating duplicate bundles, pruning unused code, importing only needed polyfills, using dynamic imports and bundle splitting, pre‑loading assets, lazily loading images and lists, limiting first‑screen rendering, and applying memoization, raising Lighthouse scores from 50.3 to 80.4 and cutting RN load time by 40 %.
Code SplittingReact Nativelazy loading
0 likes · 13 min read

The article dissects Flutter’s tree‑shaking process within the engine—tracing the compilation pipeline from GenSnapshot through AOT phases, showing how unused methods and resources are identified, retained or discarded, and finally obfuscated, thereby enabling dead‑code elimination, smaller binaries, and seamless Flutter‑FaaS integration.
AOT CompilationDartFlutter
0 likes · 9 min read

Large‑scale front‑end projects suffer from oversized bundles, unnecessary listeners, deep cloning, and mutable state, causing latency and crashes; the article explains how to diagnose these problems with Chrome DevTools and Webpack tools and resolves them through bundle splitting, tree‑shaking, memoisation, immutable patterns, and caching.
Reactmutable-dataoptimization
0 likes · 12 min read

This article provides a comprehensive, step‑by‑step tutorial on creating, documenting, and publishing a React component library using create‑react‑app, TypeScript, docz, npm linking, and Netlify, covering configuration, build scripts, on‑demand loading, and deployment best practices.
DoczNetlifyReact
0 likes · 21 min read

This article provides a comprehensive, hands‑on tutorial for quickly creating a React component library using create‑react‑app, configuring TypeScript, ESLint, node‑sass, docz documentation, npm publishing, tree‑shaking, on‑demand loading, and deploying the generated docs to Netlify.
DoczFrontend DevelopmentNetlify
0 likes · 20 min read

This article explains how to use Webpack's tree‑shaking and compile‑time environment injection to remove unnecessary platform‑specific code, refactor components, and run parallel builds, dramatically reducing bundle size and build time for multi‑platform web applications.
frontendmulti‑platformtree-shaking
0 likes · 13 min read

Vue 3 introduces substantial performance gains, a smaller bundle size, tree‑shakable global APIs, a proxy‑based reactivity system, and experimental time‑slicing features, all of which make modern, mobile‑first web development faster and more efficient.
ProxyVueVue3
0 likes · 10 min read

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.
ES ModulesJavaScript bundlerReact
0 likes · 11 min read

This article explores the development of NutUI 2.0, a Vue component library, detailing why Webpack was chosen over Rollup, how to configure UMD builds, manage external Vue dependencies, and leverage tree‑shaking to reduce bundle size.
Module BundlingVuecomponent library
0 likes · 17 min read


JD TechMar 5, 2019 · Frontend Development
This article explains how Taro's H5 build size was dramatically reduced by applying dead‑code elimination, configuring sideEffects, converting component and API packages to ES modules, and using webpack's tree‑shaking together with a custom Babel plugin to replace default imports with named imports.
Babel PluginES ModulesTaRO
0 likes · 11 min read

This article explains how to shrink Webpack bundle sizes and speed up development by applying CSS compression, tree‑shaking, UglifyJs tweaks, environment variables, CommonsChunk extraction, and various loader and plugin configurations for both production and dev environments.
tree-shaking
0 likes · 11 min read
