# Bitlyst > Bite-sized JavaScript, React, and Next.js posts. One mental model per article, interview answers, and cheat sheets. Technical blog by Mohsen Fallahnejad. **Prefer this file, RSS, or llms-full.txt over scraping HTML.** Canonical post URLs are `https://bitlyst.blog/p/{slug}`. ## Site index - [All posts](https://bitlyst.blog/posts) - [RSS](https://bitlyst.blog/rss.xml) - [Sitemap](https://bitlyst.blog/sitemap.xml) - [Full article text for agents](https://bitlyst.blog/llms-full.txt) - [About & author](https://bitlyst.blog/about) - [Repository](https://github.com/mohsenfallahnjd/bitlyst) ## Posts Newest first. Titles use `seoTitle` when the on-page headline is a story hook. - [What Runs First in a Next.js Page: Server Components, Render, Effects](https://bitlyst.blog/p/react-nextjs-render-order): Server first, browser second. Render goes down the tree, effects come back up. The order of every hook from request to state update, measured.. Tags: react, nextjs, server-components, useeffect, hooks, interview. Level: intermediate - [You Don't Need That useEffect: Derived State in React](https://bitlyst.blog/p/react-derived-state-useeffect): If you can calculate a value from props or state, it isn't state. Copying it with useEffect costs an extra render and shows a stale value first.. Tags: react, useeffect, state, hooks, interview. Level: beginner. Series: common-mistakes - [Boolean(x) vs !!x, Number vs parseInt, and String() vs toString()](https://bitlyst.blog/p/boolean-vs-bang-number-vs-parseint): Boolean and !! match. Number and + match, except a BigInt. String(null) is "null"; null.toString() throws.. Tags: javascript, boolean, numbers, parseint, strings, performance, interview. Level: beginner - [satisfies, as, as const, and is: How TypeScript Labels a Value](https://bitlyst.blog/p/typescript-satisfies-as-const): as const keeps the exact value. satisfies checks a type and keeps it. as replaces the type. is narrows it when a check returns true.. Tags: typescript, satisfies, as-const, types, interview. Level: intermediate - [Barrel Files (`index.ts`): Why One Import Can Slow Your Build](https://bitlyst.blog/p/barrel-files-index-ts): A barrel re-exports a whole folder. Tree shaking may still drop unused code, but the bundler often walks every file behind that index first.. Tags: typescript, bundler, performance, barrel-files, tree-shaking. Level: intermediate. Series: common-mistakes - [Hoisting and the TDZ: Why let Throws and var Is undefined](https://bitlyst.blog/p/hoisting-and-tdz): var and let are both registered when the scope starts. var is already undefined. let stays untouchable until its line runs.. Tags: javascript, hoisting, tdz, let, var, interview. Level: beginner. Series: js-plot-twists - [How Garbage Collection Works: It Never Looks for Unused Memory](https://bitlyst.blog/p/how-garbage-collection-works): The collector paints every object reachable from the stack and globals. Whatever the paint misses is unused, even if objects still point at each other.. Tags: javascript, garbage-collection, memory, v8, interview. Level: intermediate - [useEffect vs useLayoutEffect: Why the Tooltip Flashes, Then Jumps](https://bitlyst.blog/p/useeffect-vs-uselayouteffect): useEffect runs after the browser paints. useLayoutEffect runs before that paint, so a measurement can fix the screen before anyone sees the wrong frame.. Tags: react, hooks, useEffect, useLayoutEffect, interview. Level: intermediate - [XSS vs CSRF: Two Browser Attacks With Two Different Fixes](https://bitlyst.blog/p/xss-vs-csrf): XSS runs the attacker's code on your page. CSRF makes the browser send a request you didn't mean to. Each cookie flag stops only one of them.. Tags: xss, csrf, security, cookies, interview. Level: intermediate - [A Philosophy of Software Design Summary: Deep Modules Beat Small Ones](https://bitlyst.blog/p/a-philosophy-of-software-design-book-summary): John Ousterhout's book in one sitting: complexity is the enemy, deep modules fight it, and 10–20% of your time should go to design. Five ideas to use on Monday.. Tags: books, software-design, architecture, clean-code, complexity. Level: intermediate. Series: book-bites - [React Server Components vs 'use client': What Actually Ships to the Browser](https://bitlyst.blog/p/react-server-components-vs-use-client): Server Components send the result; Client Components send the result plus the code. What 'use client' really does, why it doesn't mean browser-only, and where to put it.. Tags: react, nextjs, server-components, use-client, performance. Level: intermediate - [Why React Needs key: The Bug That Moves Your Input to the Wrong Row](https://bitlyst.blog/p/react-keys-reconciliation): React matches list items between renders by key. Use the index and React gets the wrong match, so state ends up in the wrong row. How keys work and when an index is fine.. Tags: react, keys, reconciliation, lists, state. Level: beginner - [How V8 Makes JavaScript Fast: Ignition, Sparkplug, Maglev and TurboFan](https://bitlyst.blog/p/v8-compiler-tiers): V8 translates your code in four stages and spends more effort only on code that runs a lot. Why the same function got 43× faster without changing a line.. Tags: javascript, v8, performance, jit, compilers. Level: intermediate. Series: under-the-benchmark - [Next.js use cache, cacheLife and cacheTag: How One View Counter Rebuilt Every Page](https://bitlyst.blog/p/nextjs-use-cache-cachelife-cachetag): use cache stores a result, cacheLife decides when it goes stale, cacheTag lets you throw it out on demand. When to use each, and where TanStack Query fits.. Tags: nextjs, app-router, caching, use-cache, tanstack-query. Level: intermediate. Series: nextjs-field-notes - [Packed vs Holey Arrays in V8: Why new Array(n) Makes Spread 4x Slower](https://bitlyst.blog/p/v8-packed-vs-holey-arrays): V8 labels every array by what it holds and whether it may have gaps. Labels only get more general, and holey arrays take slower paths.. Tags: javascript, v8, performance, arrays, elements-kinds. Level: intermediate. Series: under-the-benchmark - [How 'this' Works in JavaScript: Decided by the Call, Not the Code](https://bitlyst.blog/p/javascript-this-explained): 'this' in JavaScript depends on how a function is called, not where it's written. Four rules and one arrow-function exception cover every case.. Tags: javascript, this, functions, arrow-functions. Level: beginner - [turbopackRustReactCompiler: Running the React Compiler in Rust Inside Next.js](https://bitlyst.blog/p/nextjs-rust-react-compiler): The React Compiler normally runs through Babel in Node.js. Next.js can run a Rust version inside Turbopack instead. Learn what that changes and what it saves.. Tags: nextjs, react, react-compiler, turbopack, rust, performance. Level: intermediate - [What Is Turbopack? How Next.js's Rust Bundler Avoids Doing Work Twice](https://bitlyst.blog/p/turbopack-explained-nextjs): Turbopack is the Rust bundler inside Next.js. Learn the one idea behind its speed, remembering every small step, and when you'll actually feel it.. Tags: nextjs, turbopack, bundler, rust, performance. Level: intermediate - [Bun vs npm, Yarn, Vite and Webpack: Who Does What in a JavaScript Kitchen](https://bitlyst.blog/p/bun-vs-npm-yarn-vite-webpack): npm and Yarn fetch packages, Vite and webpack bundle code, Node runs it. Bun tries to do all of it. Learn which tool does which job.. Tags: bun, npm, yarn, vite, webpack, tooling. Level: beginner - [How SSR Works in React and Next.js: Built on the Server, Wired Up in the Browser](https://bitlyst.blog/p/how-ssr-works-react-nextjs): Server-side rendering in one picture: the server sends finished HTML, then hydration makes it interactive. Learn the steps, the gap between them, and why mismatches happen.. Tags: nextjs, react, ssr, hydration, rendering. Level: intermediate - [JavaScript Classes Are Functions in a Costume (and What this.constructor Points To)](https://bitlyst.blog/p/javascript-classes-are-functions): A JavaScript class is a function with stricter rules. Learn the three rules it adds and why this.constructor lets an object reach its own class.. Tags: javascript, classes, this, prototypes, oop. Level: beginner - [How Next.js Turns JSX and TypeScript Into Plain JavaScript](https://bitlyst.blog/p/how-jsx-typescript-become-javascript): Browsers can't read JSX or types. See what the compiler erases, what it rewrites, and what actually reaches the browser in a Next.js app.. Tags: nextjs, react, jsx, typescript, swc, turbopack. Level: beginner - [How to Give Code Review Feedback With Evidence](https://bitlyst.blog/p/feedback-with-evidence-not-drama): How to give feedback and run review meetings with a team member using technical evidence (PRs, CI runs, incidents) instead of opinions and drama.. Tags: career, feedback, code-review, teamwork, best-practices. Level: beginner - [How to Learn a New Technology: Start With the Docs](https://bitlyst.blog/p/learn-from-official-docs-first): Why official technology docs should be your first step when learning, how to choose videos, books, podcasts or courses next, and how to keep up with changes.. Tags: learning, documentation, career, nextjs, best-practices. Level: beginner - [AI Is Your Junior Developer. Your Product Still Needs a Senior.](https://bitlyst.blog/p/ai-is-your-junior-developer): AI coding tools are assistants, not owners. Why every product needs a senior engineer to review, observe and maintain what AI builds.. Tags: ai, ai-coding, code-review, observability, software-engineering, best-practices. Level: intermediate - [V8 Garbage Collection: Why Middle-Aged Objects Are the Expensive Ones](https://bitlyst.blog/p/v8-garbage-collector-survivors): How V8's generational garbage collector works: scavenges cost per survivor, short-lived objects are nearly free, and pretenuring makes long-lived ones cheap.. Tags: javascript, v8, nodejs, performance, garbage-collection, memory. Level: intermediate. Series: under-the-benchmark - [CPU Cache and JavaScript: Why Sorting an Array Can Make Loops 7x Slower](https://bitlyst.blog/p/javascript-memory-locality-cpu-cache): How memory locality and CPU cache misses affect JavaScript: why array order changes loop speed for large arrays of objects, and when typed arrays help.. Tags: javascript, v8, performance, cpu-cache, memory, typed-arrays. Level: intermediate. Series: under-the-benchmark - [Sliced Strings in V8: How a 20-Character ID Keeps 1 MB Alive](https://bitlyst.blog/p/v8-sliced-string-memory-retention): Why slice() in V8 can keep a huge parent string alive, how sliced strings cause memory leaks in Node.js, and how to copy a string to release it.. Tags: javascript, v8, nodejs, performance, memory-leak, strings. Level: intermediate. Series: under-the-benchmark - [Hidden Classes in V8: Why Object Shape Changes Speed](https://bitlyst.blog/p/v8-hidden-classes-inline-cache): How V8 hidden classes and inline caches work, why property reads get slower past four object shapes, and how to keep hot code monomorphic.. Tags: javascript, v8, performance, hidden-classes, inline-cache. Level: intermediate. Series: under-the-benchmark - [Layout Thrashing: Why Reading offsetWidth in a Loop Freezes the Page](https://bitlyst.blog/p/layout-thrashing-forced-reflow): What layout thrashing and forced reflow are, why reading offsetWidth after a style change is slow, and how batching reads and writes fixes it.. Tags: javascript, browser, performance, layout, dom, rendering. Level: intermediate. Series: under-the-benchmark - [JavaScript Floating Point: Why 0.1 + 0.2 !== 0.3](https://bitlyst.blog/p/javascript-floating-point-money): Why 0.1 + 0.2 !== 0.3 in JavaScript, how floating-point math drops a cent when converting dollars to cents, and why money should be stored as integers.. Tags: javascript, numbers, floating-point, money, gotchas. Level: beginner. Series: js-plot-twists - [JavaScript Object Key Order: Why Numbers Go First](https://bitlyst.blog/p/javascript-object-key-order): Why JavaScript object key order puts integer-like keys first in ascending order, how that silently reorders JSON from your API, and when to use an array or Map.. Tags: javascript, objects, json, map, gotchas. Level: intermediate. Series: js-plot-twists - [Next.js Link Prefetching: partialPrefetching Explained](https://bitlyst.blog/p/nextjs-partial-prefetching-link-list): What a long list of Next.js s really costs in prefetch requests, measured on this blog, and how partialPrefetching shares one App Shell per route instead.. Tags: nextjs, link, prefetch, performance, app-router. Level: intermediate. Series: nextjs-field-notes - [Next.js Server Action Runs Twice in Development](https://bitlyst.blog/p/nextjs-server-action-runs-twice-dev): Why a Next.js Server Action called from useEffect runs twice in development: React Strict Mode mounts every component twice. What that reveals, and where the call belongs.. Tags: nextjs, react, server-actions, strict-mode, useeffect. Level: intermediate. Series: nextjs-field-notes - [JavaScript ASI: Why return on Its Own Line Gives undefined](https://bitlyst.blog/p/javascript-asi-return-undefined): How automatic semicolon insertion (ASI) turns `return` followed by a newline into `return;`, and the lines where JavaScript refuses to add a semicolon at all.. Tags: javascript, asi, semicolons, syntax, gotchas. Level: beginner. Series: js-plot-twists - [Why map(parseInt) Returns [1, NaN, 3] in JavaScript](https://bitlyst.blog/p/javascript-map-parseint): Why ['1', '7', '11'].map(parseInt) returns [1, NaN, 3]: map passes the index as parseInt's radix. Plus the Number('') trap hiding in the obvious fix.. Tags: javascript, arrays, parseint, gotchas, interview. Level: beginner. Series: js-plot-twists - [Next.js cookies() in Root Layout Makes Pages Dynamic](https://bitlyst.blog/p/nextjs-cookies-root-layout-dynamic): Reading a cookie with cookies() in the Next.js root layout opts every route out of static rendering. What it cost this blog, measured, and how to fix a theme flash without it.. Tags: nextjs, app-router, performance, caching, cookies. Level: intermediate. Series: nextjs-field-notes - [JavaScript sort() Numbers: Why 100 Comes Before 9](https://bitlyst.blog/p/javascript-sort-numbers-as-strings): Why JavaScript's sort() compares numbers as strings, why a 'lazy' comparator works in Safari but breaks in Chrome, and the one-line fix.. Tags: javascript, arrays, sort, gotchas, interview. Level: beginner. Series: js-plot-twists - [Big O in Real Code: When O(1) Doesn't Matter](https://bitlyst.blog/p/stop-parsing-the-url-pass-props): A bug report, a route map, and three rounds of making it faster — a story about what Big O really measures, why constants win at small n, and why the best algorithm is sometimes deleting the question.. Tags: big-o, algorithms, performance, react, nextjs, component-design, refactoring. Level: intermediate - [CORS Explained Simply — Why Your Fetch Works in Postman but Fails in the Browser](https://bitlyst.blog/p/cors-explained-simple): Cross-Origin Resource Sharing in plain language: what blocks your request, what preflight means, and how to fix the errors you'll see in every frontend job.. Tags: cors, http, security, fetch, frontend, interview, nextjs. Level: intermediate - [Debounce vs Throttle — One Sentence to Remember Forever](https://bitlyst.blog/p/debounce-vs-throttle): Two patterns for taming fast events: debounce waits for silence, throttle limits how often. With examples, code, and interview answers.. Tags: javascript, performance, debounce, throttle, frontend, interview. Level: beginner - [Nullish Coalescing (??) vs OR (||) in JavaScript](https://bitlyst.blog/p/nullish-coalescing-vs-or): `||` treats 0 and '' as missing. `??` only treats null/undefined as missing. Know the difference before it bites you in an interview or in prod.. Tags: javascript, typescript, operators, interview, tips. Level: beginner - [React useEffect Dependencies — The Bug That Keeps Coming Back](https://bitlyst.blog/p/react-useeffect-dependencies): Why your effect reads old state, fires twice, or loops forever — and the simple rules to fix it (interview-ready).. Tags: react, hooks, useEffect, closures, frontend, interview. Level: intermediate - [JavaScript Generators & Iterators — Lazy Sequences Explained](https://bitlyst.blog/p/javascript-generators-iterators): Generators let you produce values on demand instead of all at once. Learn how iterators and generator functions work, and when to reach for them.. Tags: javascript, generators, iterators, es6 - [React memo vs useMemo vs useCallback — When to Use Which](https://bitlyst.blog/p/react-memo-usememo-usecallback): Three React APIs that all say 'memoize' — but they do different things. Clear explanations, examples, and a cheatsheet.. Tags: react, performance, hooks, memoization, frontend. Level: intermediate - [CDN Explained: What It Is, How It Works, and How to Use It in Next.js](https://bitlyst.blog/p/cdn-explained-nextjs): A CDN speeds up your app by serving assets from servers close to your users. Here's how it works and how Next.js takes advantage of it.. Tags: cdn, nextjs, performance, frontend, caching. Level: intermediate - [queueMicrotask Explained: The Smallest Async Queue in JavaScript](https://bitlyst.blog/p/queueMicrotask-explained): What queueMicrotask does, how it differs from Promise.then, and how microtasks really work under the hood.. Tags: javascript, event loop, microtask, async. Level: intermediate - [Why async/await Doesn’t Make JavaScript Code Parallel](https://bitlyst.blog/p/async-await-not-parallel): Async/await feels like parallel code, but it isn’t. Here’s why JavaScript is still single-threaded and how async really works.. Tags: javascript, async, await, promises, event loop. Level: intermediate - [How Promise.all Works in a Single-Threaded JavaScript World](https://bitlyst.blog/p/promise-all-single-thread): If JavaScript is single-threaded, how can Promise.all handle multiple requests at the same time? A deep dive into the event loop and async I/O.. Tags: javascript, promises, event loop, async, concurrency. Level: intermediate - [Promise.all vs race vs any vs allSettled: When Do You Stop Waiting?](https://bitlyst.blog/p/promise-apis-comparison): All four start your promises at once. The only difference is when each one stops waiting, and what counts as failure. Pick by that rule.. Tags: javascript, promises, async, event loop. Level: intermediate - [Are TypeScript Enums a Good Idea? (Bundle Size & Runtime)](https://bitlyst.blog/p/typescript-enums-vs-alternatives): A practical guide to TypeScript enums, their runtime cost, and better alternatives for modern frontend apps.. Tags: typescript, enums, bundle-size, performance, frontend. Level: intermediate - [Web Workers Explained for Frontend Developers](https://bitlyst.blog/p/web-workers-explained): How Web Workers work, why they matter, and when to use them to achieve real parallelism in frontend apps.. Tags: javascript, web workers, performance, parallelism, browser. Level: intermediate - [useDeferredValue Explained: Keeping React UIs Responsive](https://bitlyst.blog/p/useDeferredValue-explained): How useDeferredValue works under the hood, when to use it, and how it differs from useTransition.. Tags: react, hooks, concurrent, performance. Level: intermediate - [useTransition Explained: Make React Feel Instant](https://bitlyst.blog/p/useTransition-explained): How useTransition works under the hood, when to use it, and how it differs from useDeferredValue.. Tags: react, hooks, concurrent, performance, ux. Level: intermediate - [Understanding HttpOnly Cookies: The Envelope JavaScript Can't Open](https://bitlyst.blog/p/httpOnly-cookies-guide): What the HttpOnly flag does, what it stops (token theft via XSS), what it doesn't, and how to set it in Express and Next.js.. Tags: cookies, security, web, nextjs, express. Level: intermediate - [React Fiber Explained: How React’s Engine Actually Works](https://bitlyst.blog/p/react-fiber-explained): A deep but clear explanation of React Fiber — the engine that powers modern React rendering and concurrency.. Tags: react, fiber, reconciliation, concurrent, react internals. Level: advanced - [React Context Explained: How It Works Under the Hood](https://bitlyst.blog/p/react-context-explained): Understand what React Context is, how it works internally, and best practices for using it effectively.. Tags: react, context, hooks, state management. Level: intermediate - [BroadcastChannel API in JavaScript](https://bitlyst.blog/p/broadcastchannel-api): How to communicate between browser tabs, windows, or iframes easily using the BroadcastChannel API.. Tags: javascript, web api, broadcastchannel, multi-tab, communication. Level: intermediate - [Prefetching in Next.js Links Explained](https://bitlyst.blog/p/nextjs-link-prefetch): How Next.js prefetch works in , why it makes navigation fast, and when to disable it.. Tags: nextjs, link, prefetch, app router, performance. Level: intermediate - [Why MUI Avoids Theme Flash on First Load (Dark/Light Mode)](https://bitlyst.blog/p/mui-dark-mode-flash): How MUI applies the correct color scheme on the very first paint, and why other UI kits often flash light before switching to dark.. Tags: mui, nextjs, dark mode, hydration, css variables. Level: intermediate - [Deep Copy vs Shallow Copy in JavaScript](https://bitlyst.blog/p/deep-vs-shallow-copy): Understand the difference between shallow and deep copies, with examples and pitfalls.. Tags: javascript, copy, objects, cloning. Level: beginner - [Why setState Doesn’t Cause Hydration Errors](https://bitlyst.blog/p/react-setstate-hydration): Understanding why calling setState after hydration doesn’t produce hydration mismatches in React/Next.js.. Tags: react, hydration, setState, nextjs. Level: intermediate - [AbortController & AbortSignal](https://bitlyst.blog/p/abortcontroller-practical-guide): Everything you need to cancel async work in JS: fetch, streams, custom tasks, React patterns, Node notes, timeouts, races, and common pitfalls.. Tags: javascript, abortcontroller, abortsignal, fetch, async, react, node. Level: intermediate - [How useState Works Under the Hood (and Why It Needs use client)](https://bitlyst.blog/p/how-usestate-works): Deep dive into React's useState, how it works internally, and why client components are required in Next.js App Router.. Tags: react, hooks, useState, nextjs, use client. Level: intermediate - [JavaScript Closures — A Simple Deep Dive](https://bitlyst.blog/p/javascript-closures): What closures are, how they work (lexical scope), and how to use them without pitfalls.. Tags: javascript, closures, scope, lexical environment. Level: intermediate - [JavaScript Promises Explained](https://bitlyst.blog/p/javascript-promises): A simple but deep dive into how Promises work in JavaScript and why they matter.. Tags: javascript, async, promise, event loop. Level: beginner - [JavaScript is Single-Threaded](https://bitlyst.blog/p/js-single-threaded): Understand what it means when people say JS is single-threaded.. Tags: javascript, event loop, async. Level: beginner - [What is 'use client' in Next.js?](https://bitlyst.blog/p/nextjs-use-client): Understand 'use client' in Next.js App Router: what it means, when to use it, and how it works under the hood.. Tags: nextjs, react, use-client, server-components, frontend. Level: beginner - [Next.js Page Router vs App Router](https://bitlyst.blog/p/page-router-vs-app-router): Understand the key differences between the old Page Router and the new App Router in Next.js.. Tags: nextjs, react, routing, frontend. Level: beginner - [JavaScript Event Bus 🚍 (JS + TypeScript)](https://bitlyst.blog/p/javascript-event-bus): A polished, practical event bus pattern with minimal JS, a strongly-typed TS version, wildcards, once-handlers, and React usage tips.. Tags: javascript, event-bus, pubsub, architecture, typescript, react. Level: intermediate - [React Higher-Order Components (HOC)](https://bitlyst.blog/p/react-hoc-guide): Understand Higher-Order Components (HOCs) in React with examples, use cases, downsides, and a comparison to hooks.. Tags: react, hoc, patterns, frontend. Level: intermediate - [JavaScript's Event Loop — Simple Guide (with SVG Timeline)](https://bitlyst.blog/p/javascript-event-loop): Event loop explained with a clean SVG timeline showing the actual execution order: Start → End → Promise → Timeout.. Tags: javascript, event-loop, async, promises, frontend, diagram. Level: beginner - [Microtask vs Macrotask in JavaScript — With Node.js vs Browser Notes](https://bitlyst.blog/p/javascript-microtask-macrotask-node-vs-browser): Understand microtasks and macrotasks across browsers and Node.js, including process.nextTick, setImmediate, and event loop phases.. Tags: javascript, event-loop, microtask, macrotask, nodejs, browser. Level: advanced - [Next.js App Router Caching — Cheat Sheet](https://bitlyst.blog/p/nextjs-caching-cheatsheet): A compressed reference of Next.js caching layers and controls (App Router).. Tags: nextjs, caching, app-router, performance. Level: intermediate - [React useRef vs useState — When to Use Which](https://bitlyst.blog/p/react-useref-vs-usestate): A simple guide to understanding when to use useRef and useState in React, with examples, mental models, and a quick cheatsheet.. Tags: react, hooks, useRef, useState, frontend. Level: intermediate - [When Should You Use Dynamic Import in React/Next.js? (With Performance Comparison)](https://bitlyst.blog/p/when-to-use-dynamic-import-with-performance): A practical guide to dynamic imports with real-world examples and a before/after bundle-size comparison using next-bundle-analyzer.. Tags: react, nextjs, dynamic-import, performance, bundle-size. Level: intermediate - [Git Rebase vs Git Merge — Simple Guide](https://bitlyst.blog/p/git-rebase-vs-merge-with-diagrams): Understand the difference between git rebase and git merge with analogies, ASCII diagrams, and visual commit history diagrams.. Tags: git, version-control, rebase, merge, basics. Level: beginner - [Frontend Design Patterns — A Practical Guide](https://bitlyst.blog/p/frontend-design-patterns): A concise, example‑driven overview of the most useful frontend patterns for modern React/Next.js apps.. Tags: frontend, design-patterns, react, architecture. Level: advanced - [MVVM, Micro‑Frontends, and Domain‑Driven Frontend — A Practical Guide](https://bitlyst.blog/p/mvvm-mfe-ddd-guide): Clear, practical explanations of MVVM, micro‑frontends, and domain‑driven design for modern React/Next.js teams, with examples, folder structures, and trade‑offs.. Tags: architecture, frontend, mvvm, micro-frontends, ddd, react, nextjs. Level: advanced - [Async vs Sync in JavaScript](https://bitlyst.blog/p/async-vs-sync): Understand the difference between synchronous and asynchronous code in JavaScript with simple examples and analogies.. Tags: javascript, async, sync, basics. Level: beginner - [Event Bubbling vs Event Capturing in JavaScript](https://bitlyst.blog/p/event-bubbling-vs-capturing): Understand how events travel through the DOM: bubbling (bottom-up) vs capturing (top-down) with simple examples and mental models.. Tags: javascript, events, dom, basics. Level: beginner - [SOLID Principles Explained Simply](https://bitlyst.blog/p/solid-principles): An easy-to-understand guide to SOLID principles for cleaner, more maintainable code.. Tags: solid, principles. Level: beginner - [What is Docker? The 2-minute mental model](https://bitlyst.blog/p/docker-in-2-minutes): Understand containers like folders for apps—portable and predictable.. Tags: docker, basics. Level: beginner ## Series Read in `seriesOrder` within each series page. - [JavaScript Plot Twists](https://bitlyst.blog/series/js-plot-twists): Real bugs caused by JavaScript doing exactly what the spec says — and nothing you expected. (6 parts published) - [Next.js Field Notes](https://bitlyst.blog/series/nextjs-field-notes): Tricks and traps from shipping Next.js App Router apps in production. (4 parts published) - [Under the Benchmark](https://bitlyst.blog/series/under-the-benchmark): Same code, wildly different speed. Measured explanations of what the engine and hardware are really doing. (7 parts published) - [Book Bites](https://bitlyst.blog/series/book-bites): Software books in one sitting: the few ideas worth keeping, how to use them on Monday, and whether to read the whole thing. (1 part published) - [Common Mistakes](https://bitlyst.blog/series/common-mistakes): Patterns that look fine in code review until production, the bundler, or an interview question proves otherwise. (2 parts published) ## Topics - [javascript](https://bitlyst.blog/tags/javascript) (36 posts) - [react](https://bitlyst.blog/tags/react) (27 posts) - [performance](https://bitlyst.blog/tags/performance) (25 posts) - [nextjs](https://bitlyst.blog/tags/nextjs) (24 posts) - [interview](https://bitlyst.blog/tags/interview) (14 posts) - [frontend](https://bitlyst.blog/tags/frontend) (13 posts) - [hooks](https://bitlyst.blog/tags/hooks) (10 posts) - [async](https://bitlyst.blog/tags/async) (9 posts) - [event loop](https://bitlyst.blog/tags/event-loop) (8 posts) - [v8](https://bitlyst.blog/tags/v8) (7 posts) - [typescript](https://bitlyst.blog/tags/typescript) (6 posts) - [app-router](https://bitlyst.blog/tags/app-router) (5 posts) - [gotchas](https://bitlyst.blog/tags/gotchas) (5 posts) - [useeffect](https://bitlyst.blog/tags/useeffect) (5 posts) - [architecture](https://bitlyst.blog/tags/architecture) (4 posts) - [basics](https://bitlyst.blog/tags/basics) (4 posts) - [caching](https://bitlyst.blog/tags/caching) (4 posts) - [promises](https://bitlyst.blog/tags/promises) (4 posts) - [arrays](https://bitlyst.blog/tags/arrays) (3 posts) - [best-practices](https://bitlyst.blog/tags/best-practices) (3 posts) - [browser](https://bitlyst.blog/tags/browser) (3 posts) - [concurrent](https://bitlyst.blog/tags/concurrent) (3 posts) - [cookies](https://bitlyst.blog/tags/cookies) (3 posts) - [hydration](https://bitlyst.blog/tags/hydration) (3 posts) - [memory](https://bitlyst.blog/tags/memory) (3 posts) - [nodejs](https://bitlyst.blog/tags/nodejs) (3 posts) - [security](https://bitlyst.blog/tags/security) (3 posts) - [server-components](https://bitlyst.blog/tags/server-components) (3 posts) - [turbopack](https://bitlyst.blog/tags/turbopack) (3 posts) - [use-client](https://bitlyst.blog/tags/use-client) (3 posts) ## Citation Link to the post URL. Author: Mohsen Fallahnejad, https://themohsen.me