Baffour Kusi Frimpong’s Post

If you start your day with jogging and not with reading STL sources like me, this post is probably not for you. Once, while reading sources for std::function, I found an unexpected solution for managing a stored object. Instead of a classic vtable, they implemented one function which selects the required operation by its code. Why? So I made a simple test project to compare different approaches: classic inheritance, vtable, and a managed table. I called it "managed" because the function I created was named "manage". To compare them, I filled a vector of Storage with different Foo<I> types, copied them, moved them, and destroyed them. The actual Storage was selected in each executable. So the testing code was identical, and the only difference was in how the stored object was managed. At first I was focused on the binary size of the built executable. Check the project on my repo: https://lnkd.in/dGhFy9ND The result: The managed table wins on every count of Foos. The vtable comes next, and inheritance produces the fattest binary. I also tested it with -fno-rtti; inheritance moved closer to the vtable but was still the worst. Next step: I will try to benchmark it to find out which approach is best for performance. #cpp #cxx #c++ #optimizations #metaprogramming #test

Reading through the upcoming C++26 changes, I ran into an example that captures a recurring tension in modern C++ very well. // Predicate: select monsters that are currently dead. auto dead = [](const auto& monster) { return monster.isDead(); }; // Problematic pattern: // We iterate over a filtered view and then mutate the same property // that the filter depends on. for (auto& monster : monsters | std::views::filter(dead)) { monster.bringBackToLife(); // Undefined behavior } At first glance, this feels surprising. C++26 proposes this form instead: // Treat the range as input-only before filtering. // This avoids the multi-pass assumptions that make the previous code invalid. auto dead = [](const auto& monster) { return monster.isDead(); }; for (auto& monster : monsters | std::views::as_input | std::views::filter(dead)) { monster.bringBackToLife(); // OK } What makes this interesting is not just the rule itself, but the feeling it creates. When a language needs an extra adapter to make a very intuitive loop valid, it raises a deeper design question: is the programmer doing something exotic, or is the abstraction exposing machinery that leaks too much into everyday code? Examples like this still make C++ feel as if correctness sometimes depends less on what the code means, and more on whether you remembered the exact operational contract of the pipeline. This is one of those moments where modern C++ feels incredibly powerful, but also slightly at odds with how humans naturally expect code to behave. #cpp #cpp26 #programming #softwareengineering #systemsprogramming

In C++, the difference between thread_local VS static thread_local thread_local = one separate instance per thread thread_local variable gives each thread its own copy of the variable. static = controls lifetime & linkage, not “per-thread-ness” static thread_local int x = 0; still one per thread but also has static lifetime created when thread starts (or first use) destroyed when thread ends Difference: (A) Namespace / global scope thread_local → external linkage (visible across translation units) static thread_local → internal linkage (file-local) => This is about linking, not threading behavior. (B) Inside a function void f() {   thread_local int x = 0; } vs void f() {   static thread_local int x = 0; }  In practice, these behave the same. Why? thread_local already implies static storage duration adding static is redundant thread_local → each thread owns its own copy static       → it lives for the entire lifetime (of thread/program) #CPP #LowLatency #HighPerformance #HFT #SystemsProgramming #SoftwareEngineering #Optimization #HardwareAware

🚫 A Subtle C++ Trap: Passing by Value to a Copy Constructor class A { public:   A() { cout << "Default ctor\n"; }   A(const A obj) {     cout << "Copy ctor\n";   } }; Now try: A a1; A a2 = a1; 💥 What goes wrong? Passing the parameter by value means: The compiler must copy obj That requires calling the copy constructor again Which again needs a copy... 🔁 Infinite recursion → Compilation error ✅ Correct way A(const A& obj) // ✔ pass by reference 🧠 Why this matters This isn’t just syntax — it’s about object lifetime and control. If you pass by value: You trigger unnecessary copies or worse, break compilation entirely. “A copy constructor must take its argument by reference; otherwise, it causes infinite recursion due to repeated copy construction.” #cpp #cplusplus #softwareengineering #codinginterview #systemdesign

Built a Multithreaded Matrix Library in C++ Yesterday, I implemented a custom matrix class from scratch in C++, focusing on both correctness and performance. Key highlights: • Implemented full Rule of 5 (copy/move semantics) • Designed cache-friendly contiguous memory layout • Added operator overloading for intuitive usage • Built multithreaded matrix multiplication using std::thread • Handled thread partitioning and hardware concurrency properly Then I benchmarked it Matrix Size → Time (Multithreaded) • 800 × 800 → ~0.25 sec • 1000 × 1000 → ~0.50 sec • 10000 × 10000 → ~571 sec Some interesting takeaways: • Performance scales roughly with O(n³) as expected • Multithreading helps, but memory bandwidth becomes the bottleneck at large sizes • Proper data layout (contiguous memory) is critical for performance This was a great exercise in: • Systems-level thinking • Concurrency in C++ • Performance engineering #Cplusplus #Multithreading #Performance #SystemsProgramming #LearningInPublic

Mutex might sound like the solution here, but you also essentially lose the parallelism by making the thread wait for other threads to finish work. Things LIKE atomics should be considered the defacto answer, mutexes are a last resort.

Day 177/365 – DSA Challenge 📘 Solved Distinct Subsequences on LeetCode today. 🔹 Problem: Count the number of distinct subsequences of string s that equal string t. 🔹 Approach Used: Dynamic Programming (2D DP) Steps followed: 1️⃣ Let dp[i][j] = number of ways to form t[j:] from s[i:] 2️⃣ Base case: dp[i][n] = 1 (empty string can always be formed) 3️⃣ Traverse from back: If characters match → include + exclude Else → skip character in s 🔹 Transition: If s[i] == t[j] → dp[i][j] = dp[i+1][j+1] + dp[i+1][j] Else → dp[i][j] = dp[i+1][j] 🔹 Key Idea: At each step → either use the character or skip it 🔹 Time Complexity: O(m × n) 🔹 Space Complexity: O(m × n) 💻 Language: C++ Classic DP problem that builds strong intuition for subsequence counting patterns 🔥 #Day177 #365DaysOfCode #DSA #LeetCode #DynamicProgramming #Strings #Cpp

DAY->21 Solved Reverse String (Two-Pointer Approach) in C++. Initially faced a Time Limit Exceeded issue due to a subtle bug (while loop semicolon), which led to an infinite loop. After debugging, optimized the solution using an in-place two-pointer technique. ✔ Time Complexity: O(n) ✔ Space Complexity: O(1) Key takeaway: Small syntax mistakes can significantly impact performance. #Datastructures #algorithms #cpp #leetcode #problemsolving

Day 179/365 – DSA Challenge 🌳 Solved Flatten Binary Tree to Linked List on LeetCode today. 🔹 Problem: Flatten a binary tree into a linked list in-place following preorder traversal. 🔹 Approach Used: Reverse Preorder (DFS) Steps followed: 1️⃣ Traverse the tree in reverse preorder → right → left 2️⃣ Maintain a prev pointer to track previously processed node 3️⃣ For each node: Set root->right = prev Set root->left = NULL Move prev = root 🔹 Key Idea: Process nodes in reverse order so we can build the linked list from back to front. 🔹 Time Complexity: O(n) 🔹 Space Complexity: O(h) 💻 Language: C++ Elegant example of modifying tree structure using DFS + pointer manipulation 🚀 #Day179 #365DaysOfCode #DSA #LeetCode #BinaryTree #DFS #Pointers #Cpp

🚀 Cracking Binary Tree Problems with Optimal Efficiency! I’m excited to share that I successfully solved the “Binary Tree Right Side View” problem on LeetCode using an optimized approach, achieving 0 ms runtime (beating 100% of C++ submissions) ⚡ 🔍 Problem Statement Given a binary tree, the task is to return the values of nodes visible when the tree is viewed from the right side, listed from top to bottom. 💡 My Approach Instead of using the commonly preferred BFS (Level Order Traversal), I implemented a Recursive DFS approach with optimization: ✔ Key Strategy: Right-first traversal (Root → Right → Left) ensures that rightmost nodes are prioritized. Level tracking technique is used to capture only the first node encountered at each depth. At each level, if it is the first visit, that node is added to the result vector. ⚙️ Complexity Analysis Time Complexity: O(N), where N is the number of nodes Space Complexity: O(H), where H is the height of the tree (recursion stack) 📊 Performance Results ⏱ Runtime: 0 ms (Beats 100% of C++ submissions) 💾 Memory: 14.86 MB (Beats 85.22% of submissions) 🧠 Key Takeaway Sometimes, a simple shift in traversal order combined with smart level tracking can replace complex logic and still deliver optimal performance. Consistency in solving DSA problems continues to sharpen my problem-solving intuition and coding efficiency. #LeetCode #DSA #Cplusplus #BinaryTree #Algorithms #ProblemSolving #CodingJourney #TechCommunity #SoftwareEngineering