Egor Kryzhanouski’s Post

Honest opinion: I resisted TypeScript for longer than I should have. “It’s just extra syntax.” “It slows me down.” “JavaScript is fine.” I was wrong. Here’s what changed my mind - working on a large banking application with 10+ developers. Without TypeScript: ∙ Props getting passed incorrectly across components ∙ API response shapes being assumed, not enforced ∙ Bugs that only showed up in production With TypeScript: ∙ Errors caught before the code even runs ∙ Components become self-documenting ∙ Refactoring feels safe instead of scary The “slowdown” in writing types saves 10x the time in debugging. If you’re still on the fence about TypeScript — just try it on one project. That’s all it takes. What made you finally switch to TypeScript? 👇 #TypeScript #ReactJS #Frontend #WebDevelopment #JavaScript

𝗟𝗲𝘁’𝘀 𝘁𝗮𝗹𝗸 𝗮 𝗹𝗶𝘁𝘁𝗹𝗲 𝗯𝗶𝘁 𝗮𝗯𝗼𝘂𝘁 𝗡𝗼𝗱𝗲.𝗷𝘀! 𝐓𝐨𝐩𝐢𝐜 𝟏: 𝐓𝐡𝐞 𝐍𝐨𝐝𝐞.𝐣𝐬 𝐄𝐯𝐞𝐧𝐭 𝐋𝐨𝐨𝐩 It’s a meticulously ordered cycle of 6 steps - and most developers have never seen the part that goes between each one. ⚙️ 𝘛𝘩𝘦 6 𝘚𝘵𝘦𝘱𝘴: 1️⃣ 𝘛𝘪𝘮𝘦𝘳𝘴: Recalls setTimeout / setInterval whose delay has passed 2️⃣ 𝘈𝘸𝘢𝘪𝘵𝘪𝘯𝘨 callbacks: Recalls I/O errors that were rejected from the previous iteration 3️⃣ 𝘗𝘰𝘭𝘭𝘪𝘯𝘨: Retrieves new I/O events. This is where Node.js waits when idle. 4️⃣ 𝘊𝘩𝘦𝘤𝘬: setImmediate callbacks, always after Poll 5️⃣ 𝘊𝘭𝘰𝘴𝘦 𝘊𝘢𝘭𝘭𝘣𝘢𝘤𝘬𝘴: socket.on('close'), cleanup handlers 💠The hidden layer: microtasks Between each step, before the loop progresses, Node.js completely empties the microtask queue. Two subqueues, processed in exact order: ➡️ process.nextTick() callbacks - always first ➡️ Promise resolution callbacks - second This means that microtasks have a higher priority than any step of the Event Loop. 📌 𝘛𝘩𝘦 𝘳𝘶𝘭𝘦𝘴 𝘰𝘧 𝘵𝘩𝘶𝘮𝘣: ➡️ process.nextTick() is fired before Promises, even if Promise resolved first. ➡️ setImmediate() is always fired after I/O callbacks in the same iteration. ➡️ The order of setTimeout(fn, 0) and setImmediate() is not deterministic outside of I/O callbacks. ➡️ Never use nextTick() recursively in production code. The event loop is why Node.js can handle thousands of simultaneous connections on a single thread. Controlling its execution order is the difference between writing asynchronous code and understanding it. #nodejs #javascript #backend #eventloop #softwareengineering #webdevelopment

TypeScript won't save you from writing bad code. But it will make sure you can't hide it. I've seen teams migrate from JS to TS thinking it'll magically clean up their codebase. It doesn't. What it does — ruthlessly — is surface the mess that was already there. ────────────────────────────────── JS — no complaints: function getUser(id) {  return db.find(id); } // Silently returns undefined. Good luck. TS — caught immediately: function getUser(id: string): User | null {  return db.find(id); } // Handle null. Now. ────────────────────────────────── That function existed for months in production. TS didn't write the bug — but it made us face it on day one of migration. Mistakes I see every week: → Using `any` everywhere — you just turned off TypeScript → Casting with `as` to silence errors instead of fixing the type → No return types — so the compiler can't catch what you promised vs what you shipped → Treating TS as "JS with syntax" and skipping strict mode entirely What actually helps: → Turn on strict: true from day one — not after migration → Type your boundaries: API responses, function params, return values → Read the errors. TS is telling you something, not punishing you → Use `unknown` instead of `any` when you're unsure — it forces you to handle it ────────────────────────────────── TypeScript is a mirror, not a magic wand. The teams that get the most out of it are the ones who stop fighting the errors — and start listening to them. Be honest: when you migrated to TS, how many skeletons did it drag out of your closet? #TypeScript #JavaScript #WebDevelopment #SoftwareEngineering #CleanCode #FrontendDevelopment #NodeJS #DevLife #ProgrammingTips #CodeQuality

𝐒𝐰𝐢𝐭𝐜𝐡𝐞𝐝 𝐭𝐨 𝐓𝐲𝐩𝐞𝐒𝐜𝐫𝐢𝐩𝐭. 𝐏𝐫𝐨𝐝𝐮𝐜𝐭𝐢𝐨𝐧 𝐁𝐮𝐠𝐬 𝐃𝐫𝐨𝐩𝐩𝐞𝐝 𝟕𝟎%. 🎯 My Express API was in JavaScript. "Types are just extra work," I thought. 𝐓𝐡𝐞 𝐈𝐦𝐩𝐚𝐜𝐭: Before TypeScript: - 10-15 production bugs per month - Most were type-related errors - "undefined is not a function" 😤 After TypeScript: - 1-2 production bugs per month - Caught 70% of bugs at compile time - No more "cannot read property of undefined" 𝐖𝐡𝐚𝐭 𝐓𝐲𝐩𝐞𝐒𝐜𝐫𝐢𝐩𝐭 𝐂𝐚𝐮𝐠𝐡𝐭: ✅ Wrong function parameters ✅ Typos in property names ✅ Missing required fields ✅ Wrong return types ✅ Null/undefined handling All BEFORE code reached production. 𝐓𝐡𝐞 𝐁𝐨𝐧𝐮𝐬: Better autocomplete in VS Code Refactoring became safe (rename all references) New team members onboard faster (types = documentation) 𝐖𝐡𝐚𝐭 𝐈 𝐋𝐞𝐚𝐫𝐧𝐞𝐝: "Extra work" in development = Less work in production 5 minutes adding types > 2 hours debugging at 2 AM TypeScript isn't about being fancy. It's about shipping code that works. 𝐓𝐡𝐞 𝐭𝐫𝐚𝐝𝐞-𝐨𝐟𝐟: Initial setup: 1 day (adding types to existing Express app) Time saved: Countless hours of debugging Worth it? Absolutely. 𝐓𝐡𝐞 𝐭𝐚𝐤𝐞𝐚𝐰𝐚𝐲: JavaScript: Fast to write, slow to debug TypeScript: Slower to write, fast to ship Production stability > Development speed Still writing Node/Express in vanilla JS? Give TypeScript a shot. Your future self will thank you. #TypeScript #JavaScript #NodeJS #Express #Backend #WebDev #TodayILearned #ProductionBugs #LessonsLearned #Coding

Callbacks made async code work… Promises made it readable. In Node.js, handling async operations with callbacks often leads to: ❌ Nested code ❌ Hard-to-debug logic ❌ Poor error handling This is what we call “callback hell”. Promises improve this by: ✔ Flattening async flow ✔ Making code more readable ✔ Handling errors in a structured way Using .then() and .catch(), we can write cleaner and more maintainable backend code. And with async/await — it gets even better. ❓ Quick FAQ 👉 What is a Promise? A value that may be available now, later, or never. 👉 Why are Promises better than callbacks? Cleaner code and better error handling. 👉 What is callback hell? Deeply nested callbacks that make code unreadable. 👉 What comes after Promises? Async/Await for even cleaner syntax. Good backend code isn’t just about working logic — it’s about writing maintainable and scalable systems. #NodeJS #JavaScript #BackendDeveloper #WebDevelopment

I used Claude the wrong way for a while. I kept one long thread open and kept asking for small changes. “Fix this TypeScript error.” “Now make it cleaner.” “Now convert it to React hooks.” “Now add loading state.” “Now make it production-ready.” The problem is simple. Every new message adds more context, and Claude has to process all of that again. So the thread grows, token usage grows, and the output often gets worse because the context becomes noisy. I wrote a blog about how to avoid that. https://lnkd.in/gXu8PK8x A few things that made the biggest difference for me: * start a fresh chat more often * give the full instruction in one go * summarise old context instead of dragging the whole thread * control output size when you only need code or a short answer Small prompt changes make a big difference when you use Claude every day for development work. #Claude #AI #JavaScript #TypeScript #React #NodeJS #PromptEngineering #SoftwareEngineering #WebDevelopment #Developers

Only 2% of developers use Full-stack TypeScript with tRPC for true end-to-end type safety. Have you ever wondered why, despite the evolution in tooling and frameworks, bugs still crawl into your codebase after every release? As a developer who's spent countless late nights debugging mysteriously broken interfaces, I’ve turned to Full-stack TypeScript with tRPC for a solution. Type safety isn't just a buzzword; it translates to real-world stability and confidence in code. TypeScript ensures your data contracts remain intact across your entire stack. But here's the kicker: tRPC elevates this synergy to a level where type errors become almost a non-issue. By generating API types directly from your server-side logic, every part of your application - backend to frontend - remains synchronized automatically. Imagine making a server-side change and your editor flagging exactly where you need to adjust your client logic. It's not just time-saving; it's transformative. I remember using vibe coding to quickly prototype features, and it was liberating to see real-time type validations catch potential runtime errors before they became problems. Here's a quick example of how simple it is to define a type-safe API with tRPC: ```typescript import { initTRPC } from '@trpc/server'; const t = initTRPC.create(); export const appRouter = t.router({ greeting: t.procedure .input((val: string) => val.trim()) .query(({ input }) => `Hello ${input}`), }); export type AppRouter = typeof appRouter; ``` This isn't just about using TypeScript; it's about leveraging its full potential to enhance our development workflow. What are your thoughts on adopting full-stack type safety? Are you already using something like tRPC, or is there another framework you find indispensable? Let’s dive into the discussion! #WebDevelopment #TypeScript #Frontend #JavaScript

🚀 Understanding Node.js Internals: Event Loop & Thread Pool This week, I took a deeper dive into how Node.js actually works behind the scenes — and it completely changed how I think about asynchronous code. 🔹 JavaScript in Node.js runs on a single thread 🔹 Yet it handles multiple tasks efficiently using the Event Loop 🔹 Heavy operations are offloaded to the Thread Pool (via libuv) Some key takeaways: Event Loop manages execution in phases (Timers, I/O, setImmediate, etc.) setTimeout(0) is not truly immediate setImmediate() behaves differently inside vs outside I/O process.nextTick() runs before the event loop even starts Understanding these concepts makes async behavior much more predictable and helps write better backend code. Would love to hear your thoughts or corrections 🙌! Blog Link : https://lnkd.in/gxBA4DeT #JavaScript #WebDev #LearnInPublic #Blog #libuv #EventLoop #ThreadPool #ChaiCode Thanks to Hitesh Choudhary, Piyush Garg, Jay Kadlag, Akash Kadlag for guidance 😊

You add TypeScript to the project. Half the types are any. You basically wrote JavaScript with some extra syntax. TypeScript doesn't make your code safer. You do. And using any turns off the whole tool. Here's what most people miss: any doesn't stay where you put it. It spreads. function getUser(id: string): any { return api.fetch("/users/" + id); } const user = getUser("123"); const name = user.name; const upper = name.toUpperCase(); Every variable in this chain is any. No autocomplete, no safe changes, no errors caught before release. One any at the start shuts down the whole process. This is type erosion. It acts like tech debt — hidden until it causes problems. Before you type any, ask yourself two questions. First question: Do I really not know the type? If the data comes from an API — describe its structure. A partial type is much better than any. Second question: Am I just avoiding a type error? The compiler warns you, and you ignore it. That's not a fix. It's just @ts-ignore with extra steps. Use unknown instead. It means "I don't know" but makes you check before using it. any trusts without question. unknown requires proof. If your code has more than 5% any, you're not really using TypeScript. You're just adding decorations to JavaScript. Run npx type-coverage. Look at the number. Then decide. any is not a type. It's a surrender. #TypeScript #Frontend #JavaScript #WebDev #SoftwareEngineering #CodeQuality

I spotted something worth thinking about in article #10. JavaScript async patterns trip up developers constantly—and the forEach/await problem is one of those gotchas that costs real time in production. Here's the thing: I've seen this exact issue in client code. Developer ships what looks correct, feels correct, then async operations run in parallel when they should be sequential. Debugging that mess takes hours. https://lnkd.in/g2Y9JF8u The fix is simple once you know it. Use a for loop instead. Or map with Promise.all if you actually want parallel execution. But most devs don't know why forEach breaks—they just know something's weird. This is one of those moments where understanding why matters more than just copying the fix. JavaScript's async model isn't broken. Most developers just don't spend time with it deeply enough to build intuition. If you're managing developers or you code yourself, this is worth 5 minutes of your day. Saves your team days later. Are you running into async surprises in production code, or is your team already solid on this one? #JavaScript #Development #CodeQuality