React Fundamentals: UI as a Function of State

🚀 Memoization in React — When useMemo & useCallback Actually Matter Most developers learn useMemo and useCallback… 👉 But very few understand when to use them correctly And that’s where performance is won (or lost). 💡 What is Memoization? Memoization is an optimization technique: 👉 Cache the result → Avoid recomputation In React, it helps prevent: Expensive calculations Unnecessary re-renders Function re-creations ⚙️ The Real Problem Every render in React: ❌ Recreates functions ❌ Recomputes values ❌ Triggers child re-renders 👉 Even if nothing actually changed 🔥 Where useMemo Helps const filteredData = useMemo(() => { return data.filter(item => item.active); }, [data]); ✅ Avoids expensive recalculations ❌ But useless for cheap operations 🔥 Where useCallback Helps const handleClick = useCallback(() => { console.log("Clicked"); }, []); 👉 Useful only when: Passing to child components Used with React.memo 🧠 The Real Optimization Rule 👉 Memoization only matters when: ✔ Expensive computation exists ✔ Reference equality affects rendering ✔ Component re-renders are costly ⚠️ Biggest Mistake Developers Make // ❌ Over-optimization const value = useMemo(() => count + 1, [count]); 👉 You added complexity without benefit 🔥 When NOT to use Memoization ❌ Simple calculations ❌ Small components ❌ No performance issue 👉 Premature optimization = bad code 💬 Pro Insight (Senior-Level Thinking) React is already optimized. 👉 Your job is NOT to optimize everything 👉 Your job is to optimize bottlenecks only 📌 Save this post & follow for more deep frontend insights! 📅 Day 16/100 #ReactJS #FrontendDevelopment #JavaScript #PerformanceOptimization #ReactHooks #SoftwareEngineering #100DaysOfCode 🚀

Using index as a key is dangerous Every React developer has written this at least once. items.map((item, index) => (  <li key={index}>{item}</li> )) Looks fine. Works fine. But it isn't This is Post 5 of the series: 𝗥𝗲𝗮𝗰𝘁 𝗨𝗻𝗱𝗲𝗿 𝘁𝗵𝗲 𝗛𝗼𝗼𝗱 Where I explain what React is actually doing behind the scenes. Here's what actually happens when you use index as key: You delete one item from a list. React doesn't know which item was removed. It just looks at positions. So it re-renders everything from that index downward. Input states get mismatched. Animations break. Bugs appear that you can't even reproduce consistently. And... No error. Just... wrong behavior. 🔑 Here's what React actually needs: A key isn't just something unique. It needs to be stable, unique, AND tied to the data — not the position. ❌ key={index} → breaks on delete, sort, filter  ❌ key={Math.random()} → new key every render = React destroys and recreates the node  ✅ key={item.id} → stable, reliable, React knows exactly who is who The rule is simple: If your list can ever be reordered, filtered, or deleted from... index as key will silently break your UI. Use your data's ID.  If it doesn't have one, generate it at creation — not during render. const newItem = { id: crypto.randomUUID(),   name: "New Task" } One tiny prop.  Massive impact on how React tracks your entire list. In Post 6 of React Under the Hood: What Happens When You Call setState Follow Farhaan Shaikh if you want to understand react more deeply. 👉 Read the previous post - Understanding diffing algorithm: https://lnkd.in/dzW3NP_V #SoftwareEngineering #ReactJS #WebDevelopment #JavaScript #FrontendDevelopment #BuildInPublic #LearnInPublic #ReactUnderTheHood

1,200 lines of form code deleted from a production dashboard — and the forms actually work better now.   That's what happens when you swap React Hook Form for React 19's built-in Actions + useActionState on the right kind of project.   Here's the thing most tutorials won't tell you: this isn't a blanket "RHF is dead" story. It's a "know when to use what" story.   → Simple CRUD forms (login, contact, settings)? useActionState + useOptimistic handles it natively. No extra deps, no bundle cost, instant optimistic UI out of the box.   → Complex dynamic forms (nested arrays, conditional fields, 50+ field wizards)? React Hook Form still wins. React 19 has no built-in validation beyond HTML attributes — and managing deeply nested field arrays without RHF is pain you don't need.   → The middle ground is where it gets interesting. Forms with 5–15 fields and basic Zod validation? You can go either way. We leaned native and didn't look back.   The real unlock isn't "drop the library." It's that React's form primitives finally work well enough that you can evaluate each form on its own complexity instead of reaching for RHF by default on every project.   Three questions before you refactor: 1. Do any of your forms have dynamic field arrays? 2. Are you using RHF's validation resolver pattern heavily? 3. Is your form state shared across multiple components?   If you answered "no" to all three, you might be carrying a dependency you don't need.   What's your team's take still all-in on React Hook Form, or have you started migrating simpler forms to Actions?   #ReactJS #FrontendDevelopment #WebDev #JavaScript #React19 #FormHandling #DeveloperProductivity

🔁 JavaScript Tip: Convert Object → Array Easily! Working with objects in JavaScript? Sometimes you need to transform them into arrays for better handling — especially in loops, UI rendering, or API data processing. Here are 3 powerful methods you should know: ✅ Object.keys() → Get all keys ✅ Object.values() → Get all values ✅ Object.entries() → Get key-value pairs 💡 Example: const zoo = { lion: "🦁", panda: "🐼" }; 👉 "Object.keys(zoo)" → ['lion', 'panda'] 👉 "Object.values(zoo)" → ['🦁', '🐼'] 👉 "Object.entries(zoo)" → [['lion', '🦁'], ['panda', '🐼']] 🚀 These methods are super useful in React, API handling, and data transformations. #JavaScript #WebDevelopment #Frontend #ReactJS #CodingTips #Developers #100DaysOfCode

When Your API Works… But Your UI Doesn’t Update (React Query Lesson) Today I built a “create-product” to Add products, feature in my Next.js project. I used: - useQuery to fetch products - useMutation to create a new product - router navigation after submission The product was created successfully, but I noticed an issue the UI didn’t update immediately after the mutation. I’m currently digging into how query invalidation and cache updates work in React Query to fix this. Even though it’s not fully resolved yet, it’s teaching me something important: frontend development isn’t just about making things work lit’s about keeping data in sync across the UI. Still learning. Still building. For developers……When debugging issues like this, do you prefer focusing on state management first or network/data flow first? Why? Seeing my posts for the first time? I am Irorere Juliet frontend developer and a builder. I believe in growth, consistency, and showing up even when it’s hard. #Nextjs #ReactQuery #JavaScript #WebDevelopment #FrontendDevelopment #BuildInPublic

Nobody expects to fail these 7 React questions. And then they do. The tricky part? None of them are about some lesser-known API. They test whether you actually understand how React works under the hood. Here's what catches people off guard: 🔴 setState batching — calling setCount(count + 1) three times doesn't give you 3. It gives you 1. Closures are sneaky. 🟡 useRef vs useState — mutating a ref updates the value, but the UI never knows. It just sits there. Stale. 🔵 Stale closures in useEffect — an empty dependency array + setInterval = a timer that's frozen in time. Forever stuck at 1. 🟢 React.memo shallow trap — you wrapped your component in memo, feeling smart. But you're passing a new object literal every render. Memo does nothing. 🟣 useEffect cleanup order — most devs think cleanup only runs on unmount. Wrong. It runs before every single re-render effect. Every. Time. 🟡 Index as key — it works until you sort, filter, or reorder. Then React maps the wrong DOM to the wrong data. Inputs keep stale values. Good luck debugging that. 🔴 State mutation — you pushed to the array and called setState. React compared references. Same ref = no update. Your UI is frozen and you have no idea why. I put all 7 into a carousel with code snippets, wrong answers, correct answers, and explanations. Swipe through and test yourself honestly. The pattern? The questions that trip people up aren't about syntax. They're about understanding how React actually thinks. Save this for your next interview — whether you're giving it or taking it. --- #react #javascript #frontend #interviewprep #webdevelopment #softwareengineering #reactjs

🚨 My React UI wasn’t updating… and I had NO idea why. Everything looked correct. State was changing. Data was updating. But the UI? Completely stuck. 😐 I checked everything: → API → Logic → Rendering Nothing. Then I found this 👇 state.push(newItem) 💥 Problem: I was mutating state directly. React didn’t detect any change → so it didn’t re-render. 👉 That’s when it clicked: React doesn’t track changes inside objects. It tracks references. ✅ Fix: setState([...state, newItem]) 💡 Lesson: If your UI isn’t updating… you’re probably mutating state. follow me for more such learning and interview preparation content 👨💻✍️ #ReactJS #Frontend #JavaScript #SoftwareEngineering

Why does your 'ref' return 'null' the moment you wrap your input in a custom component? It is one of those React quirks that trips up even experienced developers. By default, refs do not behave like props. They are treated as special instances that stop at the component boundary to protect encapsulation. This is exactly why we need 'forwardRef'. It acts as a bridge that allows a parent component to reach through a child and grab a direct handle on an internal DOM node. The most practical application is building a reusable UI library. If you create a custom 'Input' or 'Button' component, your parent component might need to call '.focus()' or '.scrollIntoView()'. Without 'forwardRef', your parent is just holding a reference to a React internal object, not the actual HTML element. Another real-world scenario involves Higher-Order Components (HOCs). If you wrap a component with a 'withAnalytics' or 'withTheme' wrapper, that wrapper will 'swallow' the ref by default. By using 'forwardRef' in your HOC implementation, you ensure the reference passes through the wrapper and lands on the component that actually needs it. It is about making your abstractions transparent and ensuring that the parent component maintains the control it expects over the physical DOM. Using this pattern sparingly is key. It is an escape hatch for those moments where declarative state isn't enough to manage physical browser behavior. It keeps your component interfaces clean while providing the necessary access for specialized UI interactions. #ReactJS #SoftwareEngineering #Frontend #WebDevelopment #Javascript #CodingTips #CodingBestPractices

Day 3/30 — React Journey JSX looks weird at first… until THIS clicks. 👇 Most beginners think JSX is some “new language.” It’s not. ❌ It’s just JavaScript + UI structure = one powerful syntax. 👉 The shift happens when you realize: You’re not writing HTML inside JavaScript… You’re describing UI using JavaScript. That’s the breakthrough. 💡 Instead of separating logic and UI like before: ❌ HTML (structure) ❌ CSS (style) ❌ JS (logic) React flips it: ✅ Component = Logic + UI + Behavior in ONE place And JSX is what makes that possible. Once this clicks: → You stop memorizing syntax → You start thinking in components → You build faster, cleaner, scalable apps 🔥 Real mindset shift: “JSX is not HTML… it’s JavaScript that RETURNS UI.” And suddenly… everything makes sense. 👉 Follow for more real dev insights — not just tutorials.

Hook: We need to talk about the awkward phase between useState and installing Redux. For a long time, I defaulted to useState for literally everything. Then you hit a feature—like a complex multi-step form or a data-heavy dashboard—and suddenly your component has six different state setters. Your event handlers turn into a tangled mess of setLoading(false), setData(res), and setError(null), all firing at once and risking race conditions. That’s exactly when useReducer goes from being "that confusing React hook" to the most vital tool for clean architecture. ✅ When you SHOULD use it: Dependent State: When updating one piece of state requires changing another at the exact same time (e.g., resolving an API call updates loading, data, and error simultaneously). Complex Objects: When your state is a deeply nested object or array that requires precise mapping or filtering on every update. Centralizing Logic: When you want to pull messy update logic out of your UI component and into a pure, highly testable JavaScript function. You can unit-test a reducer without ever touching a React component. ❌ When you SHOULD NOT use it: Simple Primitives: Please don't write a 15-line reducer with action types and switch statements just to toggle a modal open and closed. useState is perfectly fine for isolated, flat values. Just to look "advanced": The boilerplate is real. If the state is simple, keep the code simple. Don't frustrate the next developer who reads your code just to flex a hook. 💡 Why it matters in production: At the product-company level, you don't always need Redux, Zustand, or MobX for every feature. Pairing useReducer with the Context API gives you a powerful, localized global state. You can pass the dispatch function down the tree, completely avoiding prop-drilling without bloating your bundle size with third-party dependencies. It takes a minute to shift your brain from "updating values" to "dispatching actions," but your future self (and your teammates) will thank you when debugging. What is your personal threshold for making the switch from useState to useReducer? Let's debate below. #ReactJS #FrontendEngineering #SoftwareArchitecture #CleanCode #JavaScript