Track Claude Code Usage with CLI Package

📌 #60 DailyLeetCodeDose Today's problem: 73. Set Matrix Zeroes – 🟡 Medium When a problem states that you must modify the data in-place, LeetCode has taught me a useful pattern: to boost performance and avoid extra memory, you can reuse the same mutable data structure to encode all the information you need. In this problem, instead of using additional arrays or hash sets, I use the first row and the first column of the matrix as markers – while scanning the matrix, whenever I encounter a zero, I mark its entire row and column by setting the corresponding cell in the first row or first column to zero. Since the first row and first column are also part of the original data, I store their initial state in two boolean flags. This allows me to correctly decide at the end whether they themselves should be zeroed out. As a result, the solution runs in O(m × n) time and uses O(1) extra space, fully satisfying the in-place requirement. https://lnkd.in/eRxwBy4g #DailyLeetCodeDose #LeetCode #JavaScript #Algorithms #ProblemSolving #Coding

Is your JS copy a "Duplicate" or just a "Shortcut"? 👯♂️ Updating a "new" object only to see the original change too? That's a Shallow Copy bug. In JavaScript, objects are stored by reference. If you don't copy them correctly, you're just sharing memory. The Quick Fix: 📂 Shallow ({...obj}): Copies the surface. Nested objects stay linked. Use for flat data. 🏗️ Deep (structuredClone): Copies everything. Completely independent. Use for complex data. Stop using JSON.parse hacks. 🛑 I’ve broken down the memory mechanics and real-world "Ghost Mutation" fixes in my latest blog. Read the 2-minute deep dive: 👉 [https://lnkd.in/gzeT3rYw] #JavaScript #CleanCode #WebDev #Programming

Day 6: Closures - Understanding how functions remember variables. Today I learned: - What closures are (functions accessing parent scope variables) - Creating private variables with closures - Building a counter with increment and getCount methods Small wins: - Struggled understanding closure concept → Realized it's like "function takes memory with it" - Didn't know how to structure return object with methods → Session 2 knowledge helped Closures are the foundation of data encapsulation in JavaScript. Code: https://lnkd.in/gtT73HVR 144 days remaining. #JavaScript #BackendDeveloper #Closures #100DaysOfCode

💻 Keep these handy (Developer Edition) Code Snippet Library → https://snippets.dev Free API Collection → https://lnkd.in/gsTgEWeC Regex Tester → https://regex101.com JSON Formatter → https://jsonformatter.org CSS Generator → https://cssgenerator.org Favicon Generator → https://lnkd.in/gG2JY5ES Open Source Alternatives → https://lnkd.in/gccktyrw System Design Primer → https://lnkd.in/gJzpSaTh Dev Docs Search → https://devdocs.io Save this list — it will save you hours while building. 🚀 #WebDevelopment #Developers #Programming #DevTools #DeveloperResources #CodingTips

Number of steps to reduce ........................ 47 🔥 ✅ Approach 🔹 Initialize: steps = 0 carry = 0 🔹 Traverse the binary string from right to left, ignoring the most significant bit (index 0). 🔹 For each bit: Compute bit + carry 👉 If the result equals 1 (number becomes odd): One step to add 1 One step to divide by 2 Total → 2 steps Set carry = 1 👉 Otherwise (number is even): Only divide by 2 Total → 1 step 🔹 After traversal, if a carry still remains, add it to the total steps. ✅ Return the final number of steps. This problem was a great exercise in understanding: ✔ Binary operations ✔ Carry propagation ✔ Efficient simulation without actual conversions 📌 Example Input: s = "1101" Binary "1101" corresponds to 13 in decimal. Step 1️⃣: 13 is odd → add 1 → 14 Step 2️⃣: 14 is even → divide by 2 → 7 Step 3️⃣: 7 is odd → add 1 → 8 Step 4️⃣: 8 is even → divide by 2 → 4 Step 5️⃣: 4 is even → divide by 2 → 2 Step 6️⃣: 2 is even → divide by 2 → 1 ✅ Output: 6 steps #JavaScript #TypeScript #SoftwareDevelopment #FrontendDeveloper #CodingJourney #DevelopersLife #LearningInPublic #ContinuousLearning #TechLearning #DeveloperGrowth #100DaysOfCode

📌 #61 DailyLeetCodeDose Today's problem: 146. LRU Cache – 🟡 Medium This task looks simple until you remember the O(1) requirement. A map alone is not enough – we also need to track recency. The key idea is combining a hash map with a doubly linked list: the map gives instant access, the list keeps items ordered by usage. Every get or put moves the node to the front, making it the most recently used. When capacity is exceeded, the last node is removed – that's the true LRU. Clean design, strict O(1), and a great reminder that the right data structure is often the whole solution. https://lnkd.in/epVtDYKH #DailyLeetCodeDose #LeetCode #JavaScript #Algorithms #ProblemSolving #Coding

Wrapped up 5 challenges this weekend covering string manipulation, object management, and array logic. Check the carousel for the breakdown of the goals and challenges I solved. Code snippets styled with: https://carbon.now.sh/ hashtag#JavaScript hashtag#WebDev hashtag#BuildInPublic hashtag#LogicPuzzles"

Not every problem needs inheritance. Sometimes you just need to add one method. Extension members in C# let you attach new methods, properties, and more to existing types without touching their source code. A string, a List, a third party SDK class. Doesn't matter. public static class StringExtensions {   public static bool IsNullOrEmpty(this string value)     => string.IsNullOrEmpty(value); } Now myString.IsNullOrEmpty() reads like it was always part of the language. Extensions don't break encapsulation, they respect it. You're building on top of the public surface, not reaching into the internals. That's good design. They also shine with interfaces: public static class CollectionExtensions {   public static bool IsEmpty<T>(this IEnumerable<T> source)     => !source.Any(); } Every class that implements IEnumerable<T> gets this for free. No inheritance. No modification. Clean. C# 14 is pushing this further with proper extension members and cleaner syntax. Composition over inheritance, without sacrificing readability. One thing to keep in mind: extensions are resolved at compile time, not runtime. No polymorphism. Use them for utility and convenience, not core domain logic. #CSharp #DotNet #SoftwareEngineering #OOP #CleanCode #BackendDevelopment #Programming #CSharp14 #SoftwareDevelopment #CodeQuality