Another Weekly Contest in the books! 💻 I just wrapped up LeetCode Weekly Contest 496 and ran into a "Medium" that felt a lot like a "Hard": Q3 - Minimum Increase to Maximize Special Indices. This one was a great exercise in Dynamic Programming and greedy logic. It was one of those problems where the initial logic seems simple (just look at odd/even indices), but the edge cases and constraints ($10^5$ length) force you to think much deeper. What I learned: - Don't rush to the first "obvious" pattern. - DP state transitions can be elegant when you use pairs to track multiple metrics. - Contest environments are the best way to practice thinking under pressure. - Slowly but surely getting better every week! 📊 My Stats: Runtime: 4ms (Beats 90.85%) Memory: 139.54 MB (Beats 90.42%) Complexity: O(n) Time | O(1) Space (optimized DP) 🧠 The Logic: This problem is a classic example of a "Double Optimization" challenge. You have to maximize the number of special indices while simultaneously minimizing the cost. The "trick" was realizing that a special index at i depends on its neighbors, which creates a dependency chain. I used a Dynamic Programming approach with two state variables (prev1, prev2) to track the best results for the previous indices. By using std::pair<int, long long>, I was able to prioritize the maximum count and then tie-break with the minimum cost in a single pass. Solution Link - https://lnkd.in/d5qPp_SY #BuildInPublic #SoftwareEngineering #LeetCode #WeeklyContest #Java #CPP #Python

𝗜𝗻𝘁𝗿𝗼𝗱𝘂𝗰𝗶𝗻𝗴 𝗞𝗮𝗶𝗿𝗼! About a year and a half ago, my friends and I started building a programming language. We'd been writing systems-level code across C++, Rust, and lower-level tooling for long enough to have strong opinions about what was missing. C++ gives you performance and the richest library ecosystem in systems programming, but the language fights you at every turn undefined behavior, header hell, decades of accumulated complexity. Rust solves the safety problem but introduces real cognitive overhead and a syntax that trades readability for compiler appeasement. We wanted something that didn't force that tradeoff. So we built Kairo a statically typed systems programming language with bidirectional C++ interoperability, readability-first syntax, and a memory safety model that gives you both manual and automatic memory tracking without fighting a borrow checker. 𝗪𝗵𝗲𝗿𝗲 𝘄𝗲 𝗮𝗿𝗲 𝗻𝗼𝘄 The project has come a long way. We shipped a Stage 0 bootstrap compiler, then used it to build a Stage 1 self-hosted compiler; Kairo is being written in Kairo itself! The language, toolchain, and ecosystem are actively under development and roughly halfway to a production release. 𝗪𝗵𝗮𝘁 𝗺𝗮𝗸𝗲𝘀 𝗞𝗮𝗶𝗿𝗼 𝗱𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝘁 - Bidirectional C++ FFI call C++ from Kairo and Kairo from C++, no bindings layer required. - Readability-first design. Code should be readable by default, not after three months of pattern memorization. - BCIR/AMT memory safety model manual and automatic memory tracking with safety guarantees, without Rust's borrow checker annoyance. - Planned interop expansion to Python and Rust. - Full access to the existing C++ library ecosystem from day one. 𝗖𝗼𝗻𝘁𝗿𝗶𝗯𝘂𝘁𝗼𝗿𝘀 :Arnav Goyal , Dhruvan Kartik and Me 𝗟𝗶𝗻𝗸𝘀 - Website: https://www.kairolang.org - Github: https://lnkd.in/gZEdW2Gi We're a three-person team and the project has 360+ GitHub stars. If this interests you, a star, an issue report, or a contribution all help. #CompilerDev #Compiler #tech #buildinpublic #SystemsEngineering

Day 112 of #200DaysOfCode Leveling up Consistency continues, one concept at a time. Today I solved the "Memoize" problem on LeetCode using closures + caching in JavaScript. Key Idea: Avoid recomputing the same function call by storing previously calculated results. Approach: • Use a Map as cache storage • Convert arguments into a unique key using JSON.stringify() • If result already exists return cached value • Otherwise compute, store, and return result Concepts Used: • Closures • Memoization • Map • Higher Order Functions Time Complexity: • First Call → Depends on function • Repeated Calls → O(1) average lookup Space Complexity: O(n) Takeaway: Memoization is a powerful optimization technique that trades space for speed and is heavily used in Dynamic Programming and performance optimization. Learning not just to solve problems — but to make solutions smarter Let’s keep building #Day112 #200DaysOfCode #LeetCode #JavaScript #Memoization #Closures #CodingJourney #ProblemSolving #KeepGoing

Day 38 of My DSA Journey Today I solved LeetCode 152 – Maximum Product Subarray on LeetCode. 📌 Problem Given an integer array nums, find the contiguous subarray that has the largest product, and return that product. Example: Input: [2,3,-2,4] Output: 6 → subarray [2,3] 🧠 Approach – Dynamic Programming (Tracking Max & Min) This problem is tricky because of negative numbers. Key Idea: • At each index, we maintain: maxProduct → maximum product ending at current index minProduct → minimum product ending at current index 👉 Why min? Because a negative number can turn a small (negative) product into a large positive one. Steps I followed: • Initialize maxProduct, minProduct, and ans with the first element • Traverse the array from left to right • If the current number is negative → swap max and min • Update: maxProduct = max(current, current × maxProduct) minProduct = min(current, current × minProduct) • Update the final answer using maxProduct ⏱ Time Complexity: O(n) — Single pass through the array 📦 Space Complexity: O(1) — No extra space used 💡 Key Learnings ✔ Handling negative numbers in product problems ✔ Using dynamic programming with state tracking ✔ Understanding why tracking both max & min is important This is one of those problems that looks simple but tests deep understanding of edge cases 🚀 Consistency continues — leveling up every day 💪 #100DaysOfCode #DSA #DynamicProgramming #Arrays #LeetCode #Java #ProblemSolving #CodingJourney #DeveloperJourney #Programming #SoftwareEngineering

When two systems communicate over the internet, they often use different programming languages. For example: Frontend → JavaScript Backend → Python / Go / Rust / Java But these languages all have different data structures and types. So how do they actually understand each other? The answer is serialization and deserialization. In this article, I explain this concept from first principles: • How clients and servers exchange data • Why systems need a common format • What serialization and deserialization actually mean • Why JSON became the standard format for APIs • Where serialization fits in the network communication flow If you're learning backend engineering or system design, this is one of those foundational concepts that makes many other things easier to understand. 📖 Read the article: Serialization & Deserialization https://lnkd.in/g4GXncHj I’m also documenting my learning journey in these playlists: Backend Engineering from First Principles https://lnkd.in/g7MJ6TnP System Design from First Principles (HLD + LLD) https://lnkd.in/gateH6Jz #BackendEngineering #SystemDesign #APIDesign #SoftwareEngineering #WebDevelopment

Day 36 of My DSA Journey Today I solved LeetCode 150 – Evaluate Reverse Polish Notation (RPN) on LeetCode. 📌 Problem Evaluate the value of an arithmetic expression in Reverse Polish Notation. Valid operators are: +, -, *, / Each operand may be an integer. Example: Input: ["2","1","+","3","*"] Output: 9 Explanation: (2 + 1) * 3 = 9 🧠 Approach – Stack This problem is a perfect application of the Stack data structure. Steps I followed: • Traverse the tokens array. • If the element is a number → push it onto the stack. • If it is an operator: Pop the top two elements (a and b) Perform the operation (a operator b) Push the result back into the stack • At the end, the stack contains the final result. ⏱ Time Complexity: O(n) — We process each token once 📦 Space Complexity: O(n) — Stack to store operands 💡 Key Learnings ✔ Understanding Reverse Polish Notation (Postfix Expression) ✔ Applying stack for expression evaluation ✔ Handling operator precedence implicitly using stack This problem connects DSA with compiler/interpreter concepts, which makes it even more interesting 🚀 Consistency continues — improving every day 💪 #100DaysOfCode #DSA #Stack #LeetCode #Java #ProblemSolving #CodingJourney #DeveloperJourney #Programming #SoftwareEngineering

I spent a few weeks migrating 5 microservices from C# + gRPC to F# + gRPC. Personal project, no deadlines, no pressure.... only fun!! I have a background in functional programming. But I had not touched anything in that paradigm for years. Day-to-day Python, C/C++, C# is imperative by default, and that default goes deep. The good part first: some things in F# are genuinely simpler. Discriminated unions for domain modeling, function composition with |>, pattern matching that covers every case and the compiler holds you accountable. Things that exist in C# too, but cost more code to express. The beginning was harder than I expected, precisely because of that background.... I knew what a pure function was. I knew what immutability meant. The problem is that knowing something conceptually does not mean your brain will reach for it first when a problem shows up. Years of writing loops and mutations build a reflex. My first instinct was still: create a variable, iterate, mutate. In F#, that path exists, but you are swimming against the current. The language pushes you to think about what the function receives, what it returns, how to compose that with the next step. It took me a while to stop mentally translating C# into F# and start formulating the problem in F# directly. Another real point: the compiler is strict, which is good, but error messages can be cryptic when you are still reactivating that way of thinking. You know something is wrong, but the message does not always point directly at it. In the end, it worked. The services are running, gRPC integrated without major surprises, and the code got leaner in several places. The most useful thing I learned was not technical. It was realizing that knowledge rusts when left untouched, and that years on the imperative autopilot leave a deeper mark than it seems. And on that note: AI is making this worse. Every time you let it write the code, debug the problem, or think through the design for you, you are not just saving time. You are letting your own knowledge rust a little more. It does not matter if it is functional programming, system design, algorithms, or anything else in tech. The muscle atrophies when it stops being used. #fsharp #dotnet #grpc #functionalprogramming

🚀 How LinkedList Solves What Arrays Cannot. (https://lnkd.in/g_8fWXFq ) ➡️ An array demands contiguous memory — every element must sit next to the other. But what if memory is scattered? That's exactly where LinkedList steps in, connecting nodes across RAM using addresses. Here are the key takeaways from the LinkedList session at TAP Academy by Sharath R sir : 🔹 The Node: Every element lives in a node — an object with a data field and the address of the next (and previous) node. It's not magic, it's just object references. 🔹 Singly vs Doubly: Singly LL has one link — forward traversal only. Doubly LL has two links — bidirectional. Java's LinkedList class uses Doubly LL internally. 🔹 Initial Capacity = 0: Unlike ArrayList (initial capacity 10), LinkedList pre-allocates nothing. Every add() creates a fresh node dynamically — no contiguous block needed. 🔹 Polymorphism hiding in plain sight: new LinkedList(arrayList) works because ArrayList IS-A Collection. Parent reference + child object = loose coupling. The same concept from OOP, live inside Collections. 🔹 Iterator vs ListIterator: Iterator moves forward only. ListIterator moves both ways — but declaring it as Iterator type blocks access to hasPrevious(). That's Inheritance at work — parent references can't reach specialized child methods. Visit this Interactive webpage to understand the concept by visualization : https://lnkd.in/g_8fWXFq #Java #LinkedList #CoreJava #TapAcademy #DataStructures #OOP #Collections #LearningEveryDay #SoftwareDevelopment #Programming

🚀 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

Here's the thing most developers miss: Claude Code has full terminal access. That's the entire point. It can shell out to wc for accurate token counts (LLMs are terrible at counting). It can use grep, sed, awk for text processing. It can hit APIs, execute Python scripts, deploy to production. It can also rm -rf your entire system if you're not careful with permissions. So the setup isn't optional. It's the foundation. We talked about Claude Code setup and barely opened Claude Code itself yesterday. Because that's how software development works. You build the infrastructure first. #ClaudeCode #DeveloperProductivity #AITools #SoftwareDevelopment