Debugging Array.flat() and flatMap() issues in JavaScript

A feature I worked on became difficult to maintain within weeks. Not because of complexity. Because of structure. Here’s what went wrong 👇 Problem: → Large components (400–600 lines) → Mixed UI + logic + API calls → Hard to reuse or test Root cause: ✖ No separation of concerns ✖ Everything tightly coupled ✖ Poor component boundaries What I changed: ✔ Split logic into custom hooks ✔ Separated UI from business logic ✔ Created smaller, focused components Result: → Better readability → Easier debugging → Faster feature updates Key insight: Bad structure doesn’t fail immediately. It fails as the system grows. That’s why architecture matters early. #ReactJS #FrontendArchitecture #SoftwareEngineering #CaseStudy #CleanCode #JavaScript #Engineering #ScalableSystems #Programming #Tech

CI tests were failing inconsistently across distributed teams and environments while passing locally. Reruns became the default fix. Sometimes they passed. Sometimes they didn’t. And that made one thing hard: separating infrastructure instability from real product defects. I investigated the issue end-to-end and found an intermittent environment problem (504 responses) that was being reported as test instability. From there, I started designing frameworks with failure classification as a core principle. That shift changed how I design test systems. In Playwright + JavaScript projects, I now focus on: - Condition-based waits only (no waitForTimeout) - Retry policies limited to infrastructure noise - First-failure trace capture for faster debugging - Clear separation between environment noise and product defects in reporting and debugging This is the kind of work that makes CI systems reliable: improving signal quality, reducing false failures, and enabling faster triage. How is infrastructure noise typically separated from real product failures in CI systems in practice? #Playwright #TestAutomation #SDET #QualityEngineering #JavaScript

JS engines sometimes skip creating objects that your code asks for. This isn't a bug — it's Copy Elision. 🧠 When you return an object from a function, you might think: create it → copy it out → assign it. That's three heap operations. With copy elision, V8 can skip to just one — building the object directly where it's going to live. Where it shows up in real JS Copy elision is most visible with object literals returned from functions, array spread operations, and destructuring assignments. V8's optimizing compiler (TurboFan) detects when a temporary object's only purpose is to be immediately assigned somewhere — and eliminates the middle step. Why it matters at scale In high-throughput Node.js apps, you might call a factory function millions of times per minute. Each unnecessary allocation adds GC pressure. More GC = more stop-the-world pauses = latency spikes. When I was building our aggregation pipeline processing 20M+ records, keeping factory functions small and predictable let V8 apply this consistently. How to help V8 elide more Return object literals directly — avoid storing in a local variable first. Keep return shapes consistent (same keys, same order). Avoid conditional returns with different shapes — V8 can't elide what it can't predict. Ever had an unexpected GC pause tank your API response times? What did you find when you dug in? 👇 #JavaScript #NodeJS #V8Engine #MemoryManagement #BackendEngineering #JSInternals #WebPerformance #LearnInPublic

Custom hooks can make your codebase harder to debug. Not easier. Here’s why 👇 We often extract logic into hooks: → useUsers → useAuth → useDashboard Sounds clean. But over time: ✖ Logic becomes hidden ✖ Data flow becomes indirect ✖ Debugging requires jumping files Now imagine debugging: → Component → Hook → Another Hook → API You lose context. What I’ve learned: ✔ Not everything should be a hook ✔ Keep critical logic visible ✔ Avoid over-abstraction Use hooks for: → Reusability with clarity Avoid hooks for: → Hiding complexity Key insight: Abstraction reduces duplication. But increases cognitive load. Balance matters. #ReactJS #CustomHooks #Frontend #SoftwareEngineering #Architecture #JavaScript #CleanCode #AdvancedReact #Engineering #Programming

Clean code isn’t just about making things work — it’s about making them scalable, maintainable, and future-proof. Recently, I revisited the SOLID principles, and it completely changed how I think about designing systems: 🔹 S – Single Responsibility → One class, one job 🔹 O – Open/Closed → Extend without modifying existing code 🔹 L – Liskov Substitution → Subclasses should behave like their parent 🔹 I – Interface Segregation → Keep interfaces lean and focused 🔹 D – Dependency Inversion → Depend on abstractions, not implementations 💡 Applying these principles leads to: ✔️ Cleaner architecture ✔️ Easier debugging & testing ✔️ Better scalability in real-world systems 📌 Great code is not just written — it is designed. Check it out - https://lnkd.in/g_RF35rw #SoftwareEngineering #Java #SystemDesign #CleanCode #SOLIDPrinciples #BackendDevelopment

Stop fighting TypeScript. Start using it to model your domain. 🛡️ The goal isn’t just to "fix red lines"—it's to make illegal states unrepresentable. 1️⃣ Discriminated Unions > Optionals: Stop using isLoading? or data?. Use an explicit status. If the state is 'Loading', the 'Data' shouldn't even exist in your type. 2️⃣ Types = Technical Contract: A solid type system is the best documentation. It tells the next developer exactly what the system boundaries are without opening a Wiki. 3️⃣ Strictness = Refactoring Velocity: Tight types allow you to refactor 100+ files with 100% confidence. No more "pray-and-hope" deployments. Seniors don't just write code that works. They write code that is impossible to break. Are you using TS as a fancy linter or an architectural tool? 👇 #TypeScript #SoftwareEngineering #CleanCode #WebDev #Programming #Architecture

🚀 Jetpack Compose — What actually happens inside @Composable? (Deep Dive) @Composable is not just an annotation. It's a promise to the compiler: 👉 "please transform me." Think of the Compose compiler like a secret assistant that rewrites your code before the JVM sees it. Step 1 — You write this @Composable fun Greeting(name: String) { Text("Hello, $name") } Step 2 — Compiler transformation The compiler secretly adds two hidden parameters: fun Greeting( name: String, $composer: Composer, $changed: Int ) • $composer → Tracks position in UI tree (SlotTable) • $changed → Bitmask → tells if inputs changed 👉 This is how Compose decides whether to skip execution Step 3 — Restart group (Recomposition scope) $composer.startRestartGroup(KEY) // UI code $composer.endRestartGroup()?.updateScope { c, _ -> Greeting(name, c, 1) } 👉 Registers a stored lambda 👉 Allows recomposition of ONLY this scope (not whole UI) Step 4 — Smart skipping At runtime, Compose checks: 👉 “Did anything change?” • If NO → entire function is skipped (zero work) • If YES → function re-executes 👉 This is the core performance optimization Step 5 — remember {} becomes SlotTable read val count = remember { mutableStateOf(0) } ➡️ Transforms into: val count = $composer.cache(false) { mutableStateOf(0) } 👉 Stored in SlotTable 👉 Retrieved by position 👉 Survives recomposition 🧠 Interview Summary "@Composable is a compiler transformation where functions are converted into restartable groups tracked by a Composer. A bitmask enables skipping, and stored lambdas allow recomposition of only affected scopes." ❓ Why can't @Composable be called from normal function? 👉 Because normal functions don’t have $composer ✔ Compile-time restriction 💬 This is a commonly asked deep-dive question in Android interviews #AndroidDevelopment #JetpackCompose #Kotlin #ComposeInternals #Recomposition #StateManagement #CleanArchitecture #MVVM #MVI #AndroidInterview #InterviewPreparation #SoftwareEngineer #MobileDeveloper #DeveloperLife #Programming #Coding #DevCommunity

I used to fix bugs as fast as I could. Find the line. Change the value. Ship the patch. PR merged. Ticket closed. Move on. Then the same category of bug would come back. Not the same bug. The same shape. Off-by-one in a different list. Null where null shouldn't be. A state combination that shouldn't exist but nothing prevents it. I started asking a different question. Not "how do I fix this?" But "why was this bug possible in the first place?" The answer is almost never "I made a typo". It's usually: - the type system allows null where it shouldn't - the state holds a combination that's logically invalid - or the API contract isn't enforced at the boundary Fixing the bug: 15 minutes. Fixing why it was possible: tightening a type, adding a runtime check at the API boundary, replacing two booleans with a state machine. The first fix closes a ticket. The second fix closes a category of tickets. Most debugging time isn't spent finding bugs. It's spent finding the same kind of bug for the third time. #ReactJS #Frontend #Debug #Engineering

🐞 Debuggability should be treated as a design requirement. One thing I’ve come to value more over time is this, A system that is hard to debug is hard to own. A lot of teams think about debugging only after something breaks in production. But by then, the real design question has already been answered. If the system does not expose enough context, failure clarity, and traceability, engineers end up doing what they should not have to do during an incident, For me, debuggability is not just about “having logs.” It is about designing systems so that when something goes wrong, we can actually understand • where it failed • why it failed • how far the request got • what state the system is in • what impact it is causing • what can be done next That usually means things like: • Meaningful logs, • Correlation IDs, • Clear status transitions, • Useful error messages, • Visibility across async flows, • Enough context to trace behavior across components. Because in real systems, symptoms and causes are often far apart. The error may appear in one place, while the real issue started much earlier in another service, queue, dependency, or state transition. That is why I think debuggability is a design concern, not just a support concern. A system that works is valuable. A system that can explain itself under pressure is even better. #SoftwareEngineering #SystemDesign #BackendEngineering #ProductionEngineering #Java #SpringBoot

Came from JavaScript thinking backend is just: res.json(req.body) 😄 Then met C# / .NET…........ 💀 DTOs, Domain Models, AutoMapper, Validation, Layers, Clean Architecture — and suddenly a “simple API” needs 5 files and 3 hours. JS mindset: “It works, ship it.” .NET reality: “But is it structured, safe, and scalable?” That moment when you realize… backend is not just sending JSON, it’s actual engineering.