Stanislav Kirichenko’s Post

The 𝗰𝗼𝗺𝗺𝗮𝗻𝗱 𝗽𝗮𝘁𝘁𝗲𝗿𝗻 is useful 𝗳𝗼𝗿 𝗺𝘂𝗹𝘁𝗶𝘁𝗵𝗿𝗲𝗮𝗱 𝗰𝗼𝗺𝗺𝘂𝗻𝗶𝗰𝗮𝘁𝗶𝗼𝗻. The pattern has many variants, including templates, unions, polymorphism or std::variant, type erasure etc... Every problem requires a different specific solution, thus a different implementation. This version of the 𝗖𝗼𝗺𝗺𝗮𝗻𝗱 𝗽𝗮𝘁𝘁𝗲𝗿𝗻 with virtual functions, simplest form to implement. This pattern is perfect to pair with a 𝗹𝗼𝗰𝗸-𝗳𝗿𝗲𝗲 𝗿𝗶𝗻𝗴 𝗯𝘂𝗳𝗳𝗲𝗿 or 𝗾𝘂𝗲𝘂𝗲, one way communication between threads, The command pattern AFAIK is also heavily used in Job/Task systems. If you think about it, if we could move the ownership of everything from a thread to another one, would this make multithreading easier to write? Save this post and give it a try! #programming #coding #C++

The 𝗰𝗼𝗺𝗺𝗮𝗻𝗱 𝗽𝗮𝘁𝘁𝗲𝗿𝗻 is useful 𝗳𝗼𝗿 𝗺𝘂𝗹𝘁𝗶𝘁𝗵𝗿𝗲𝗮𝗱 𝗰𝗼𝗺𝗺𝘂𝗻𝗶𝗰𝗮𝘁𝗶𝗼𝗻 and more. This version of the 𝗖𝗼𝗺𝗺𝗮𝗻𝗱 𝗽𝗮𝘁𝘁𝗲𝗿𝗻 uses 𝘀𝘁𝗱::𝘃𝗮𝗿𝗶𝗮𝗻𝘁 for a more elegant and modern approach, decoupling the command data from it's execution logic. The pattern has many variants, including templates, unions, polymorphism or std::variant, type erasure etc... Every problem requires a different specific solution, thus a different implementation. This pattern is perfect to pair with a 𝗹𝗼𝗰𝗸-𝗳𝗿𝗲𝗲 𝗿𝗶𝗻𝗴 𝗯𝘂𝗳𝗳𝗲𝗿 or 𝗾𝘂𝗲𝘂𝗲, one way communication between threads, The command pattern AFAIK is also heavily used in Job/Task systems. If you think about it, if we could move the ownership of everything from a thread to another one, would this make multithreading easier to write? Save this post and give it a try! #programming #coding #C++

Before the compiler ever sees your C++ code, it goes through an important step called preprocessing. The preprocessor runs first and performs text-based transformations such as: • Expanding #include directives • Handling macros defined using #define • Enabling or disabling code using conditional compilation (#ifdef, #ifndef, #if 0) • Removing comments and preparing the code for compilation The result of this step is a translation unit, which is what the compiler actually compiles. Understanding the preprocessor helps demystify: • How header files really work • Why macros behave differently from variables and functions • How compile-time configuration is achieved in C++ 📘 I’ve written a beginner-friendly article over Substack explaining the C/C++ preprocessor in detail, with examples and practical insights. I have attatched link for article in comment. #CPP #Preprocessor #Macros #Programming

Function Pointers & Callbacks in C – The Backbone of Real Embedded Systems 🎥 — Subscribe to my YouTube channel: https://lnkd.in/dGdNRGkU 📷 Follow me on Instagram for tech updates: https://lnkd.in/duzREQhG Most beginners see function pointers as “advanced C syntax.” In real embedded firmware, they are everywhere — drivers, ISRs, schedulers, state machines, and communication stacks. Function pointers allow code to decouple logic, switch behavior at runtime, and build scalable, reusable architectures. Callbacks take this one step further by letting hardware or frameworks notify your application instead of hard-coding control flow. If you truly want to move from writing C code to designing firmware, mastering function pointers and callbacks is non-negotiable. #EmbeddedSystems #EmbeddedC #FirmwareEngineering #FunctionPointers #Callbacks #CProgramming #BareMetal #RTOS #LowLevelProgramming #EngineeringLife

🔒 Thread Synchronization in OS: Mutex, Semaphore, and Beyond 🔒 Multithreading boosts performance but risks race conditions & deadlocks. Dive into mutex (exclusive locks), semaphores (counting access), condition variables, RW locks, & lock-free atomics! Real examples, pitfalls, best practices + future trends like HTM. Perfect for devs mastering multithreading in OS. Read full 1000-word guide: https://lnkd.in/gKbVu4mw #OperatingSystems #Threading #Concurrency #Programming #TechTutorial #analyticsjobs

Leetcode potd : Construct the Minimum Bitwise Array II Goal - minimize values of ans[i] such that , ans[i] or ans[i+1] == nums[i] 💭 My thought process I initially started with a brute-force approach, where I tried all possible values of x for each nums[i]. But as the constraints are large, this approach quickly leads to TLE. ⚡ Optimization: So I shifted focus to observing the bitwise behavior of: x | (x + 1) After analyzing it in binary, one key pattern stood out: For any nums[i], once we find the first 0 bit from the right, We can flip the last 1 just before it, And keep the remaining bits unchanged. This directly gives the minimum possible value of ans[i] that satisfies the condition, without trying all possibilities. #problem_solving #bit_manipulation #leetcode #programming #coding

Rust 1.93 is out. Highlights: - The deref_nullptr lint is now deny-by-default, and asm_cfg has been stabilized. - Stabilized String::into_raw_parts and Vec::into_raw_parts, alongside expanded MaybeUninit methods. - Removed internal Copy trait specialization to resolve unsafe lifetime dependencies. - cargo clean now fully supports the --workspace flag. #rustlang #software #programming

Algorithm Challenge – Level 3 | #27 | Character Case Inversion In Algorithm Challenge #27 (Level 3), I implemented a C++ program that inverts the case of a single character — converting uppercase letters to lowercase and vice versa. While the implementation is concise, the engineering value lies deeper. This challenge reinforces a fundamental software principle: Every complex system is built on precise, low-level decisions. At the character level, software must: ✔ Classify input accurately ✔ Apply deterministic rules ✔ Avoid ambiguity in transformation ✔ Guarantee predictable output This type of logic appears everywhere: Lexical analysis in compilers Input validation and sanitization Text processing engines Security and encoding systems The real lesson here is not about changing letter case, it’s about designing clear decision paths and respecting data boundaries. Strong software engineers don’t skip the fundamentals. They master them. Full implementation available on GitHub: 👉 https://lnkd.in/dyy5bf5W Think clearly. Decide precisely. Build reliably. 💻🚀 🏷️ Hashtags #AlgorithmChallenge #SoftwareEngineering #Cpp #Algorithms #ProblemSolving #EngineeringThinking #CleanCode #ComputerScience #Programming #LowLevelProgramming #DeveloperJourney #Tech

Easy communication between threads? I present you the 𝗗𝗮𝘁𝗮 𝗼𝗿𝗶𝗲𝗻𝘁𝗲𝗱 𝗰𝗼𝗺𝗺𝗮𝗻𝗱 𝗽𝗮𝘁𝘁𝗲𝗿𝗻 𝗳𝗼𝗿 𝗺𝘂𝗹𝘁𝗶𝘁𝗵𝗿𝗲𝗮𝗱 𝘀𝗶𝗻𝗴𝗹𝗲-𝗽𝗿𝗼𝗱𝘂𝗰𝗲𝗿-𝘀𝗶𝗻𝗴𝗹𝗲-𝗰𝗼𝗻𝘀𝘂𝗺𝗲𝗿 𝗰𝗼𝗺𝗺𝘂𝗻𝗶𝗰𝗮𝘁𝗶𝗼𝗻. The pattern can be implemented in all low level languages from C, modern C++, Rust, Zig, using templates, unions, polymorphism or std::variant, type erasure etc...  Every problem requires a different specific solution, thus a different implementation. My version compared to the standard 𝗖𝗼𝗺𝗺𝗮𝗻𝗱 𝗽𝗮𝘁𝘁𝗲𝗿𝗻 with virtual functions, it eliminates the overhead of the 𝗩𝗧𝗮𝗯𝗹𝗲 𝗱𝗶𝘀𝗽𝗮𝘁𝗰𝗵, where if the vtable is not already in cache you hit a 𝗰𝗮𝗰𝗵𝗲 𝗺𝗶𝘀𝘀, losing many precious clock cycles, (bad for RTOS or real time renderers). This pattern is perfect to pair with a 𝗹𝗼𝗰𝗸-𝗳𝗿𝗲𝗲 𝗿𝗶𝗻𝗴 𝗯𝘂𝗳𝗳𝗲𝗿 or 𝗾𝘂𝗲𝘂𝗲, one way communication between threads, The command pattern AFAIK is also heavily used in Job/Task systems. I've personally used it in my 𝗩𝘂𝗹𝗸𝗮𝗻 𝗿𝗲𝗻𝗱𝗲𝗿𝗲𝗿 on a dedicated thread, no locks, no mutex, no race conditions, it makes the coding experience easier. Of course there are also drawbacks compared, more boiler plate code, or heavy use of templates to make it more generalized, make a struct for each new command type, etc... It helped me gain 𝗮𝘁 𝗹𝗲𝗮𝘀𝘁 𝟱𝟬𝟬𝗳𝗽𝘀 to switch to another thread without too much hassle. If you think about it, if we could move the ownership of everything from a thread to another one, would this make multithreading easier to write? Save this post and give it a try! #programming #coding #C++

The 𝗰𝗼𝗺𝗺𝗮𝗻𝗱 𝗽𝗮𝘁𝘁𝗲𝗿𝗻 is useful 𝗳𝗼𝗿 𝗺𝘂𝗹𝘁𝗶𝘁𝗵𝗿𝗲𝗮𝗱 𝗰𝗼𝗺𝗺𝘂𝗻𝗶𝗰𝗮𝘁𝗶𝗼𝗻. The pattern has many variants, including templates, unions, polymorphism or std::variant, type erasure etc... Every problem requires a different specific solution, thus a different implementation. This version of the 𝗖𝗼𝗺𝗺𝗮𝗻𝗱 𝗽𝗮𝘁𝘁𝗲𝗿𝗻 uses a function pointer, simplest form to implement in C. This pattern is perfect to pair with a 𝗹𝗼𝗰𝗸-𝗳𝗿𝗲𝗲 𝗿𝗶𝗻𝗴 𝗯𝘂𝗳𝗳𝗲𝗿 or 𝗾𝘂𝗲𝘂𝗲, one way communication between threads, The command pattern AFAIK is also heavily used in Job/Task systems. If you think about it, if we could move the ownership of everything from a thread to another one, would this make multithreading easier to write? Save this post and give it a try! #programming #code #C++