ESLint Prettier Setup for Node.js

🚀 Day 7 / 30 - JavaScript Coding Practice Today’s challenge: Recreating the Array.map() functionality — without actually using it 👀 Problem: Apply a transformation function to each element of an array and return a new array. 💡 Key Insight: This problem helped me understand what’s happening under the hood of built-in methods like map(). 👉 Instead of relying on .map(), I used a loop to: Iterate through each element Apply the given function with both value & index Build a new transformed array Solution: var map = function (arr, fn) {     let transArr = []     arr.forEach((element, i) => {         transArr.push(fn(element, i) ?? element);     });     return transArr; }; #JavaScript #DSA #CodingPractice #100DaysOfCode #FrontendDevelopment #ProblemSolving

Most developers know var is bad… Yet it’s still showing up in codebases in 2026 😬 Here’s why it keeps breaking things 👇 🔴 var is function-scoped, hoisted, and re-declarable → Leads to silent, hard-to-trace bugs 🟢 const is block-scoped and strict → Fails fast, catches mistakes early, keeps your code predictable 💡 The rule is simple: → const by default — always → let when reassignment is needed → var — never again ⚡ Quick 5-second fix: Add "no-var": "error" to your ESLint config and enforce it across your team 👀 Still seeing var in your codebase? Drop a 😅 — you’re definitely not alone ♻️ Repost this to save your team hours of debugging 👉 Follow Mohd Sharfuddin Khan for daily JavaScript tips that actually level up your coding #JavaScript #WebDevelopment #Frontend #CodingTips #CleanCode #Developers #ESLint #JSDaily #WebDevelopment #FrontendDeveloper #100DaysOfCode #CodeTips #LearnToCode #ProgrammingTips #TechCommunity #DevLife

🚀 Day 43 of My Full Stack Development Journey Today I stepped into one of the most important concepts in modern JavaScript — Asynchronous Programming ⚡ This wasn’t just about syntax… it was about understanding how JavaScript handles real-world operations behind the scenes. Here’s what I explored today: 🔹 Promises – Writing cleaner async code 🔹 then() & catch() – Handling success & errors 🔹 Promise Chaining – Avoiding messy nested code 🔹 Refactoring Old Code – Converting callbacks → promises 🔹 Async Functions & await – Writing async code like synchronous 🔹 Handling Rejections – Managing errors properly 💡 One big takeaway: Moving from Callback Hell → Promises → Async/Await makes code more readable and maintainable. Practiced multiple questions to strengthen my understanding 💻 This felt like a real shift from beginner to intermediate JavaScript 🚀 #FullStackJourney #WebDevelopment #JavaScript #AsyncJavaScript #LearningInPublic #100DaysOfCode #CodingJourney

Linting is good. But real code quality goes beyond ESLint. In production-grade React apps, I use tools like SonarQube and Code Climate to catch deeper issues early — even before code reaches CI. What these tools add: • code smells detection • duplication analysis • complexity tracking • security vulnerability checks • maintainability scoring Local setup approach: Run SonarQube locally using Docker Connect your React project using sonar-scanner Analyze code before pushing Example flow: Write code → run local scan → fix issues → commit clean code Why this matters: • catch issues before PR review • maintain long-term code health • reduce tech debt accumulation • enforce consistent quality standards ESLint checks syntax. Sonar checks architecture. Both together make your codebase much stronger. #reactjs #javascript #frontenddevelopment #sonarqube #codequality #clean code #softwareengineering #webdevelopment #techdebt #codingstandards #devtools #modernjavascript #reactdeveloper

Just wrapped up learning the fundamentals of TypeScript, and honestly—it’s changed how I think about writing JavaScript 🚀 At first, it felt like extra work 🤯 Adding types, fixing errors I didn’t “need” to fix… but once it clicked, it started saving me time instead of costing it. Here’s what stood out for me: Fewer bugs 🐛❌ → catching mistakes while coding instead of at runtime Better readability 📖 → my code explains itself more clearly Stronger confidence 💪 → refactoring doesn’t feel risky anymore Improved developer experience ⚡ → autocomplete + type hints are a game changer TypeScript doesn’t just make code “safer”—it makes you more intentional as a developer 🧠 Still learning, still building, but definitely glad I added this to my toolkit 🔧 #TypeScript #JavaScript #WebDevelopment #LearningInPublic #DeveloperJourney

A typical React + TypeScript project linting setup looks something like this: - eslint - @typescript-eslint/parser - @typescript-eslint/eslint-plugin - eslint-plugin-react - eslint-plugin-react-hooks - prettier - eslint-config-prettier That is 7 packages before you have written a single line of application code. And that is before you start fighting the config to make ESLint and Prettier not conflict with each other. I have set up this exact combination more times than I would like to admit. Every time it works, but it never feels like it should be this complicated. I recently came across Biome (https://biomejs.dev/). It is a linter and formatter in one tool, written in Rust. Here is what caught my attention: - TypeScript support is built in, no extra packages needed - Linting and formatting in one tool, one config file, no conflicts - Can lint only staged files with --staged flag built in, no need for additional tools - Reported to be significantly faster than ESLint and Prettier combined - Already supports a large portion of common ESLint rules out of the box The entire setup is one package: @biomejs/biome I am planning to use it on my next project. The reduction in setup complexity alone makes it worth trying. Have you already migrated to Biome? I would love to hear about your experiences, especially any gotchas to watch out for.

Here's an unpopular take that'll probably get me blocked by half the frontend community: TypeScript was JavaScript's biggest mistake. I've been building systems for 15 years. Seen teams at enterprise scale struggle with this. Here's what actually happens: • Developers spend 40% more time on type definitions than business logic • Complex generics for simple object operations • Config hell: tsconfig, eslint, webpack interdependencies • Junior developers get stuck on type gymnastics instead of learning programming fundamentals • Runtime bugs still happen because types disappear JavaScript's flexibility was a feature, not a bug. Dynamic typing lets you prototype fast, iterate quickly, and solve problems creatively. TypeScript promised safety but delivered complexity. We added a compile step to a runtime language and convinced ourselves it was progress. Don't get me wrong - types have their place. But JavaScript with good testing, clear naming, and proper validation catches the same bugs with less overhead. Sometimes the simple solution is the right solution. #viral #trending #trend #typescript #javascript #webdev #programming #developer #coding #frontend #backend #softwareengineering #tech #unpopularopinion #hotteake #development #programminglife #techopinions

Work in progress 💻 Deep in the code today, building out new functionality for Scrimba Advance JavaScript. Sometimes the best commits are the ones that say "promise" twice because that's exactly what clean, asynchronous code delivers. Those small, focused commits? That's where the real progress happens. 𝖶𝖺𝗇𝗍 𝗍𝗈 𝗅𝖾𝖺𝗋𝗇 coding click 𝗁𝖾𝗋𝖾 👉🏽 : https://shorturl.at/cESup #WebDevelopment #JavaScript #Coding

Why We Migrated 6,000+ TypeScript Files from ESLint to oxlint Sharing my work and thoughts on the code quality in the age of AI assist coding as well as Rust based JS toolings. My first contribution to the oxc project. https://lnkd.in/eccazNqF #rust #jstooling #javascript #typescript #reactjs #oxlint #voidzero

🚀 How JavaScript Runs Your Code (Super Simple) Ever wondered what happens behind the scenes when you run JavaScript? 🤔 Let’s break it down step by step 👇 🧠 Step 1: Read 👉 JavaScript reads your code line by line 🔍 Step 2: Break 👉 Code is broken into small pieces (tokens) 🌳 Step 3: Understand (AST) 👉 JavaScript creates a structure (AST) of your code ⚡ Step 4: Convert (JIT) 👉 Code is converted into machine code during execution ▶️ Step 5: Execute 👉 JavaScript runs the compiled code 💡 Easy Flow: 👉 Read → Break → Understand → Convert → Execute 🔥 One line to remember: 👉 “JavaScript understands and runs your code at the same time” 💬 Which step was new for you? 📌 Save this for interviews (very important concept) #javascript #webdevelopment #frontend #coding #programming #javascriptdeveloper #learncoding #developers #100DaysOfCode