The Weird World of Floating-Point Arithmetic: Why Computers Get Math Wrong

just published a new breakdown on ref, in and out in C#, when to use them, how they work, and the performance trade-offs If you want a simple, quick and practical guide to passing parameters efficiently (with real examples), here you go 👇 🔗 https://lnkd.in/dbb_WtQ2 #csharp #dotnet #programming #softwareengineering #performance #cleancode #developers

🧠 Day 37 of #100DaysOfCode 📦 Project: Number to Words Converter in C Today I built a C program that converts any number (up to 9 digits) into its word representation! 💬🔢 ✨ Highlights: Handles billions, millions, thousands, and hundreds with proper segmentation. Covers special cases like teens (10–19) and tens (20, 30, …). Modular design using arrays for digit names and a clean convert_hundreds() function. Input: 123456789 → Output: "One Hundred Twenty Three Million Four Hundred Fifty Six Thousand Seven Hundred Eighty Nine" This was a fun challenge in logic structuring and string formatting. It deepened my understanding of number decomposition and control flow in C. 💡 Next up: maybe adding support for decimals or currency formatting? 💸 🔧 Built with: C language Console I/O Arrays & conditionals #CProgramming #CodingChallenge #100DaysOfCode #CodeNewbie

There’s one STL feature I wish I had learned earlier: std::optional. It’s such a simple idea — a variable that might hold a value, or nothing. But once you start using it, you realize how much cleaner your code becomes. Before std::optional, I used magic values, null pointers, or random flags to signal “no result.” It always felt messy. With optional, intent becomes explicit: this function may or may not produce a value. No guessing, no hidden state. Example: std::optional<int> findUserAge(const std::string& name); That line already tells you the story. The compiler enforces what used to be just “discipline.” It’s one of those small modern C++ touches that make you write safer and more expressive code without losing control. If you haven’t explored features like optional, variant, or any yet — they’re worth a weekend of deep diving. They’ll quietly upgrade the way you design functions. What STL feature do you think deserves more attention? #cplusplus #programming #moderncpp #softwareengineering #learning

.NET Exception Handling: Preserve StackTrace with throw, avoid throw ex; A simple but important detail you must never forget! #Csharp #NET #ExceptionHandling #Development #StackTrace #Throw

💬 Project 4: Lexical Analyzer – C Tokenizer & Parser Ever wondered how a compiler understands your C code before it even runs? 👀 To explore that, I built a Lexical Analyzer in C — a command-line tool that scans and tokenizes C source files. It identifies keywords, identifiers, constants, operators, and special symbols, and even flags lexical errors such as invalid tokens or unmatched brackets. ⚙️ What I Learned: • Designed a tokenization logic that scans source code character by character • Implemented structures, enums, and string operations to classify tokens efficiently • Debugged complex edge cases like macros, preprocessor directives, and numeric literals (int, float, hex, octal) 💻 Tech Stack: C, File I/O, Compiler Design Concepts, String Processing, Structures 🔗 GitHub: https://lnkd.in/gyrf8kJw 📸 I’ll be sharing the terminal output showing the token list and categorized symbols in the comments below. Next up → APC Calculator – Arbitrary Precision Arithmetic using Doubly Linked List #CProgramming #CompilerDesign #SystemsProgramming #SoftwareEngineering #LearningByDoing #Linux

𝐖𝐞 𝐚𝐫𝐞 𝐞𝐧𝐚𝐛𝐥𝐢𝐧𝐠 𝐞𝐱𝐩𝐞𝐫𝐢𝐦𝐞𝐧𝐭𝐚𝐥 𝐚𝐬𝐬𝐞𝐫𝐭-𝐚𝐬-𝐚𝐬𝐮𝐦𝐞 For our release builds. 1. Every DBUG_ASSERT(x) now becomes [[assume(x)]] by default. 2. Some cases are opted out. Sometimes we have code like: DBUG_ASSERT(x); if (x) return error; // failsafe production case --^ Assuming `x` will not work as expected here. 3. It only targets `main` branch, meaning it's only for the major release. Here's one curious case. The simplified code: 𝚋𝚘𝚘𝚕 𝚏𝚘𝚞𝚗𝚍 = 𝚏𝚊𝚕𝚜𝚎; 𝚏𝚘𝚛 (𝚜𝚒𝚣𝚎_𝚝 𝚒= 0; 𝚒 < 𝚊𝚛𝚛𝚊𝚢->𝚎𝚕𝚎𝚖𝚎𝚗𝚝𝚜; 𝚒++) 𝚒𝚏 (𝚙𝚝𝚛 == *𝚍𝚢𝚗𝚊𝚖𝚒𝚌_𝚎𝚕𝚎𝚖𝚎𝚗𝚝(𝚊𝚛𝚛𝚊𝚢, 𝚒, 𝚟𝚘𝚒𝚍**)) { 𝚍𝚎𝚕𝚎𝚝𝚎_𝚍𝚢𝚗𝚊𝚖𝚒𝚌_𝚎𝚕𝚎𝚖𝚎𝚗𝚝(𝚊𝚛𝚛𝚊𝚢, 𝚒); 𝙸𝙵_𝙳𝙱𝚄𝙶(𝚏𝚘𝚞𝚗𝚍= 𝚝𝚛𝚞𝚎); // 𝚊𝚜𝚜𝚒𝚐𝚗𝚖𝚎𝚗𝚝 𝚑𝚊𝚙𝚙𝚎𝚗𝚜 𝚘𝚗𝚕𝚢 𝚒𝚗 𝚍𝚎𝚋𝚞𝚐 𝚖𝚘𝚍𝚎 } 𝙳𝙱𝚄𝙶_𝙰𝚂𝚂𝙴𝚁𝚃(𝚏𝚘𝚞𝚗𝚍); // 𝚏𝚘𝚞𝚗𝚍 𝚒𝚜 𝚗𝚘𝚝 𝚏𝚞𝚛𝚝𝚑𝚎𝚛 𝚞𝚜𝚎𝚍. In the release mode, found=true assignment wasn't present, which eventually led to a crash. Why though? `found` does not intervene the loop, so the reason is not so obvious. Here is a sketch example, showing the problem core: https://lnkd.in/dsGY4G3y We can see there what the compiler thinks: 1. bool found = false; assume(found) means assume(false) 2. Having assume(false), this point in code is 𝘂𝗻𝗿𝗲𝗮𝗰𝗵𝗮𝗯𝗹𝗲 3. 𝘈𝘴 𝘴𝘶𝘤𝘩, 𝘐 𝘤𝘢𝘯 𝘤𝘰𝘯𝘴𝘪𝘥𝘦𝘳 𝘵𝘩𝘦 𝘭𝘰𝘰𝘱 𝘢𝘣𝘰𝘷𝘦 𝘪𝘯𝘧𝘪𝘯𝘪𝘵𝘦 Fascinating! Indeed, the godbolt link above shows that an unconditional jmp command was generated. This case shows how effective the assumption mechanism can be on practice. #mariadb #performance #coding

Rust’s Lifetimes vs Manual Memory in C In C, developers manually manage memory using malloc() and free(), which gives full control but also introduces dangerous risks like dangling pointers, memory leaks, and use-after-free errors. Rust eliminates these issues through its lifetime system, which the compiler uses to track how long each reference remains valid. This means memory safety is guaranteed at compile time, not runtime, without requiring a garbage collector. Lifetimes ensure that no reference outlives the data it points to, making bugs that crash systems in C impossible in safe Rust. The result is C-level performance with mathematically proven safety a balance that has redefined systems programming.

Even if a problem can be solved using dynamic programming, it's not always the best solution possible, and sometimes a simple DFS/BFS approach might produce a better solution with less code. Thus, it's essential to understand how to calculate the complexity of graph traversal algorithms, even for non-standard graphs. The post: https://lnkd.in/dATG59j3 The problem: https://lnkd.in/d5TahY47 #LeetCode #DSATips #DSA #ThinkDSA #ProblemSolving

𝐋𝐞𝐞𝐭𝐜𝐨𝐝𝐞 𝐃𝐚𝐢𝐥𝐲 𝐂𝐡𝐚𝐥𝐥𝐞𝐧𝐠𝐞 - 𝟑𝟑𝟏𝟖. 𝐅𝐢𝐧𝐝 𝐗-𝐒𝐮𝐦 𝐨𝐟 𝐀𝐥𝐥 𝐊-𝐋𝐨𝐧𝐠 𝐒𝐮𝐛𝐚𝐫𝐫𝐚𝐲𝐬 𝐈 🔹 Problem Overview: Given an array nums, an integer k (window size), and x, we slide a window of size k across the array and, for each window, calculate its x-sum — the sum formed by the top x most frequent elements (based on frequency, then value). If there are fewer than x distinct elements, we take the total sum of that subarray. 💡 Approach Explanation: [1] 𝐒𝐥𝐢𝐝𝐢𝐧𝐠 𝐭𝐡𝐞 𝐰𝐢𝐧𝐝𝐨𝐰: iterate over each window of size k in the array - total (n - k + 1) windows. [2] 𝐂𝐨𝐮𝐧𝐭𝐢𝐧𝐠 𝐟𝐫𝐞𝐪𝐮𝐞𝐧𝐜𝐢𝐞𝐬: For each window, use an unordered_map to store the frequency of each element. [3] 𝐒𝐞𝐥𝐞𝐜𝐭𝐢𝐧𝐠 𝐭𝐨𝐩 𝐱 𝐟𝐫𝐞𝐪𝐮𝐞𝐧𝐭 𝐞𝐥𝐞𝐦𝐞𝐧𝐭𝐬: use a min-heap (priority_queue) to maintain only the top x most frequent elements. • Each heap entry is {frequency, value}. • The heap ensures that only the most frequent (and if tie, higher value) elements remain. • If the heap size exceeds x, the least frequent is removed. [7] 𝐂𝐚𝐥𝐜𝐮𝐥𝐚𝐭𝐢𝐧𝐠 𝐱-𝐬𝐮𝐦: For the remaining x elements in the heap, calculate ans += frequency * value. That gives the x-sum for that particular window. Complexity: Time Complexity: O(n × k), Space Complexity: O(k + x) 𝑇𝘩𝑖𝑠 𝑎𝑝𝑝𝑟𝑜𝑎𝑐𝘩 𝑒𝑓𝑓𝑖𝑐𝑖𝑒𝑛𝑡𝑙𝑦 𝑐𝑜𝑚𝑏𝑖𝑛𝑒𝑠 𝑓𝑟𝑒𝑞𝑢𝑒𝑛𝑐𝑦 𝑐𝑜𝑢𝑛𝑡𝑖𝑛𝑔 𝑎𝑛𝑑 𝘩𝑒𝑎𝑝 𝑙𝑜𝑔𝑖𝑐 𝑡𝑜 𝘩𝑎𝑛𝑑𝑙𝑒 𝑡𝘩𝑒 𝑠𝑢𝑏𝑎𝑟𝑟𝑎𝑦 𝑎𝑛𝑑 𝑓𝑟𝑒𝑞𝑢𝑒𝑛𝑐𝑦-𝑏𝑎𝑠𝑒𝑑 𝑠𝑒𝑙𝑒𝑐𝑡𝑖𝑜𝑛 𝑝𝑟𝑜𝑐𝑒𝑠𝑠. #LeetCode #ProblemSolving #DSA #Cplusplus #CodingChallenge #SlidingWindow #Heap #Programming #DailyLeetcode

Day 1/30 of Solving Dp problem . Problem - Zero Array Transformation IV Time complexity - O(n*q^2*log(q)) , Space - O(n*max(nums[i])) Approach - Binary search on query index with Dp - Till mid index, for every element of nums check we can make nums[i] equal to zero using queries till mid index ( use dp for this ). #leetcode #dsa #problemsolving #programming