Mastering Fetch API in JavaScript

Day 13 of Learning JavaScript 💻 Today I practiced accessing and modifying object properties. Example: user.name = "New Name" This is useful when working with dynamic data. Feels good to understand how real apps update data. #javascript #frontenddeveloper

ICYMI: By processing millions of CSV rows directly in the browser, this tutorial shows how WebAssembly outpaces JavaScript when the data gets big. By Jessica Wachtel

I just published my first npm package called Arc. It is a web framework for Node.js that I built from the ground up using TypeScript. Instead of just using Express, I wanted to see if I could build the whole engine myself using only the native http module and zero external dependencies. I spent a lot of time on the core logic writing a router that uses regex to handle dynamic paths like /user/:id and setting up a recursive next function so middlewares run in the right order. Since I wanted it to be a complete tool, I also built my own custom parsers for JSON, URL encoded data, and cookies. It also has built in logic for JWT auth, CORS, rate limiting, and a static file server. Building this taught me way more about how a backend actually handles data flow than just using a pre made library ever did. I am still adding to it. My next plans are to include request validation, dependency injection, and cluster support to make it even faster. If you are into low level Node.js or want to help build out the engine, you are more than welcome to contribute. If you want to see how the guts of a framework actually work, check out the code or try it out: NPM: https://lnkd.in/dPkTEjYZ GitHub: https://lnkd.in/dfmwM_Cb #NodeJS #TypeScript #OpenSource #Backend #Coding

Day 10/100 of JavaScript 🚀 Today’s topic : Fetch API "fetch" is used to make HTTP requests in JavaScript and is a modern replacement for XMLHttpRequest Basic usage : fetch("https://lnkd.in/gCA7VyNQ") .then(res => res.json()) .then(data => console.log(data)) .catch(err => console.error(err)); Using async/await : async function getData() { try { const res = await fetch("https://lnkd.in/gCA7VyNQ"); const data = await res.json(); console.log(data); } catch (err) { console.error(err); } } What it does : - Returns a Promise - Cleaner than XMLHttpRequest - Works well with async/await #Day10 #JavaScript #100DaysOfCode

Updating libraries without knowing their breaking changes 🔧 - Part 2 Symptom: Deleted `dist` → build succeeded → `dist` empty → no `main.js` What I deleted: - ✅ `dist` - ✅ `node_modules`   - ✅ `package-lock.json` What I missed: - ❌ `tsconfig.tsbuildinfo` - ❌ `tsconfig.build.tsbuildinfo` Why it broke me: TypeScript incremental cache told `tsc`: *"Already built. Nothing to do."*   So it skipped emitting JS files. The fix: ```json "scripts": {   "clean": "rm -rf dist *.tsbuildinfo",   "build": "npm run clean && nest build" } ``` The rule: Delete `dist`? Delete `*.tsbuildinfo` too. One-liner for your next cleanup: ```bash rm -rf dist node_modules package-lock.json *.tsbuildinfo ``` My wrong assumption: Thought `dist` was the only output. Didn't know TypeScript keeps a separate cache file that survives `dist` deletion. #NestJS #TypeScript #DevOops #LessonsLearned

Following the Masterji TypeScript Challenge, today I learned about union types and the any type. Yesterday, I randomly came across a short by Hitesh Sir Hitesh Choudhary where he mentioned that learning in public is not enough if you're not building something out of it. That really stuck with me. So today, I tried a different approach. Instead of just learning, I built a small project — an API Response Viewer that handles loading, success, and error states using union types, and also explores how any works with real-world data. Live: https://lnkd.in/ezmcbVtx Code: https://lnkd.in/e2CDqwZM Small shift, but it made the learning much more real. #typescript #learninginpublic #webdevelopment #javascript #buildinpublic #chaicode

📣 𝗡𝗲𝘅𝘁 𝗕𝗹𝗼𝗴 𝗶𝘀 𝗛𝗲𝗿𝗲! ⤵️ JavaScript Arrays 101 — Finally Managing Lists Like a Real Program 🧠📋 Storing values in separate variables works… until you need to handle real-world data. This beginner-friendly blog explains arrays in a simple, practical way — so you can start working with lists confidently. 🔗 𝗥𝗲𝗮𝗱 𝗵𝗲𝗿𝗲: https://lnkd.in/g2CXGSPW 𝗧𝗼𝗽𝗶𝗰𝘀 𝗰𝗼𝘃𝗲𝗿𝗲𝗱 ✍🏻: ⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺ ⇢ What arrays actually are (simple list mental model) ⇢ Why arrays are needed in real programs ⇢ Creating arrays using square brackets ⇢ Indexing and why arrays start at 0 ⇢ Accessing and updating array elements ⇢ Using the length property ⇢ Looping with for and for...of ⇢ Arrays vs individual variables confusion cleared ⇢ Common beginner mistakes (off-by-one errors, dot notation, etc.) 💬 If JavaScript still feels limited to single values, this article helps you understand how arrays unlock real data handling and scalable logic. #ChaiAurCode #JavaScript #Arrays #ProgrammingBasics #WebDevelopment #Beginners #LearningInPublic #100DaysOfCoding

🚀 Day 16 of #100DaysOfCode Today I started the JavaScript section from The Odin Project. 💡 Focus: Variables & Operators At first, it looks simple… but I realized something powerful: 👉 Variables are like “containers of logic” — they store the state of your program 👉 Operators are the “decision makers” — they control how data transforms ⚡ Key things I explored: • let vs const (when to use what) • Primitive data types • Arithmetic & comparison operators • Writing clean and predictable expressions 🧠 Realization: Even the most advanced applications depend on these basics. If I master this deeply, I can build anything. GitHub repo : https://lnkd.in/g6BsNMZw 🎯 Goal: Not just to learn JavaScript… but to think like a developer. Consistency > Motivation #JavaScript #WebDevelopment #CodingJourney #TheOdinProject #100DaysOfCode

🎥 **New Video: HTTP Parser in Node.js — Technical Deep-Dive** I just published a deep dive I did with Paolo Insogna (Platformatic) and Artem Zakharchenko (creator of Mock Service Worker/MSW) on how HTTP parsing actually works in Node.js. Artem was researching socket-level interception for MSW v3 and ended up going down a rabbit hole that led to this conversation. Fair warning: the answers don't get simpler the deeper you go. **What we covered:** 🔹 The original `http-parser` C library — "totally unmaintainable" according to Paolo. Any change = recompile. Rigid, static, impossible to configure. 🔹 The migration to llhttp — a state-machine-based, generated parser that's configurable and 2x faster (1.5M → 3M req/s). 🔹 The l build pipeline: TypeScript → llparse (code generator) → C code → compiled binary. Tests in Markdown. 🔹 Parser pools — Node.js pre-allocates 1000 parsers and keeps them in a free list instead of GC-ing them. Why? Minimizing C++ ↔ JavaScript boundary crossing. Is it still needed with modern GC? *"I have no real hard data on that."* 🔹 Why Undici migrated from Node.js bindings to llhttp as WebAssembly — WASM boundary crossing is faster, and it's portable across runtimes. 🔹 Why you should NEVER use `process.binding('http_parser')` — no TypeScript types, no public API, changes without notice. Just use Undici. 🔹 And yes, we explain why internal symbols have a `k` prefix (Hungarian Notation, Windows API 90s, nobody knows why it stuck, it just did). Watch the full video 👇 👉 https://lnkd.in/gk7AMNYU I love doing this video, it's the kind of deep dive. Hopefully, it would make you appreciate just how much work goes into making `fetch()` feel effortless. What do you want us to cover next?

🚀 Day 31 of My Full Stack Development Journey Today I explored one of the most important concepts in JavaScript — Arrays 📦 Here’s what I learned today: 🔹 Arrays (Data Structure) – Storing multiple values in a single variable 🔹 Visualizing Arrays – Understanding how data is organized 🔹 Creating Arrays – Different ways to define arrays 🔹 Arrays are Mutable – Learning how arrays can be modified 🔹 Array Methods – Working with built-in functions 🔹 indexOf() & includes() – Searching within arrays 🔹 Concatenation & reverse() – Combining and reversing arrays 🔹 Practiced several questions to strengthen my understanding 💻 It’s exciting to see how arrays make handling data much easier and more powerful. Step by step, getting closer to building real-world applications 🚀 #FullStackJourney #WebDevelopment #JavaScript #LearningInPublic #100DaysOfCode #CodingJourney