Tagged articles
memoization
24 articles · Page 1 of 1
This article dissects Claude Code’s 12 ms --version response and its 1.1 MB lazy‑loaded footprint, explaining a four‑layer startup chain that uses fast‑path handling, parallel prefetch, selective lazy imports, memoized global initialization, and compile‑time dead‑code elimination to achieve near‑instant CLI launch.
BunTypeScriptcli
0 likes · 15 min read

This article explains three practical categories for C functions—pure functions with no side effects, functions that read external state without modifying it, and functions that both read and depend on external variables—showing how the classification aids memoization, re‑entrancy reasoning, and inline‑function usage.
Pure Functionsc-programmingfunction classification
0 likes · 5 min read

Explore ten crucial Python design patterns—from Singleton to Memoization—complete with real-world examples for data pipelines, ETL processes, and scalable systems, helping developers write cleaner, more maintainable, and efficient code across backend and data engineering tasks.
Code ReusabilityPythonbackend development
0 likes · 9 min read

This article explains what Python closures are, how they capture surrounding variables, their key characteristics, and demonstrates multiple practical patterns—including decorators, memoization, and factories—through clear code examples and usage guidelines.
DecoratorPythonTutorial
0 likes · 10 min read

This article presents ten practical Python recursion techniques—including base case identification, progressive convergence, tail‑recursion optimization, memoization, recursion depth management, generator usage, iterative alternatives, recursion‑tree visualization, hybrid approaches, and divide‑and‑conquer implementations—each illustrated with clear code examples to improve performance and avoid stack overflow.
memoizationrecursiontail-recursion
0 likes · 7 min read

This article explores React 19's new React Compiler, explains how it automatically memoizes components to cut redundant renders, and walks through three practical examples that compare its behavior with traditional React.memo, useMemo, and useCallback techniques.
Next.jsReactReact Compiler
0 likes · 8 min read

This article presents a collection of straightforward Python techniques—such as list comprehensions, external length calculation, set usage, early‑exit loops, inlining functions, pre‑computations, generators, map(), memoization, NumPy vectorization, filterfalse, and join()—that can accelerate for‑loops anywhere from 1.3‑fold up to nearly a thousand‑fold, with explanations and benchmark results.
Loop OptimizationNumPyPython
0 likes · 18 min read

This article presents a series of practical techniques—such as list comprehensions, pre‑computing lengths, using sets, skipping irrelevant iterations, inlining functions, generators, map, memoization, vectorization, and efficient string joining—that can accelerate Python for‑loops anywhere from 1.3‑fold up to 970‑fold, with concrete benchmark results and code examples.
Loop OptimizationPythonmemoization
0 likes · 15 min read

This article presents ten practical Python code examples demonstrating how to implement and use comparison and hashing magic methods such as __eq__, __ne__, __lt__, __hash__, and related utilities like functools.total_ordering and memoization for custom objects.
functoolsmemoization
0 likes · 7 min read

This article explores how PureComponent and shouldComponentUpdate address unnecessary re‑renders in class components, compares them with functional components and hooks, and provides practical techniques—including React.memo, useCallback, setState updater functions, and refs—to optimize rendering performance in modern React applications.
PureComponentReacthooks
0 likes · 20 min read

The article examines why Ant Design's Table feels sluggish, covering its historical design choices, memoization behavior, challenges with virtual scrolling and editable cells, and how breaking‑change management influences performance and developer experience.
Ant DesignReactTable
0 likes · 10 min read

The article explains that dynamic programming boils down to two core ideas—treating problems as a set of independent sub‑problems via divide‑and‑conquer and using memoization to avoid redundant calculations—illustrated with analogies to business management and contrasted with plain recursion.
Divide and Conqueralgorithm fundamentalsdynamic programming
0 likes · 6 min read

This article examines why Ant Design’s Table component often feels sluggish, covering historical design choices, memoization pitfalls with external state, the challenges of virtual scrolling for editable tables, and how the shouldCellUpdate and onCell APIs provide finer‑grained rendering control.
Ant DesignReactTable
0 likes · 9 min read

This article outlines four key React performance optimization strategies—reducing render frequency, trimming rendered nodes, minimizing computation, and designing components wisely—while providing practical code examples such as PureComponent, shouldComponentUpdate, React.memo, lazy loading, useMemo, and virtualized lists.
LazyLoadingReactVirtualList
0 likes · 12 min read

The article shows how OpenSumi’s UI lag, caused by global‑state re‑renders, redundant props, and repeated menu and tree creation, can be eliminated by memoizing components, splitting views, caching menus, removing unneeded width props, batching icon CSS insertion, and debouncing ResizeObserver events, cutting latency from seconds to smooth responsiveness on both M1 and Intel machines.
IDEOpenSumimemoization
0 likes · 13 min read


政采云技术Sep 15, 2021 · Frontend Development
This article explains how to install and use the React Profiler tool to identify performance bottlenecks in React applications, demonstrates analysis of render phases with example code, and discusses optimization techniques such as React.memo, PureComponent, shouldComponentUpdate, and hooks to reduce unnecessary re‑renders.
Reacthooksmemoization
0 likes · 12 min read

This article explains how functional components, React hooks, and memoization techniques such as React.memo, useCallback, and useMemo can be combined to reduce unnecessary re‑renders, simplify side‑effect management, and improve overall UI performance in modern React applications.
Reactfunctional componentsmemoization
0 likes · 16 min read

This article explains the fundamental concept of recursion using a cinema‑seat analogy, demonstrates array‑sum and Fibonacci implementations in JavaScript, shows how to visualize recursive calls, discusses stack‑overflow and redundant computation issues, and presents iterative and memoized alternatives.
AlgorithmStack Overflowmemoization
0 likes · 10 min read

This article introduces the Fibonacci sequence, explains its definition, and presents six PHP implementations—including naive recursion, memoized recursion, bottom‑up iteration, iterative loop, closed‑form formula, and a lookup table—detailing their logic and performance considerations.
FibonacciPHPiteration
0 likes · 6 min read

This article explains why left‑recursive rules break recursive‑descent parsers, demonstrates how naïve grammar rewrites alter parse trees, and introduces an oracle‑based memoization technique with a custom @memoize_left_rec decorator to correctly handle left recursion in PEG parsers.
Compiler TheoryPEGPython
0 likes · 13 min read


政采云技术Oct 27, 2019 · Frontend Development
This article explains how to emulate Vue's computed properties in React by extracting calculations from the render method, using class getters, applying memoization with memoize-one, and leveraging the useMemo hook to achieve dependency‑based caching and cleaner component code.
Computed PropertiesFrontend DevelopmentJavaScript
0 likes · 7 min read

On October 23, React 16.6.0 was released, introducing React.memo for function components, React.lazy with Suspense for code‑splitting, a simpler static contextType API, new error‑boundary methods, and deprecations in StrictMode, along with installation instructions and a detailed changelog.
JavaScriptReacterror handling
0 likes · 7 min read


21CTOAug 27, 2018 · Fundamentals
Memoization, a dynamic programming technique introduced in 1968, stores results of recursive calls to eliminate redundant calculations, dramatically improving performance—as demonstrated by transforming a naïve O(2ⁿ) Fibonacci function into an O(n) version with simple code modifications and practical examples.
Fibonaccialgorithm optimizationdynamic programming
0 likes · 5 min read


21CTOOct 22, 2017 · Frontend Development
This article walks front‑end developers through the author's deductive model of React, covering transformation, abstraction, composition, state handling, memoization, list management, continuations, state maps, and algebraic effects with clear code examples.
Component ArchitectureCompositionJavaScript
0 likes · 9 min read
