Mastering JavaScript Control Flow with If, Else, and Switch

Your variable names are lying to you.   const fetchWill = () => {}     ⚠ -will implies Promise. Function is not async. Sumerish fixes this. ───── Last week I posted about building a new language protocol. This week I shipped the tooling. 🔌 VS Code extension — syntax highlighting, hover tooltips, autocomplete, chain-order linting 📦 eslint-plugin-sumerish — enforces type contracts on your variable names in CI ───── The color system alone is worth installing for: Every suffix group gets a distinct color. Amber = tense. Red = negation. Blue = plural. Green = social. You scan a Sumerish chain and your eye groups the meaning before your brain reads the words. ───── But the part I'm most proud of: You don't need to learn Sumerish to read it.   Report-view-pl-q? You just understood that. "Could you please look at the report?" The roots stay English. The hyphens make the structure visible. The suffix chain is self-documenting. Learning curve: nearly zero. The only two suffixes you need to guess: -pl and -q. And even those are guessable. ───── Links in the comments — extension, npm, GitHub, demo. #vscode #eslint #typescript #javascript #buildinpublic #devtools #opensource

🚀 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

🚀 Day 5/100 — #100DaysOfCode Today was all about strengthening my JavaScript fundamentals 💻 Instead of rushing ahead, I took time to revise the core concepts that form the backbone of programming. 📚 What I revised: 🧠 Core Concepts • Variables & Declarations • Data Types & JavaScript Type System ⚡ Logic Building • Operators • Control Flow (if-else, conditions) 🔁 Iteration • Loops (for, while) ⚙️ Functions • Writing reusable and structured code 📦 Data Structures • Arrays — handling collections of data • Objects — organizing data in key-value form 💡 Key Insight: Strong fundamentals make complex problems easier to solve. 🔥 Day 5 complete. Staying consistent and building step by step. #JavaScript #WebDevelopment #CodingJourney #BuildInPublic #Consistency

LeetCode Day 10 : Problem 380 (Insert Delete GetRandom O(1)) Just solved my tenth LeetCode problem. It was "Insert Delete GetRandom O(1)", sounds like a basic Set problem, right? But here's what I actually learned: My first attempt used only a Map. Insert and remove worked fine, Map gives you O(1) for both. So I thought I was done. Then came getRandom(). I wrote Array.from(this.map.keys()) to pick a random element. It worked. Tests passed locally. But it was O(n), rebuilding an entire array from the map on every single call. The problem explicitly requires O(1) for all three operations. My solution was silently failing the constraint. I also had a crash hiding in insert. I wrote this.map.insert(val), but JavaScript's Map has no insert() method. The correct method is .set(). One wrong method name and the whole class throws a TypeError at runtime. The real fix wasn't patching getRandom(). It was rethinking the data structure entirely. The trick: maintain both a Map and an Array together. The Array holds the actual values so getRandom() is just a random index lookup, pure O(1). The Map stores each value's index in the array so insert and remove stay O(1) too. The hardest part? Remove. You can't just delete from the middle of an array in O(1). The solution: swap the target element with the last element, pop the end, then update the swapped element's index in the Map. No shifting, no gaps. Two bugs in one problem. One crashed the code, one passed tests but broke the core constraint. The real lesson? Passing test cases is not the same as meeting complexity requirements. Always verify your Big O, not just your output. #DSA #LeetCode #JavaScript #CodingJourney #Programming

Most beginners start JavaScript… but don’t understand variables & data types deeply. They declare variables. Store values. Write basic code. It feels easy — until logic gets complex. Then the real problems start: Confusion in data handling. Unexpected bugs. Weak logic building. Difficulty scaling code. In 2026, JavaScript isn’t about syntax. It’s about building strong logic foundations. This is where it starts: • Understanding var, let, const clearly • Knowing different data types (string, number, boolean, object, array) • Storing and managing data efficiently • Writing clean and predictable logic • Avoiding common beginner mistakes Because strong logic doesn’t come from frameworks — it comes from mastering the basics. Curious — are your fundamentals strong or just “working somehow”? #JavaScript #WebDevelopment #Coding #Programming #FrontendDevelopment #LearnToCode #DeveloperLife #JSBasics

📣 𝗡𝗲𝘅𝘁 𝗕𝗹𝗼𝗴 𝗶𝘀 𝗛𝗲𝗿𝗲! ⤵️ 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 19 of my Chai Code web development journey Today was a revision day. I went through the last two lectures on JavaScript Essentials again, and honestly, this helped more than learning something new. When I first learned these topics, I understood them at a surface level. But during revision, things started making more sense, especially around arrays and objects. I focused mainly on the concepts that are actually used in real projects: Arrays: map, filter, reduce slice vs splice mutating vs non-mutating methods sort with compare function Objects: Object.keys, values, entries dot vs bracket notation freeze vs seal property checks using "in" and hasOwnProperty One thing I noticed: Before, I was just writing these methods. Now I’m starting to understand when and why to use them. For example: ->map for transforming data ->filter for selecting data ->reduce for combining data Also revised some important fundamentals: ->shallow vs deep copy ->how data can get unintentionally mutated ->why immutability matters in real applications Big takeaway from today: Revision is where actual understanding happens. Learning once is not enough, you have to revisit it. Day 19 done. Consistency continues. Thank you Hitesh Choudhary sir, Piyush Garg sir, Anirudh Jwala sir, Suraj Kumar Jha for the support. #JavaScript #WebDevelopment #CodingJourney #LearnInPublic #LearnToCode #100DaysOfCode #Developers #Programming #TechCareers

🚀 Day 968 of #1000DaysOfCode ✨ Types of Loops in JavaScript (Explained Simply) Loops are one of the most fundamental concepts in JavaScript — but choosing the right one can make a big difference in your code. In today’s post, I’ve explained the different types of loops in JavaScript in a simple and practical way, so you can understand when to use each one. From `for` and `while` to `for...of` and `for...in`, each loop has its own purpose depending on how you’re working with data. Using the right loop not only makes your code cleaner but also improves readability and performance in many cases. This is one of those basics that every developer uses daily — but mastering it helps you write much better code. If you’re working with arrays, objects, or complex data structures, this is something you should be confident about. 👇 Which loop do you use the most in your day-to-day coding? #Day968 #learningoftheday #1000daysofcodingchallenge #FrontendDevelopment #WebDevelopment #JavaScript #React #CodingCommunity #JSBasics

Today I finally understood how JavaScript actually stores data in memory — and it changed the way I look at code. Earlier, I used to just write variables and functions without thinking much about what’s happening behind the scenes. But now it makes a lot more sense: Primitive values (like numbers, strings, booleans) are stored directly in memory Reference types (like arrays and objects) are stored differently — the variable holds a reference, not the actual value That’s why things like this behave unexpectedly sometimes: Copying objects doesn’t create a real copy Changing one reference can affect another Understanding this cleared up a lot of confusion I had while debugging. Still learning, but this felt like a small breakthrough Hitesh Choudhary Piyush Garg Chai Code #JavaScript #WebDevelopment #100DaysOfCode #LearningInPublic

59.8 MB JavaScript source leak of Claude Code. Surprisingly, it was a human error that happened during the release packaging. No customer data, API credentials, or model weights were exposed. But, 512,000 lines of TypeScript across ~1,900 files were exposed. It includes the query engine, tool system, multi-agent orchestration logic, and context compaction. But the amazing part? Someone noticed this as an opportunity. The guy's name is Sigrid Jin, a Korean Developer. He developed Claw Code, a clean-room Python rewrite of Claude Code's agent harness. He published it on GitHub where the repo reached 50k stars in just 2 hours. If you want the GitHub URL, comment "Claw Code" and I will share it with you.