Tagged articles
Reactivity
32 articles · Page 1 of 1
Vue 3.6 released two release candidates in a single week with 90% of updates targeting Vapor Mode, a new compilation strategy that bypasses virtual DOM diffing, while also introducing a reactivity kernel rewrite based on alien-signals; Vue 4.0 will stabilize these features without breaking API changes.
ReactivityRelease CandidateVapor Mode
0 likes · 5 min read

Vue 3.6.0‑beta.1 brings the long‑awaited Vapor Mode to feature parity (except Suspense), claims benchmark‑level performance comparable to Solid and Svelte 5, overhauls the reactivity system with alien‑signals, and offers an opt‑in, composition‑API‑only path with clear limitations for existing projects.
Composition APIReactivitySolidJS
0 likes · 6 min read

Vue 3 replaces Vue 2’s Object.defineProperty‑based reactivity with Proxy, eliminating array method hacks, dynamic property constraints, and heavy initialization overhead, while delivering full array support, seamless property tracking, and improved performance, as illustrated by side‑by‑side code comparisons.
Object.definePropertyProxyReactivity
0 likes · 4 min read

Discover ten practical Vue3 techniques—including shallowRef, shallowReactive, toRef/toRefs, watchPostEffect, v‑for keys, custom hooks, v‑model modifiers, keep‑alive, and Web Workers—that boost performance, simplify data handling, and enhance component development for modern frontend projects.
ReactivityVue3Web Workers
0 likes · 15 min read

Vue 2’s reactivity relied on Object.defineProperty, which struggled with array mutations, dynamic properties, and performance overhead, prompting the Vue 3 team to adopt Proxy for full array support, seamless property tracking, and lazy, more efficient reactive handling, as illustrated by code comparisons.
JavaScriptObject.definePropertyProxy
0 likes · 4 min read

This article explains several advanced Vue 3 reactivity APIs—including shallowRef, triggerRef, customRef, shallowReactive, toRaw, markRaw, and shallowReadonly—detailing their differences from standard refs, performance benefits, usage patterns, and providing complete TypeScript code examples for each.
ReactivityVue3customRef
0 likes · 11 min read

Vue 2 implements reactivity by adding individual getters and setters with Object.defineProperty, which works for existing properties but struggles with many fields and dynamic changes, whereas Vue 3 uses a Proxy to intercept all operations on an object, delivering higher performance, automatic handling of added or removed properties, and greater flexibility for complex data structures.
JavaScriptObject.definePropertyProxy
0 likes · 14 min read

This article explains how Vue2 and Vue3 rewrite array methods to achieve reactivity, compares Object.defineProperty with Proxy, demonstrates common pitfalls such as includes and push causing infinite loops, and provides practical code examples for both versions.
Array MethodsJavaScriptObject.defineProperty
0 likes · 18 min read

Vue 3.4 introduces a rewritten template compiler that doubles parsing speed, a refactored reactivity system with more precise effect triggering, stable defineModel macro, v‑bind shorthand, improved hydration error messages, and several deprecated features removed, while recommending dependency updates for a smooth upgrade.
JavaScriptReactivityTemplate Compiler
0 likes · 11 min read

This article explains the fundamentals of Vue's reactivity system, comparing Vue2's Object.defineProperty approach with Vue3's Proxy-based implementation, and walks through building a custom dependency-collection model with code examples, key-level tracking, and branch-aware cleanup to achieve precise reactive updates.
Dependency CollectionFrontend DevelopmentProxy
0 likes · 9 min read

This article explains how adopting RxJS concepts—such as observable streams, pipeline operators, and pure functional transformations—can help Vue developers avoid common reactivity pitfalls, write more declarative code, and improve maintainability through practical examples and concrete guidelines.
ReactivityVuecomputed
0 likes · 19 min read

This article analyses how modern frontend view frameworks such as Solid, Svelte, Qwik, React, Vue and Angular are converging on a solidified programming paradigm while competing through fine‑grained rendering, reactive data, developer tooling, compilation strategies and the push to reduce JavaScript for better first‑page performance.
FrameworksReactivityRendering
0 likes · 14 min read

This article provides a comprehensive technical comparison between Vue and React, covering their programming and view styles, component models, routing solutions, state‑management libraries, basic feature differences, reactivity mechanisms, lifecycle hooks and side‑effect handling, with illustrative code examples.
@ComponentReactReactivity
0 likes · 15 min read

The article explains how Vue 3 improves upon Vue 2 by replacing Object.defineProperty with Proxy for reactivity, introducing a refined runtime renderer, a compiler that transforms templates into render functions, and new features such as the Composition API, script setup, and built‑in components like Fragment and Teleport.
Composition APIFrontend DevelopmentReactivity
0 likes · 6 min read

This article explains how to recreate Vue 3's computed API using the composition API, covering getter/setter handling, effect integration, caching with a dirty flag, dependency tracking, and trigger mechanisms, and provides step‑by‑step code examples to build a functional ComputedRef implementation.
Composition APIJavaScriptReactivity
0 likes · 10 min read

This article explains how Vue 3 replaces Vue 2’s Object.defineProperty reactivity with JavaScript’s Proxy, covering Proxy fundamentals, handler traps, the relationship with Reflect, internal methods and slots, and the distinction between ordinary and exotic objects, providing code examples and visual diagrams.
ECMAScriptProxyReactivity
0 likes · 15 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

This article explains Vue 3's reactivity mechanism by dissecting the ref API, showing how dependency collection and triggering work through effect functions, and describing the bit‑mask optimization introduced in Vue 3.2 to efficiently update only stale dependencies.
EffectJavaScriptReactivity
0 likes · 24 min read

This article introduces Svelte, explains its compile‑time approach versus runtime frameworks, compares code size and performance with React and Vue, details its reactivity model, compiler and runtime internals, explores the surrounding ecosystem, and shows how to build web components and assess its suitability for projects.
CompilerReactivitySvelte
0 likes · 23 min read

This article walks through building a Vue 3‑style reactivity system from scratch, covering effect functions, dependency collection with Set/Map/WeakMap, automatic tracking via Proxy, and the implementation of reactive and ref utilities, all illustrated with complete JavaScript code examples.
JavaScriptReactivityVue3
0 likes · 8 min read

This article provides a comprehensive walkthrough of Vue 3's reactivity system, covering the architecture diagram, prerequisite concepts like Proxy, Reflect, and WeakMap, and detailed source code explanations for reactive, readonly, ref, effect, and computed implementations, plus further reading links.
ProxyReactivityVue3
0 likes · 25 min read

The article examines core design decisions in modern frontend frameworks—immutable tree‑diff versus mutable reactive models, update granularity, virtual‑DOM usage, DSL choices, and the performance trade‑offs illustrated by React, Vue, SolidJS and Svelte, while also exploring component portability via WebComponents.
Framework DesignReactivitySolidJS
0 likes · 10 min read


WeChatFEJun 17, 2021 · Frontend Development
This article explains Vue’s reactive system, compares Vue 2.6’s Object.defineProperty approach with Vue 3’s Proxy implementation, details how observers are defined, collected, and triggered, and shows why the asynchronous update queue improves performance and maintainability.
JavaScriptProxyReactivity
0 likes · 16 min read


ByteFEMay 12, 2021 · Frontend Development
This article demonstrates how to leverage the @vue/reactivity package inside React by creating a custom useReactive hook for function components and a reactiveHoc higher‑order component for class components, explaining the underlying concepts, implementation steps, and practical usage with full code examples.
Custom HooksHigher-Order ComponentReact
0 likes · 7 min read

This article walks through Vue 2.0's core source code, explaining the initialization and mounting process, the three‑stage template compilation (parse, optimize, generate), the reactivity system with dependency collection, and how the virtual DOM and patch algorithm update the view.
ReactivityVirtual DOMVue.js
0 likes · 11 min read

This article provides a comprehensive overview of Vue 3, covering its evolution from Vue 2, key new features such as TypeScript support, the Composition API, performance optimizations, the modular monorepo structure, the reactivity system built on Proxy, and the Vite development server that powers its ecosystem.
Composition APIJavaScriptReactivity
0 likes · 28 min read

This article explains how Vue.js implements its reactivity system using the observer pattern, detailing the roles of Dep and Watcher classes, the observe function, Object.defineProperty handling for objects and arrays, and providing annotated code examples to illustrate the complete dependency‑collection workflow.
Dependency CollectionObserver PatternReactivity
0 likes · 16 min read

At a GitHub China meetup, the author reflects on Rich Harris’s critique of React, compares mutable versus immutable reactivity in Vue and React, examines functional programming foundations, and proposes a unified approach integrating mutable, immutable, and reactive patterns to transcend framework paradigm disputes.
ImmutableReactReactivity
0 likes · 9 min read

This article explores Vue 3's function‑based reactivity API, demonstrates how to implement a lightweight, framework‑agnostic reactivity library with watchable objects, functional combinators, and immutable updates, and shows practical examples such as a reactive counter, a todo list, immer‑style state handling, RxJS‑style pipelines, and React‑hooks‑style utilities, while discussing the underlying concepts and limitations.
ReactivityState Managementfrontend
0 likes · 12 min read

This article walks through Vue.js's internal workflow, covering global overview, initialization and mounting, compilation stages, reactivity mechanisms, virtual DOM creation, and view updating, providing a comprehensive picture for developers seeking deeper insight into the framework.
ReactivityVirtual DOMVue.js
0 likes · 6 min read

This article explains Vue's reactivity system by recreating a simple reactivity engine using JavaScript, covering dependency collection, watcher functions, observer classes, and Object.defineProperty to track and update values automatically when data changes.
Observer PatternReactivityVue
0 likes · 8 min read

This article explains why Vue.js is chosen over other MVVM frameworks, details its data observer mechanism with source code examples, and demonstrates component-based architecture in a real-world project, highlighting Vue's reactivity, watcher system, and future prospects.
Component ArchitectureObserver PatternReactivity
0 likes · 14 min read
