Shabana Jasmin’s Post

Stop declaring variables until you read this! 🛑 Most developers think they know variables. But using var when you should be using const is the fastest way to create "ghost bugs" in your code. I’ve put together a full guide on the 4 ways to declare variables in 2026. Inside this carousel: ✅ The "Hidden" Automatic declaration (and why it’s dangerous). ✅ The breakdown of Scope: Function-scoped vs. Block-scoped. ✅ Why const isn't actually 100% immutable. ✅ When to use let vs. var. Why you need this: Mastering variables isn't just about syntax; it’s about memory management and preventing global variable leaks that slow down your applications. The Benefit: Clean code = Less debugging. Understanding these fundamentals will make your logic more predictable and your PRs much smoother. Tell me in the comments: Are you still using var in 2026, or is it const all the way for you? 🛡️ #JavaScript #WebDevelopment #CodingTips #FrontendEngineer #JSVariables #CleanCode

This one change removed 80% of our Redux Code Most developers have a love-hate relationship with Redux. The "love" is for the predictable state; the "hate" is for the mountain of boilerplate. In our project, as we grew, we hit a wall. For every new API call, we were manually writing: - 5 Action Types - 3 Action Creators - A customized Reducer - A complex Saga watcher/worker It was repetitive and error-prone. So, we decided to automate the boredom away. We built a Redux Module Factory that handles the entire lifecycle (Types, Actions, Reducer, and Sagas) with a single configuration call. The Results:  - 100+ APIs currently running on this automated architecture in production. - 80% reduction in boilerplate code. - "Zero-touch" Registration: Our system automatically aggregates and injects new modules into the Root Reducer and Root Saga. - Consistency: Every API call now follows the exact same state pattern (loading, data, error). Engineering isn't just about finishing tasks—it’s about building systems that make those tasks easier for everyone. #Javascript #React #Redux #SoftwareEngineering #Automation #SystemDesign #DeveloperExperience

I've read the definition of closures probably 10 times. "A function bundled with its lexical scope." Made sense on paper. But I never truly got it until I came across the backpack analogy. Here's how it actually works: When a function is returned from a higher order function, it doesn't leave empty handed. It carries a backpack. That backpack is attached via a hidden [[scope]] link and contains persistent memory of the variables from its outer environment, even after that outer function has finished executing. The data lives on. Attached to the function. Quietly. And once I understood that, everything clicked: → once() runs a function exactly one time, then remembers it already ran → memoize() caches previous results so you never compute the same thing twice → iterators maintain position in a sequence across multiple calls → module pattern keeps variables private, exposes only what you choose → async programming lets callbacks remember the context they were created in All of these are closures in action. I've been writing JavaScript for 3 years. Going back to the fundamentals has been humbling and genuinely eye opening. If you've been skimming over closures, I'd recommend diving deep. It changes how you read code. #javascript #webdevelopment #softwareengineering #frontenddevelopment #continuouslearning

Here’s the second artifact: the engineering-facing React + XState + Redux Toolkit demo. This is the part that made me think the "bad at diagrams" critique is aiming at the wrong target. The interesting outcome wasn’t just that the system could render a diagram. It was that the same underlying state machines could also drive an interactive demo with Redux DevTools time-travel, while keeping the graph cursor and event log coherent in both directions. The key pattern ended up being surprisingly small: reducer = machine.transition() Then side effects live in listener middleware. That gave me: pure reducers under replay natural DevTools scrubbing bidirectional synchronization between the graph and the event history So for me, the real win wasn’t "Claude made a diagram." It was: Claude helped build a system where the diagram, the demo, and the exploration tooling all fell out of the same source of truth.

Arena's Code Arena has GPT-5.5 at #9. The comments are calling the benchmark gamed. They're missing what the eval actually measures: agentic web dev. Frontend UI work. 5.5's known weak spot. The naming is the bug here, not the rankings. Open the leaderboard. The Categories panel for "Code Arena" has four entries total: WebDev (Overall, HTML, React), Image to WebDev (Overall). That's the full slice. No backend, no algorithms, no debugging. Patrick Bade caught it in one line under Arena's post: "Web Dev Code Arena". Benchmarks are slicing narrower every quarter and labels haven't kept pace. People see "Code" and import 20 years of what code work means. Half of this read might fall apart in 6 months. For now: the rankings aren't gamed. The naming is.

Day 01: Precision Matters 🔢 Kicking off my coding journey by tackling a classic: The Plus Minus Challenge. The Problem: Given an array of integers, calculate the ratios of positive numbers, negative numbers, and zeros. The catch? The output must be precise to six decimal places. The Solution: It’s all about iteration and formatting. By looping through the array and categorizing each element, we can determine the counts. The key to meeting the precision requirement in JavaScript is using the .toFixed(6) method. javascript function plusMinus(arr) { let n = arr.length; let positive = 0, negative = 0, zero = 0; for(let val of arr) { if(val > 0) positive++; else if(val < 0) negative++; else zero++; } console.log((positive/n).toFixed(6)); console.log((negative/n).toFixed(6)); console.log((zero/n).toFixed(6)); } plusMinus(arr); Key Takeaway: Even simple logic requires attention to detail—especially when it comes to floating-point precision! #CodingChallenge #JavaScript #ProblemSolving #100DaysOfCode #DataStructures

Our researcher Sławomir Zakrzewski uploaded a YAML file to a shared MLflow instance. When another user opened the run, JavaScript executed in their browser. Here's what happened. MLflow stores model artifacts - YAML configs, pickle files, dependency specs. When you open a run in the web UI, the frontend fetches that YAML and parses it client-side. The parser it uses supports a tag called !!js/function. That tag doesn't just read data. It constructs live JavaScript objects. The safe version of the parser - the one that strips these tags - was already used in two other places in the same codebase. The artifact viewer used the unsafe one. It's CVE-2026-33865, CVE-2026-33866 - Full write-up in the comments.

Well, this is interesting. Why on earth the extreme hype and churn over the 'leak' when in reality the source code was _always_ there?? I need to remember to always take a step back before getting sucked into the drama! Even so, I've got no idea what is driving all this fever. And most likely it's just one of those things, no mysterious deeper meaning. 🤷

🚀 I just open-sourced claude-reimagined - the bootstrap script I wish existed when I first set up Claude Code. Setting up a real Claude Code workstation isn't `npm install`. It's an afternoon of stitching together the CLI, MCP servers, hooks, plugins, skills, and a dozen settings that nobody documents in one place. So I automated that afternoon. A lean Claude Code setup that cuts token usage (RTK, caveman), offloads heavy output (context-mode), queries code structurally (code-review-graph), auto-selects cost-efficient models (subagent-model-router), and preserves state (pre-compact), with built-in 40+ skills. If you've ever burned a context window watching a build log scroll by, or paid Opus prices for a one-line lookup, this is for you. ⭐ Star it, fork it, break it, send PRs: https://lnkd.in/gzSdkEgH #ClaudeCode #AI #DeveloperTools #Anthropic #OpenSource #LLM #DevProductivity