Md Nafiul Adnan Chowdhury

Last week, I spent some time learning about random number generators and entropy pooling. Suppose you're in a Linux machine and you generate a random number in C++: std::random_device rd; std::uniform_int_distribution<int> dist(1, 10); dist(rd); But what does this do under the hood? std::random_device gives you a true random number and it pretty opaque. You don't really know exactly what it is, what it's going to do, or how efficient it will be. You don't even know if it can actually be acquired -- it might throw an exception when you attempt to create it. If you look at the libc++ code for std::random_device, it's just a thin wrapper over std::fopen("/dev/urandom"). So each time you create a std::random_device you are getting a filesystem handle and whenever you read from it, you are simply making a system call. When using GCC on Linux, std::random_device will try to use Intel's RDRAND instruction. RDRAND has a single entropy source and provides a stream of entropy data as zeros and ones. It is essentially a hardware circuit which jumps between 0 and 1 based on thermal noise fluctuations within the CPU. On Linux, the root of all randomness is something called the kernel entropy pool. This entropy pool is used in two ways: random numbers are generated from it and it is replenished with entropy by the kernel. When random numbers are generated from the pool the entropy of the pool is diminished, as the person receiving the random number has some information about the pool itself. You can even check a rough estimate of the number of bits of entropy in the pool with this command: cat /proc/sys/kernel/random/entropy_avail Hope this was useful, I might write a bit more in detail about this as I found it super intriguing!

94

7 Comments

I'm looking for a remote Windows low-level developer job. have large knowledge in windows internals, win32/NT api, both kernel(wdm) and user mode (primary), c++(old version), x64/x86, huge experiense in debugging, research, etc why all this not work ? exist multiple reasons: 1) my geolocation and remote position: most positions not accepted full remote work. but even if position is full remote - this is not mean everywhere. this is in concrete country or in short list of countries. It is almost impossible to break through this barrier. The company probably has to know you personally and be very interested in you in order to make an exception. 2) my resume. it does not correspond to any templates. it is simply an honest description of my knowledge and experience. such a resume is always simply thrown into the trash. if a few years ago there were still extremely rare reviews on it, now it is an absolute 0. 3) lack of previous jobs. that is, it is not enough to just have the necessary knowledge and experience. You need to have worked somewhere else before 4) there are very few positions in the area that interests me 5) my english is poor. 6) I have very deep knowledge and talent. but in a very narrow area. because of which I simply do not fit into most existing positions that are created for other people 7) I have a very unique coding style and knowledge base. This doesn't reduce my ability to write quality code, but it makes it very difficult to interact with other people who have a different style. 8) Probably 99% of those who see my statuses work in the cyber security field. I have never worked in this field and have no knowledge or experience in it. I don’t know why this happened. And in fact, all of my statuses are seen by the same people 10+ times already. It is obvious that if they can’t offer me anything right away, then after N times this will not change. How can I get into a more relevant circle for me or expand my audience, I don’t know probably the best opportunity for me is when team leaders/developers (not recruiters) post positions in their team here. but so far this has never worked either. they either don't answer or - can't hire a person from my country. recently my question, under status that is quite relevant to me (according to the description) was supported by 14 people, but it had no effect. no one answered me :) or I need a person inside the company who could talk to me, assess my real level, and if it is ok, influence the hiring process. it is clear that this is too much, but less not works and I can't create my own business, or teach, etc. because it doesn't match my skills and personality. I also have my own debugger and utilities. This is not an amateur fake, with minimal functionality, but a very powerful and useful product. But no one is interested. I also have some of my own solutions in the wndows MFA logon area, but again - no one needs it (or my knowledge, experience and capabilites in this area)

65

7 Comments

Post - 12 🌟 Working Concept in C Supporting CAPL Code 🌟 In one of my recent posts, I shared a CAPL example where I demonstrated how to read data from a file and feed it into a CAN signal. To better understand the working mechanism, here’s the equivalent implementation in C programming that conceptually supports that CAPL code. This C code showcases: 1️⃣ File Handling using fopen(), fread(), and fclose(). 2️⃣ Pointer and Memory Management with malloc() and free(). 3️⃣ File Pointer Manipulation through fseek() and ftell(). 4️⃣ Reading and Processing File Data in a structured and safe manner. Here’s the C code: #include <stdio.h> #include <stdlib.h> #include <string.h> int main() {   FILE *fp;   fp = fopen("file1.txt", "rb");   if (fp == NULL)   {     printf("There is problem with opening the file\n");   }   long int lp;   char *ptr;   fseek(fp, 0, SEEK_END); // Move the file pointer to the end of the file   lp = ftell(fp);     // Get the byte size of the file   fseek(fp, 0, SEEK_SET); // Move the file pointer to the start of the file   ptr = (char *)malloc(sizeof(lp) + 1); // Allocate memory for file content   ptr[lp + 1] = '\0';          // Add null terminator   fread(ptr, lp, 1, fp);        // Read the file content in one go   printf("%s", ptr);          // Print the file content   printf("\n");   printf("%ld\n", lp);         // Print the size of the file   fclose(fp);              // Close the file   free(ptr);              // Free allocated memory   ptr = NULL;   return 0; } Why This is Relevant This code demonstrates the underlying mechanisms used in CAPL: 🔹 CAPL’s openFileRead() is conceptually like fopen() in C. 🔹 CAPL’s fileGetString() resembles fread(). 🔹 CAPL’s fileRewind() matches the use of fseek() and rewind() to reset the file pointer. 🔹 CAPL’s dynamic file reading and signal updates are modeled by reading and printing file content in C. Conclusion Understanding the C concepts behind CAPL helps bridge the gap between high-level automotive scripting and low-level system programming, making debugging and optimization much more intuitive! 🚗💻 Let me know your thoughts and how you approach such integrations in your projects!

24

Linux kernel important core component of operating systems which helps manage software and hardware on computer . To modify the kernel you need its source code . See my below article which is explained with practical example. Check out!!! Balemarthy Vamsi Krishna

9

Do yourself a favor: • Open your laptop • Open YouTube • Type Docker crash course • Start learning • Learn DevOps Step-by-step • Ask questions to ChatGPT • Build projects • Push code to GitHub • Share your progress on Threads Procedure is easy. Being consistent is hard.

2

If you want to write low-level code that works super-fast, the best way is C++. Understanding networking and socket programming is something that only skilled software developers typically learn. Multithreading and I/O Multiplexing are topics that even many experienced software engineers are unfamiliar with, but these are the concepts that will help you write production-grade software. And you can learn all of this in just 6 weekends, starting 𝐭𝐨𝐝𝐚𝐲. Amit is one of the most skilled software engineers I know, with over a decade of experience working with C++ (a lot of it related to networking). He is the only other teacher I trust for Educosys because he is that good. His last course, Advanced C++, received awesome feedback. You can check out the testimonials on the site. This is the final reminder that our LIVE Advanced C++ Course with Networking starts today at 2 PM. This will be the only and last batch of the year. If you're interested, check out the details here: https://lnkd.in/gQnF64-N

1,002

25 Comments

I would argue most Data Scientists should also be aware of the Big(O) notation. This is a critical aspect of programming that could mean the difference between your notebook finishing in five minutes vs five days.

11

Amazon, Microsoft, Adobe, and more companies are known to ask this coding interview question because it tests the fundamentals by forcing you to think about:  1. String manipulation 2. 2-pointers 3. Out of the box edge cases All at the same time! I explain it all in this video on Leetode 5 - Longest Palindromic Substring. Out now! https://lnkd.in/gHnpues9

2

1 Comment

Linux - read documentation with attention: resources of the finished thread created with pthread_create() will not be released unless it is joined or detached. Kind of unexpected source of significant memory leaks.

8

1 Comment

🚀 DYK 3 - Preemptive Schedulers - A Tour of the BEAM (Elixir, Gleam, Erlang) on Fault-Tolerance, Concurrency, Distribution and Scalability Do you Know that the BEAM VM has the concept of lightweight BEAM processes (not OS processes) that can only communicate with each other through asynchronous message passing in a share-nothing approach. They run concurrently and completely isolated from each other, with their own memory space and garbage collection. To make this work, the BEAM VM starts one OS thread per core, which becomes a BEAM scheduler with a processing queue to run all the BEAM processes concurrently. The scheduler gives a slice of time for each process to execute, and when this time elapses, the process goes back to the queue and waits for its turn to execute again. This repeats as many times as needed for the process to complete its task without blocking others indefinitely, preventing one process from monopolizing available resources, memory, CPU, and I/O. This is called pre-emptive scheduling and is the reason why the BEAM can run under very high loads without crumbling. A resource-heavy process or a process running code that crashes only operates for a tiny amount of time without significantly affecting the execution time of other processes. The BEAM achieves concurrency by having each pre-emptive BEAM scheduler run a process at a time from its queue, as many times as needed for the process to complete its task. Parallelism is achieved by running the same BEAM processes simultaneously in more than one BEAM scheduler, which means they are running on different cores. To recap, BEAM processes can run concurrently in one BEAM scheduler and at the same time in parallel in other BEAM schedulers. The BEAM VM manages all of this for you by load balancing processes across the schedulers and reassigning them to another scheduler when a queue becomes too large. Finally, one or several processes crashing due to a bug in the code or some other reason won't take the BEAM VM down. They are just restarted by the supervisor up to a certain number of times and then disposed of if they don't recover. This is called the "Let it Crash" philosophy in the BEAM, which we will discuss in more detail another day. Also, for another day, we will explore the few ways one can crash the very robust and resilient BEAM VM. As Joe Armstrong, the creator of Erlang, used to say: "The BEAM runs forever while *** runs everywhere". ✅ Follow me to continue to see more like this on your feed 😀 📢 Let's spread the knowlodge about the BEAM. Like and repost to also reach your network. 👉 Leave your thoughts and questions in the comments below 👇

10

5 Comments

🔍 Understanding Memory Management: Smart Pointers in C++ vs. Ownership in Rust In the world of programming, efficient memory management is crucial for building reliable and performant applications. Two languages with different approaches to handling memory are C++ and Rust. Let’s take a closer look at how they tackle this challenge: 🧩 C++ Smart Pointers: In C++, smart pointers like std::unique_ptr and std::shared_ptr help manage resource ownership and ensure automatic cleanup: Exclusive Ownership: std::unique_ptr enforces single ownership, similar to Rust’s ownership model, ensuring resources are properly deallocated. Shared Ownership: std::shared_ptr allows multiple pointers to share ownership of a resource, with the resource being freed only when the last owner is gone. RAII Principle: Both types of smart pointers use RAII (Resource Acquisition Is Initialization) to ensure that resources are cleaned up when the smart pointer goes out of scope. 🦀 Rust Ownership: Rust introduces a robust ownership system that emphasizes safety and concurrency: Single Ownership: Each resource in Rust has a single owner, enforced at compile time, preventing data races and memory leaks. Borrowing & Lifetimes: Rust’s borrowing system allows for immutable (&T) and mutable (&mut T) references, with strict rules to prevent dangling pointers and ensure safe access. Compiler-Driven Safety: Rust’s ownership model includes strict compile-time checks, making it easier to write safe concurrent code without fear of common memory issues. 🔄 Comparison: While C++ smart pointers offer automated resource management and can prevent memory leaks, they do not provide the same level of safety guarantees as Rust's ownership system. Rust’s approach enforces memory safety and concurrency guarantees at the language level, ensuring fewer runtime errors and safer code. Understanding these differences helps in choosing the right tool for the job. Whether you’re working with C++ or exploring Rust, both approaches offer powerful mechanisms to handle memory management effectively. 💬 What’s your experience with memory management in C++ or Rust? Share your thoughts and insights! #CPlusPlus #Rust #Programming #MemoryManagement #Tech #SoftwareEngineering

75

12 Comments

Added to the Github Star Leaderboard changes in standings in the past month: Leaderboard features top 1000 public github repos, based on the number of stars https://lnkd.in/guYaJaDe Packages from this list that I use Each row is: Place, change in standing, package, number of stars - 10, 0, React by Facebook, 226k - 19, 0, Linux, 176k - 21, 0, ohmyzsh, 171k - 22, 0, Bootstrap, 169k - 26, 0, VSCode by Microsoft, 161k - 35, 0, Transformers by Hugging Face, 130k - 38, 0, Next.JS by Vercel, 124k - 41, 0, React Native by Facebook, 117k - 52, 0, create-react-app by Facebook, 102k - 54, 0, TypeScript by Microsoft, 99k - 61, 0, Material-UI, 92k - 81, -1, PyTorch, 81k - 82, -3, TailwindCSS, 81k - 95, -1, OpenCV, 77k - 103, +2, FastAPI by Sebastián Ramírez Montaño, 74k - 182, +1, scikit-learn, 59k - 236, 0, Git, 51k - 248, 0, Traefik by Traefik Labs, 49k - 256, -4, Prettier, 48k - 338, -3, Pandas, 42k - 360, -8, Yarn, 41k - 461, -5, Vim, 35k - 509, -2, Tmux, 34k - 6701, -3, pytorch-image-models by Ross Wightman, 31k - 645, +33, Ruff by Astral, 29k - 760, -5, pytorch-lighning by Lightning AI, 27k - 782, -7, NumPy, 27k - 945, -10, Eslint, 24k - 1000, -19, Ngrok, 24k ---- GitHub star leaderboard looks very stable. Only Ruff stands out. P.S. Pydantic by Samuel Colvin and Albumentations do not have enough stars to get to the top 1000.

21

16 Comments

CP experts your help Needed! Le: CF casually teaching me that same time complexity notation doesn't result in the same runtime 😕 Link to the problem :- https://lnkd.in/dqgDCnFb Idea to the solution: Iterate through each university one by one and calculate its contribution (cumulative strength) to every k from 1 to n. (observation: if the students in University are x ,it can only contribute to k from 1 to x.) Implementation 1: https://lnkd.in/dmUH-yRs -> Used an ordered map (int to vector<int>) to store universities and their corresponding student's strength. Complexity: O(nlogn) -> sorted all university vectors in reverse order [O(nlogn)] -> maintained suffix sum array( prefix sum array can also be maintained with sorting in no decreasing order) to calculate contribution for any university for any k [O(n)] ->Then Iterated through each vector and for every k i calculated the contribution in O(1) time for 1≤k≤n [O(n)] Total Time complexity: O(nlogn) result : TLE Implementation 2: https://lnkd.in/d336dfNg -> Rather than using a map stored in uni and students as a pair in a vector v. [O(n)] -> Sorted the vector v with help of custom comparator fn ,such that it maintains ranges of students of same universities one by one in a decreasing fashion. (O(nlogn) -> then constructed the prefix sum subArrays this time in the vector v for every university O(n) -> Now again Iterated through v for every university and calculated its contribution for every k O(n) total time complexity: O(nlogn) result: accepted (249ms) My idea is that the second approach doesn't use a map and it saves time but still I'm not quite sure about why the first one gave TLE. Summoning all cp enthusiasts and experts to help me to figure out what could be the exact reason that the first code didn't get ac but second one did? tagging some cp gods for help : Pranav Mehta (snippet v sir ka hi hai 😉) Aryan C. Badal Kumar Kartik Singh Kushwah #codeforces #cp

131

5 Comments

the TRUTH about C++ (is it worth your time?) ============================== C++ gets a lot of hate on the internet, and there may be good reason for that. I think C++ is misunderstood, and there are a few simple reasons why. Despite being designed around 3 simple principles, the language has inflated to have a ton of features that are either too complicated to understand, or too powerful to implement without making your code base unmanageable. But, should you learn C++? Yes. There are a few caveats though. https://lnkd.in/dw-24J5m

33

10 Comments

Today's LeetCode POTD "Subsets". Code Execution Process : 1. Importing Combinations: "from itertools import combinations" - Import the combinations function from the itertools module to generate all possible combinations of elements in the list. 2. Initialize List: "l = []" Initialize an empty list "l" to store all combinations. 3. Loop Through Lengths: "for i in range(len(nums)+1)": - Loop through all possible lengths of combinations, from 0 to the length of "nums". 4. Generate Combinations: "res = map(list, combinations(nums, i))" - Generate all combinations of "nums" of length "i" and convert each combination to a list. 5. Extend Result List: "l.extend(res)" - Add the generated combinations to the list "l". #leetcode #potd #subsets #programming #python #problemsolving #coding #codingchallenge #dsa #problemsolvingskills #codeexplanation #dailycode #consistency #problem #code #tech

12

Why the White House Wants Safer Code: Moving from C/C++ to Rust by 2026 The White House recently urged organizations working on critical software to switch from C/C++ to memory-safe languages like Rust by 2026. The reason? Memory issues in C/C++ lead to vulnerabilities that hackers can exploit, putting critical systems at risk. While this isn’t a hard deadline, it’s a strong recommendation to improve security in software that supports essential infrastructure. Languages like Rust, designed to avoid memory errors, can significantly reduce these risks. Reference Link: https://lnkd.in/gMhudrCa #Cybersecurity #MemorySafe #Rust #Programming

9