Ranit Manik’s Post

The biggest React 19 feature isn’t a new hook. it’s the React Compiler, now stable and shipping with zero configuration! The compiler automatically memoizes your components. You no longer need to sprinkle useMemo, useCallback, and React.memo everywhere: #react #developer #dev #programming #react19 #compiler #programming #tips #frontend

A lot of people are shipping faster than ever, but when something breaks, most reach for AI instead of looking at what the browser is actually telling them. I wrote 5 DevTools features that most developers miss and never really used: → $0 and $_ console shortcuts → Network request blocking → Local Overrides → Rendering panel → Memory profiling Full breakdown is on my blog 👇 https://lnkd.in/g3w2GnDv #frontend #webdevelopment #devtools #javascript #programming

🚀 Day 568 of #750DaysOfCode 🚀 🔍 Problem Solved: Two Furthest Houses With Different Colors Today’s problem looked simple at first, but it had a nice twist that tested observation skills more than brute force thinking. 💡 Key Insight: To maximize the distance between two houses with different colors, we don’t need to check all pairs. The answer will always involve either: the first house, or the last house Why? Because the maximum distance comes from the edges of the array. ⚡ Approach: Compare every house with the first and last house If colors are different → calculate distance Keep track of the maximum distance 🧠 Optimization: Instead of an O(n²) brute-force approach, we can solve this in O(n) time with constant space. 📈 Complexity: Time: O(n) Space: O(1) ✨ Takeaway: Sometimes the best solution isn’t about trying everything — it’s about spotting the right pattern. #LeetCode #Java #DSA #CodingJourney #ProblemSolving #100DaysOfCode #Programming #Tech #LearningEveryday

Imagine a world where building a web app could require 12 hour deep dive into debugging linker problems after bisecting two months of nightly tool chains. Put away your JavaScript and Node, and join us in the trenches with Rust and WebAssembly! Earn your stripes. Contribute to the growing pool of blood, sweat, and tears that you've always heard about. #Rust #Programming #WebAssembly #Leptos

🚀 Excited to share one of the most ambitious projects Diamond 💎 This isn’t just a compiler. It’s a complete educational ecosystem that brings together language design, systems programming, and modern web engineering into one unified platform. Visit here: https://lnkd.in/gP3QHCkx 🔍 What is Diamond? A custom programming language + a real compiler built in C + a fully interactive browser-based IDE. ⚙️ Core Highlights: Built a full compiler pipeline using C, Flex, and Bison Converted the compiler to WebAssembly so it runs directly in the browser Designed a modern IDE using Next.js, React, and TypeScript Added a multi-layer compilation strategy: Browser (WASM) Web Worker optimization Backend fallback (Express.js) Demo mode for resilience 📊 Educational Features: AST Visualization (Graph-based) Flowchart Generation from code logic Token & Symbol Table inspection Scope Explorer & Type Inference insights Intermediate Representation (TAC) & pseudo-assembly view Built-in Debugger with memory snapshots Interactive Challenges & Test Suite One-click HTML/PDF Report Export #CompilerDesign #WebAssembly #FullStackDevelopment #ProgrammingLanguages #SoftwareEngineering #CProgramming #React #NextJS #EducationTech

C# allows multiple inheritance via interfaces (safe), but not via classes (ambiguous).Multiple Inheritance in C# — Interfaces vs Classes (Quick Summary) 🔹 Using Interfaces (Allowed ✅) A class can implement multiple interfaces Interfaces have no implementation, only method signatures The class provides one implementation 👉 No ambiguity, no duplication 🔹 Using Classes (Not Allowed ❌) A class cannot inherit from multiple classes Because it would bring multiple implementations of same method Leads to Diamond Problem (ambiguity) 👉 Compiler won’t know which method to call #CSharp #DotNet #ASPNetCore #SoftwareDevelopment #Programming #Coding #Developer #WebDevelopment #BackendDevelopment #TechInterview #InterviewPrep #LearningToCode #100DaysOfCode #CodeNewbie #DevelopersLife

We all use console.log… But we barely use its real power. We’ve all done this: console.log("check") Again. And again. And again. 😅 But the console can do way more. 👇 console.table(data) // better data view console.time("api") // measure performance console.timeEnd("api") // end timer console.group("Debug") // structured logs Most of us debug. A few of us debug smartly. Small tools. Big difference. Curious — What's one console trick you use often? 👇 #Developers #JavaScript #Debugging #Programming #TypeScript #Coding

Made a video about my year-long experience of rewriting the entire backend of RecordRanks and the lessons I learned from it: https://lnkd.in/dtaS-RrT #coding #programming #webdev #NextJS #React

🚀 Jetpack Compose — What actually happens inside @Composable? (Deep Dive) @Composable is not just an annotation. It's a promise to the compiler: 👉 "please transform me." Think of the Compose compiler like a secret assistant that rewrites your code before the JVM sees it. Step 1 — You write this @Composable fun Greeting(name: String) { Text("Hello, $name") } Step 2 — Compiler transformation The compiler secretly adds two hidden parameters: fun Greeting( name: String, $composer: Composer, $changed: Int ) • $composer → Tracks position in UI tree (SlotTable) • $changed → Bitmask → tells if inputs changed 👉 This is how Compose decides whether to skip execution Step 3 — Restart group (Recomposition scope) $composer.startRestartGroup(KEY) // UI code $composer.endRestartGroup()?.updateScope { c, _ -> Greeting(name, c, 1) } 👉 Registers a stored lambda 👉 Allows recomposition of ONLY this scope (not whole UI) Step 4 — Smart skipping At runtime, Compose checks: 👉 “Did anything change?” • If NO → entire function is skipped (zero work) • If YES → function re-executes 👉 This is the core performance optimization Step 5 — remember {} becomes SlotTable read val count = remember { mutableStateOf(0) } ➡️ Transforms into: val count = $composer.cache(false) { mutableStateOf(0) } 👉 Stored in SlotTable 👉 Retrieved by position 👉 Survives recomposition 🧠 Interview Summary "@Composable is a compiler transformation where functions are converted into restartable groups tracked by a Composer. A bitmask enables skipping, and stored lambdas allow recomposition of only affected scopes." ❓ Why can't @Composable be called from normal function? 👉 Because normal functions don’t have $composer ✔ Compile-time restriction 💬 This is a commonly asked deep-dive question in Android interviews #AndroidDevelopment #JetpackCompose #Kotlin #ComposeInternals #Recomposition #StateManagement #CleanArchitecture #MVVM #MVI #AndroidInterview #InterviewPreparation #SoftwareEngineer #MobileDeveloper #DeveloperLife #Programming #Coding #DevCommunity

The low code/ no code ecosystem that thrived for the last 20 years is dying as architecture. The idea of building a custom proprietary runtime that only works for specific vendor is no longer a solution. Now you can generate apps of javascript, C#, Python,….. using new generation of platforms that are not proprietary. It helps you generate the code not own your app through monthly subscription forever. Even if the old platforms added AI generators, why sticking to proprietary if I can be free? That’s the challenge for platforms like Power Apps. Either to start new from scratch or lose the market. #nocode #lowcode #powerapps