Aamir Muhammad Amin’s Post

#Stream is simply a sequence of data that is read or written over time, rather than all at once. #Node.js provides 4 main types of streams: #Readable → for reading data (e.g., fs.createReadStream()) #Writable → for writing data (e.g., fs.createWriteStream()) #Duplex → both readable and writable (e.g., sockets) #Transform → modifies data as it passes through (e.g., zlib, compression) 💡 Why Streams & Pipes Matter ⚡ Performance: Process large data without blocking the event loop. 💾 Memory efficiency: Only small chunks are in memory at a time. 🔗 Composability: Chain multiple operations elegantly. 🧩 Built-in support: Many Node.js core modules (HTTP, FS, etc.) use streams. #NodeJS #BackendDevelopment #JavaScript #WebDevelopment #Streams #Performance #CodingTips #100DaysOfCode

Today I ran into a problem while building the profile picture upload feature in my auth-service. 😭 The issue: The API Gateway uses express.json() for all routes (/auth, /post, etc.). That works fine for normal JSON requests, but when uploading a file, express.json() tries to parse the multipart request. It works the first time, but on subsequent uploads, it breaks and throws a 500 proxy error. My solution: Instead of rewriting the whole gateway or switching libraries, I just skipped express.json() for routes that handle file uploads. For all other routes, JSON parsing still works normally. // Routes to skip JSON parsing (file uploads) const skipJsonRoutes = ['/auth/upload', '/post/upload']; app.use((req, res, next) => { if (skipJsonRoutes.some(route => req.originalUrl.startsWith(route))) { return next(); // skip JSON parsing for these routes } express.json()(req, res, next); // parse JSON for all other routes }); In simple terms: File upload routes → skip JSON parsing. All other routes → parse JSON normally. It’s a small change but solved the issue perfectly, without having to rebuild the gateway from scratch.🔥 #NodeJS #ExpressJS #APIGateway #FileUpload #WebDev #JavaScript #CodingTips #DevHack #BackendDevelopment #ProgrammingLife #MultipartHandling #CodeOptimization #TechTips #DeveloperLife #FullStackDev

Day 2/365 — Pointers over proximity: understanding non-contiguous memory. 𝗪𝗵𝗮𝘁 𝗜 𝗹𝗲𝗮𝗿𝗻𝗲𝗱 𝘁𝗼𝗱𝗮𝘆 𝗟𝗶𝗻𝗸𝗲𝗱 𝗟𝗶𝘀𝘁 𝗽𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲: Insert at head = O(1), search = O(n), no reallocation needed. Nodes scatter in memory — only pointers connect them. 𝗩𝗮𝗿𝗶𝗮𝘁𝗶𝗼𝗻𝘀 𝗺𝗮𝘁𝘁𝗲𝗿: Doubly linked (prev + next) for bidirectional traversal, circular for round-robin scheduling, skip lists for O(log n) search. 𝗧𝘆𝗽𝗲𝗦𝗰𝗿𝗶𝗽𝘁 𝗿𝗲𝗮𝗹𝗶𝘁𝘆: === beats ==, ?? beats || for falsy-safe defaults, ?. prevents null explosions, type unions (|) allow flexible contracts without any escape hatches. 𝗖𝗹𝗮𝘀𝘀 𝘀𝘆𝗻𝘁𝗮𝘅: public in constructor params auto-creates properties — eliminates boilerplate, inheritance with extends + super(). 𝗪𝗵𝗮𝘁 𝗜 𝗯𝘂𝗶𝗹𝘁 Full LinkedList implementation with addFirst/addLast/addBefore/addAfter/remove/contains. Type-safe with generics and proper null handling. 𝗕𝗶𝗴𝗴𝗲𝘀𝘁 𝗶𝗻𝘀𝗶𝗴𝗵𝘁 Linked lists sacrifice random access for structural flexibility. TypeScript sacrifices runtime flexibility for compile-time safety. Both trades worth making when the access pattern or team size justifies the cost. #datastructures #typeScript #javascript #nodeJS #linkedlists #DSA #learninginpublic #100daysofcode #softwareengineering #nextjs #tailwindCSS #webdevelopment #softwarearchitecture #codequality #reactJS #frontenddevelopment #webapp #developerproductivity #cleancode #techbestpractices

🚀 Solve and optimize to O(n) — #LeetCode17: Contains Duplicate [EASY] ❓Given an integer array nums, return true if any value appears at least twice in the array, and return false if every element is distinct. 🔹 Example 1:  Input: nums = [1,2,3,1] Output: true Explanation: The element 1 occurs at the indices 0 and 3. 🔹 Example 2: Input: nums = [1,2,3,4] Output: false Explanation: All elements are distinct. #️⃣ Hashtags: #LeetCode #JavaScript #Algorithm #WebDevelopment #FullStackDevelopment #FrontEndDeveloper #BackEndDeveloper

🚀 JavaScript Tip — The Mysterious y (Sticky) Flag in RegExp! Most developers know about the /g flag for global matching — but few know about the /y flag, also known as the “sticky flag” 🤔 Here’s what it does 👇 const str = "Hello123World"; const regex = /\d+/y; // sticky flag regex.lastIndex = 5; // start matching from index 5 console.log(regex.exec(str)); // ["123"] 🔍 The /y flag tells the regex engine: > “Match only if the pattern starts exactly at lastIndex.” If it doesn’t — the match fails! Compare that with /g, which skips ahead to find the next match: const regexG = /\d+/g; regexG.lastIndex = 5; console.log(regexG.exec(str)); // ["123"] ✅ (finds later) 🧠 Key Difference: /g → global, scans ahead for next possible match /y → sticky, matches only from lastIndex Perfect for tokenization, custom parsers, and controlled regex scanning. 💡 Remember: /y gives you precise control over regex matching — no skipping allowed! #JavaScript #Regex #WebDevelopment #CodingTips #Frontend #100DaysOfCode

🌟 Day 19: Node.js Promises — Goodbye Callback Hell! 🌟 Callbacks were great… until they turned into callback hell 😵 That’s where Promises come in ✨ 🔹 What is a Promise? A Promise represents a value that may be: • ✅ Resolved (success) • ❌ Rejected (error) • ⏳ Pending (still running) 🔹 Example: File Read with Promises const fs = require("fs").promises; fs.readFile("demo.txt", "utf8") .then(data => { console.log("File Content:", data); }) .catch(err => { console.error("Error:", err); }); 🔹 Cleaner Chaining Instead of nesting callbacks ⛓️, you can chain promises: doA() .then(doB) .then(doC) .then(doD) .catch(err => console.error("Error:", err)); ✅ Promises = More readable async code ✅ Handle errors in one place (.catch) ✅ Foundation for async/await 💡 Pro Tip: Always end your chain with .catch() to avoid unhandled errors. 👉 With Promises, async code looks like a straight line, not a pyramid of doom ⛰️ #Nodejs #Promises #AsyncProgramming #JavaScript #BackendDevelopment #FullStackDeveloper #cfbr

ReScript 2025 — The Top JavaScript Alternative (Tech Deep Dive) TL;DR — ReScript gives you a sound nominal type system, lightning‑fast compiles (native OCaml backend), ergonomic ADTs + pattern matching, data‑first stdlib with pipes, and first‑class React support — without opting out of the JS ecosystem. If TypeScript is “JS with types”, ReScript is “types with JS interop”. in the JS ecosystem? Because large apps need: Type soundness: if it compiles, it won’t throw type errors at runtime. Predictable data: immutability by default; Record, Tuple, Variant. Expressive logic: pattern matching over ADTs; Option/Result ergonomics. Speed: native compiler; blazing feedback loop even at 50k+ files. Interop: consume NPM, emit human‑readable JS, bind to any library. TypeScript’s structural typing allows refutable assignments that can later crash. ReScript’s nominal types avoid this entire class. // TypeScript — compiles, may crash at runtime type T = { x: number } type U = { x: number | string } const a: T = { x: 3 } const b: U = a // ✅ compiles b.x = https://lnkd.in/gZi9xrip

ReScript 2025 — The Top JavaScript Alternative (Tech Deep Dive) TL;DR — ReScript gives you a sound nominal type system, lightning‑fast compiles (native OCaml backend), ergonomic ADTs + pattern matching, data‑first stdlib with pipes, and first‑class React support — without opting out of the JS ecosystem. If TypeScript is “JS with types”, ReScript is “types with JS interop”. in the JS ecosystem? Because large apps need: Type soundness: if it compiles, it won’t throw type errors at runtime. Predictable data: immutability by default; Record, Tuple, Variant. Expressive logic: pattern matching over ADTs; Option/Result ergonomics. Speed: native compiler; blazing feedback loop even at 50k+ files. Interop: consume NPM, emit human‑readable JS, bind to any library. TypeScript’s structural typing allows refutable assignments that can later crash. ReScript’s nominal types avoid this entire class. // TypeScript — compiles, may crash at runtime type T = { x: number } type U = { x: number | string } const a: T = { x: 3 } const b: U = a // ✅ compiles b.x = https://lnkd.in/gZi9xrip

In TypeScript, 'as const' might look like a tiny keyword, but it’s incredibly powerful once you understand what it does. By default, TypeScript tries to be flexible - - Strings, numbers, and booleans are widened to their general type ("apple" -> string, 42 ->number). - Arrays are treated as general arrays (number[]). - Objects have properties typed generally (role: "admin" -> string). This flexibility is called type 'widening.' TypeScript assumes you might want to reassign these values later. But what if you want the most specific, literal type, and you also want your object or array to be 'readonly' at the type level? That’s where 'as const' comes in. When we use 'as const', the values are narrowed to their literal types, arrays become 'readonly,' and Objects have all the properties marked as 'readonly'. But why is this useful? It is useful for things like - - Configuration objects: values can’t be reassigned accidentally. - Readonly tuples - avoids unintended array mutation. - Enums alternative - teams often use 'as const' objects instead of enums. Now, you need to still keep in mind that 'as const' is a compile-time only TypeScript feature. It doesn’t make the object immutable at runtime. If you also need runtime immutability, you can use something like 'Object.freeze.' The bottom-line is that this small keyword can prevent subtle bugs, make your types safer, and improve code reliability. #TypeScript #JavaScript #Coding #Programming #WebDevelopment #Development