TypeScript's 'any' and strict mode explained

📌 Something I learned recently TypeScript isn’t about writing more code. It’s about writing code with more confidence. I used to think adding types was just extra work that slowed me down. But over time, I realized it actually does the opposite. ✨ It catches mistakes early ✨ It makes refactoring less intimidating ✨ And it helps future-me (and teammates) understand decisions faster The biggest lesson? You don’t have to go all-in from day one. Even adding types gradually changes how you think about your code and that mindset shift is where the real value is. #TypeScript #JavaScript #DeveloperLife #SoftwareDevelopment

“Does TypeScript only add types to my code?” That was my first thought too. And the short answer is No. The honest answer is TypeScript changes the way you think about code. ❌ The common myth “TypeScript is just JavaScript with types” If that was true, people would not insist on using it. ✅ What actually changes 🧠 You start thinking in contracts, not guesses Functions become clear about what they accept and what they return. 🧩 Your code becomes living documentation Anyone can understand it without asking or reading outdated comments. 🔍 Refactoring feels safer The compiler points out problems before they become bugs. ⚠️ Errors show up early In your editor, not in production. 🚀 The real value TypeScript is not only about avoiding bugs. It is about confidence. Confidence to change things. Confidence to scale code. Confidence to work with larger teams. 🎯 My takeaway If TypeScript feels like “just extra typing”, you probably have not refactored a large project without it yet. 👉 What about you Is TypeScript optional, mandatory, or still “it depends”? #TypeScript #JavaScript #SoftwareEngineering #CleanCode #Frontend #Backend #NodeJS #React #DevLife

Day 78 of #100DaysOfLinkedIn — Function Overloads in TypeScript Today I learned how function overloads work in TypeScript and why they’re important for writing type-safe and flexible APIs. Function overloads allow us to define multiple function signatures for the same function, while keeping a single implementation. What I learned today: • What function overloads are and why they’re used • Writing multiple call signatures for one function • How TypeScript selects the correct overload • Difference between overload signatures & implementation • Making functions safer without using any This is very useful when building utility functions, libraries, and reusable APIs. #TypeScript #JavaScript #WebDevelopment #FrontendDevelopment #MERNStack #100DaysOfLinkedIn #100DaysOfCode #CodingJourney

I just published Part 1 of a new series: TypeScript From the Ground Up This series is not about shortcuts, hype, or framework-driven tutorials. It’s about understanding TypeScript from first principles so your code is: ▫️ safer ▫️ easier to reason about ▫️ easier to maintain Part 1 covers the basics the right way: Types, Functions, Objects, Async behavior. If you already know JavaScript, TypeScript is not a rewrite. It’s an upgrade! Read here 👉 https://lnkd.in/eZK2uwBQ More parts coming soon. #TypeScript #JavaScript #FrontendDevelopment #WebDevelopment #SoftwareEngineering #CleanCode #DeveloperEducation #SeniorDev

Day 73 of #100DaysOfLinkedIn — Primitive Types & Special Types in TypeScript Today I explored primitive types and some special types that make TypeScript powerful and safe when used correctly. Understanding these types helps avoid unexpected bugs and improves code reliability. What I learned today: • Primitive types: string, number, boolean, null, undefined • Why any should be avoided in real projects • How unknown is safer than any • When never is used in functions • Difference between null and undefined These concepts are essential for writing type-safe and scalable TypeScript code. #TypeScript #JavaScript #WebDevelopment #FrontendDevelopment #MERNStack #100DaysOfLinkedIn #CodingJourney

JavaScript lets you fly. TypeScript makes sure you don’t crash. ✈️💥 I used to think adding types was just extra work that slowed me down. But after a few large-scale projects, I realized it actually does the opposite.

Day 72 of #100DaysOfLinkedIn — Variables, Type Annotations & Type Inference in TypeScript Today I learned how TypeScript handles variables and how it understands types using annotations and inference. This topic is the foundation of everything in TypeScript — if this is clear, the rest becomes much easier. What I learned today: • How to declare variables with explicit types • Difference between type annotation and type inference • When to let TypeScript infer types automatically • Why avoiding any is important • How TypeScript prevents invalid reassignments Understanding this helps write clean, safe, and predictable code. #TypeScript #JavaScript #WebDevelopment #FrontendDevelopment #MERNStack #100DaysOfLinkedIn #CodingJourney

There was a time when JavaScript flexibility felt like freedom. Until projects grew. Teams changed. Assumptions aged. TypeScript didn’t become relevant because it’s fashionable. It became necessary when code stopped being written for ourselves and started being maintained by others. Most bugs are not logic errors. They are misunderstandings. Types don’t eliminate mistakes. They expose them earlier — and cheaper. In long-lived systems, clarity outperforms cleverness. That’s where TypeScript quietly earns its place. #TypeScript #SoftwareEngineering #LongLivedSystems #CodeQuality #DeveloperMindset #TechCareers

Let’s talk TypeScript 💙 What it means: TypeScript is a superset of JavaScript. That means any valid JavaScript code is also valid TypeScript with extra features on top. What it does: • Adds types to variables and functions • Helps detect errors before your code runs • Makes code easier to read and maintain • Improves developer experience with better autocomplete and tooling In simple terms: TypeScript helps you write safer, more predictable JavaScript, especially as projects grow. Day 01: Understanding what TypeScript is and what it does before writing too much code. #TypeScript #LearningInPublic #SoftwareEngineering #WomenInTech #DevJourney

🛑 Still using Enums in TypeScript in 2026? Enums look convenient, but they quietly add real JavaScript code to your bundle. That means extra runtime weight, weaker tree shaking, and edge cases with numeric enums that can surprise you in production. This is why many senior TypeScript teams are moving away from them. A better pattern - Use const objects with as const, then derive union types from them. Why this approach wins ✅ No runtime cost after transpilation ✅ Predictable behavior at runtime ✅ Stronger type safety with clearer intent ✅ Better editor autocomplete and refactoring support TypeScript shines when types disappear at runtime. If a feature leaks into JavaScript, question whether you really need it. Modern codebases favor clarity, safety, and zero cost abstractions. 🚀 #TypeScript #JavaScript #WebDev #CleanCode #Frontend #SoftwareEngineering #PerformanceOptimization