Radu Viorel Cosnita’s Post

🐭🌐 Successfully completed the Rat in a Maze - Backtracking approach using C and C++ with visualization! 🚀💻 #Algorithms #Backtracking #ProgrammingSuccess

Hey Connections !! 🔍 New Blog Alert! Exploring C++ STL Iterators 🔍 I'm excited to share my latest blog post on C++ STL Iterators. 📜✨ In my previous blog, we dove deep into the world of C++ STL Containers, uncovering their unique functionalities and use cases. Now, we're taking it a step further by exploring the magic of C++ STL Iterators. In this post, we'll learn: 🔹 The various types of iterators and their applications. 🔹 How to traverse and manipulate container elements efficiently. 🔹 Operation Supported by Iterators Stay ahead in your C++ journey and master the tools that make coding seamless and efficient. Happy reading! 🚀 #C++ #STL #Iterators #Coding #Programming #TechBlog #LearnAndGrow #SoftwareEngineering Check it out here: https://lnkd.in/d3hgzR9e 4o

Implementation of the Raft Consensus Algorithm Using C++20 Coroutines

What? 🤣 online debugging a C program? It works though I tried to build a C program that did a divide by zero and got it to crash during the debug session.

How is Zig seriously great? quick sell for the non-zigmas: - insane comptime features - inline/unroll at comptime out of the box - vectorization / simd support out the box - no C gotchas/footguns - you can dynamically link to it from any C ABI compatible language - amazing error management - the build system is 10000x better than cmake (and you can/should use it in c and cpp projects regardless of zig) - zig's compiler is also a C and C++ compiler - simpler than C - amazing build system (built in Zig) - there is no system language I have found where you can read the code top to bottom and everything that will actually happen is written right there. There is no magic, no hidden control flow, it is the closest to being able to know exactly what the machine will end up doing https://lnkd.in/gYNeXgXT

Compilation: Translation to Assembly: The compiler translates the preprocessed C code into assembly language, a low-level language that corresponds to machine instructions. Stages within this phase: Lexical Analysis: Breaks down the code into tokens (e.g., keywords, variables, operators). Syntax Analysis: Checks the code for correct structure and grammar. Semantic Analysis: Ensures logical correctness (e.g., type-checking). Intermediate Code Generation: Produces intermediate code that is simpler than C but independent of the hardware. Optimization: The intermediate code may be optimized for better performance. Output: Assembly code (.s file). Command to run: gcc -S file.i -o file.s #c #compiler #programming #ccode #embeddedc #embeddedsystem #assembly #syntax

An easy-to-use and fast library for task-based parallelism, utilizing coroutines. Coros is a header-only C++23 library designed for task-based parallelism, that utilizes coroutines and the new expected type #CPlusPlus #ParallelProgramming #TaskBasedParallelism #Coroutines #C23 #ConcurrentProgramming #HighPerformanceComputing #Multithreading #AsyncProgramming #SystemProgramming https://lnkd.in/gSEH7vWp

Hey Connections !! 🚀 Unlock the Power of C++ STL Algorithms! 🚀 In my latest blog, "C++ STL - Algorithms: One Shot", I dive deep into the versatile world of algorithms in the C++ Standard Library. If you’ve been following my journey, you’ll know we recently explored the fundamentals of iterators. Now, it's time to take that knowledge to the next level! 🔍 What You’ll Learn: 1. The core algorithms that make STL so powerful 2. Practical examples of these algorithms to optimize your code 3. Tips and tricks to leverage STL algorithms for efficient problem-solving Whether you’re aiming to boost your C++ skills or looking to refine your coding techniques, this blog is your next step. Dive in and discover how STL algorithms can transform your development process! 💡 👉 Check out the blog here: https://lnkd.in/dZtBqGdr Feel free to share your thoughts and questions in the comments! #CPlusPlus #STL #Algorithms #Coding #SoftwareEngineering #TechBlog

After spending some time experimenting with Rust's FFI, I thought I'd write a short article on getting started with it, pointing to some useful resources and tools. The Rust FFI (Foreign-Function Interface) provides a way for Rust code to natively "talk" to C code and C APIs / libraries. This makes it possible to use Rust in existing C projects and allows for communicating directly with existing OS APIs (e.g., POSIX, WinAPI). This involves using types provided in the standard library (std::ffi) or core::ffi when using no_std on bare metal. To call C code from Rust, a function definition must be provided within an `extern "C"` block, similar to the signature of the actual C function. This function signature will be written in Rust but must use types provided by the FFI instead of Rust's native types (e.g., c_int over i32). To call Rust code from C, a Rust function must be defined as `pub extern "C"` and must use C types in its signature. The #[no_mangle] annotation must also be used to ensure the Rust compiler doesn't change the function name during compilation. For more details, see https://lnkd.in/gHqQNgMj Note that interoperating with external code requires using an `unsafe` block as the compiler cannot provide safety guarantees for non-Rust code. I believe the FFI should be seen as a tool to help transition to Rust, rather than an excuse not to use it when it eventually makes life difficult :) Rust does have a steeper learning curve than C, but its benefits are well worth the investment. The Rust embedded book is a great place to learn more about the FFI and dealing with no_std: https://lnkd.in/gG-sdAdh * Some useful resources: 1. libc: Provides an interface to the C standard library for the FFI and can work in no_std environments. https://lnkd.in/g3jXYzBt 2. nix: A higher-level wrapper around libc for *nix systems, providing a safer abstraction. https://lnkd.in/gk3Cha_t 3. cc-rs: A build-stage tool that makes it easy to include C files within Rust's build process by communicating with the platform's C compiler. https://lnkd.in/gy9PxG2z 4. rust-bindgen: A tool to automatically generate FFI bindings from a C header file. https://lnkd.in/gP8hX9vF --- The next thing I want to do is experiment with the embedded-hal, to learn how to use Rust to communicate directly with embedded hardware. https://lnkd.in/gnV4e-sW #rust #embeddedsystems

If you remember the kbhit() function from Borland Trubo C (or C++), I recreate it today's #cprogramming Lesson. The goal is to check for pending keyboard (standard) input without reading a character. https://lnkd.in/guq_-Vws