Shahin Mahmud

Hi folks, more about pointers in C which are undeniably powerful, but they can also be tricky for even seasoned developers. 🤯 Avoid common pitfalls and write safer, more robust code with these tips: 1️⃣ Understand Scope & Lifetime: 🤔    - A pointer's value is only valid as long as the memory it points to exists. Keep track of object lifetimes to prevent dangling pointers (pointing to  freed memory!) leading to crashes. 2️⃣ Null Pointers Are Your Friends: ✅    - Always initialize pointers to `NULL` when not pointing to a specific location. Check for `NULL` before dereferencing to avoid segmentation faults.  "Null checks are your safety net!"  3️⃣ Beware of Dangling Pointers: 💀   - When memory is freed, the pointer becomes invalid. Reusing it can lead to unpredictable behavior. Double-check deallocation and pointer usage. 4️⃣ Pass by Reference with Care: ⚠️   - Be mindful when passing pointers as arguments. Modifying a passed pointer might unintentionally change original data. Use const qualifiers for  safety. 5️⃣ Deep Dive into Documentation: 📚   - C libraries often have complex pointer interactions. Consult documentation thoroughly to understand how memory management works for specific  functions and structures. What's your biggest pointers challenge? Share in the comments! Let's learn from each other's experiences. 👇 #CProgramming #SoftwareDevelopment #MemoryManagement #Pointers

৬০

৪ মন্তব্যসমূহ

⛓ **Day 165: Nodes Between Critical Points** ⛓ **Understanding the Problem:** Given a linked list, identify the critical points where the node's value is either a local minimum or a local maximum. We need to find the minimum and maximum distance between any two critical points. **Approach:** To solve this problem, we traverse the linked list while checking for critical points (local minima or maxima). We record the positions of these critical points and calculate the minimum and maximum distances between them. **Implementation:** 1. **Traverse the List:**   - Iterate through the linked list while comparing each node with its previous and next nodes to identify critical points. 2. **Record Positions:**   - Keep track of the positions of the first and last critical points, as well as the previous critical point to calculate distances. 3. **Calculate Distances:**   - Calculate the minimum distance between consecutive critical points.   - Calculate the maximum distance between the first and last critical points. **Steps:** 1. Initialize variables to store the positions of the first, last, and previous critical points. 2. Traverse the list and identify critical points by comparing each node with its neighbors. 3. Update the positions and calculate distances accordingly. 4. Return the minimum and maximum distances. **Complexity Analysis:** - Time Complexity: O(N), where N is the number of nodes in the linked list, as we traverse the list once. - Space Complexity: O(1), as we are using a constant amount of extra space. This approach efficiently identifies critical points and calculates the required distances between them. #LinkedList #CriticalPoints #DSADay165 #AlgorithmInsights

২

১ মন্তব্য

- Open your laptop - Open YouTube - Learn Linux, Networking, Python - Practice Practice Practice - Learn Git - Take help from ChatGPT - Learn Cloud Computing - Practice Practice Practice - Build project and make them public

১,০২৮

৪৯ মন্তব্যসমূহ

If you recently joined a company as a frontend developer, then this is for you. Irrespective of the task level you got assigned, attach an image or Jam.dev of your work to the PR. Why? Even though it might sound like a trivial change to you, it might not be for the person reviewing. If visual feedback is missing in the PR, then the person has to checkout the branch and review it. This adds a lot of friction and slows down the review process. Of course, some good companies can raise live preview for each PR which makes this process easier but still they have to navigate to the respective page or component. Just attach an image or Jam.dev to your PRs and reduce the friction. Trust me, everyone on the team will appreciate this effort. Once you better understand the product, you might be okay with not doing such PRs and sticking to more text-based ones. Here is a nice example of such PR raised by Anmol Bhatia from the Plane team: https://lnkd.in/g_ngsf5R #betterreviews #pr #github

২৫

৩ মন্তব্যসমূহ

- Fundamentals of backend engineering - Backend communication design patterns - Understand how backend communication protocols work - Comprehend how OS Kernel communicate with Backend Applications - OS fundamentals (Thread, Process, Async IO in Linux) - HTTP/1.1, HTTP/2, HTTP/3 - gRPC, WebRTC, WebSockets - TLS 1.2, TLS 1.3, QUIC 0RTT - The idempotency topic in this course really triggered me. 😔

১

Left: Setup Database, Traces, Metrics, Circuit Breaker, Dashboard...etc Right: Use gofr.dev and focus on business logic https://lnkd.in/g3bviaah #gofr #go #golang #productivity #startup #olympic

৭৭

৫ মন্তব্যসমূহ

📣 Secure System Design Essentials: A quick reference guide 🔒 #systemdesign #coding #interviewtips

১

Why is Kafka fast? There are many design decisions that contributed to Kafka’s performance. In this post, we’ll focus on two. We think these two carried the most weight. 1️. The first one is Kafka’s reliance on Sequential I/O. 2️. The second design choice that gives Kafka its performance advantage is its focus on efficiency: zero copy principle.   The diagram below illustrates how the data is transmitted between producer and consumer, and what zero-copy means.   🔹Step 1.1 - 1.3: Producer writes data to the disk    🔹Step 2: Consumer reads data without zero-copy 2.1: The data is loaded from disk to OS cache 2.2 The data is copied from OS cache to Kafka application 2.3 Kafka application copies the data into the socket buffer  2.4 The data is copied from socket buffer to network card 2.5 The network card sends data out to the consumer   🔹Step 3: Consumer reads data with zero-copy 3.1: The data is loaded from disk to OS cache 3.2 OS cache directly copies the data to the network card via sendfile() command 3.3 The network card sends data out to the consumer   Zero copy is a shortcut to save multiple data copies between the application context and kernel context. – Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages): https://bit.ly/3KCnWXq #systemdesign #coding #interviewtips .

১,৯৮৮

১১ মন্তব্যসমূহ

Why is Kafka fast? There are many design decisions that contributed to Kafka’s performance. In this post, we’ll focus on two. We think these two carried the most weight. 1️. The first one is Kafka’s reliance on Sequential I/O.   2️. The second design choice that gives Kafka its performance advantage is its focus on efficiency: zero copy principle.   The diagram below illustrates how the data is transmitted between producer and consumer, and what zero-copy means.   🔹Step 1.1 - 1.3: Producer writes data to the disk    🔹Step 2: Consumer reads data without zero-copy 2.1: The data is loaded from disk to OS cache 2.2 The data is copied from OS cache to Kafka application 2.3 Kafka application copies the data into the socket buffer  2.4 The data is copied from socket buffer to network card 2.5 The network card sends data out to the consumer   🔹Step 3: Consumer reads data with zero-copy 3.1: The data is loaded from disk to OS cache 3.2 OS cache directly copies the data to the network card via sendfile() command 3.3 The network card sends data out to the consumer   Zero copy is a shortcut to save multiple data copies between the application context and kernel context. --  Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages): https://bit.ly/3KCnWXq #systemdesign #coding #interviewtips  .

২,৬০৬

৪০ মন্তব্যসমূহ

Just released version 0.4.6 of Shuk - my command line file sharing utility. 🎉 🦀 New features: - If a file has already been uploaded, it will only pre-sign it instead of re-uploading. - Added a lot of debug options for better troubleshooting To install it: cargo install shuk https://lnkd.in/gXybw-Qd

৪৪

৬ মন্তব্যসমূহ

Learn everything you need to know about ZKPs for free with Matter Labs 👇 Zero-Knowledge Proofs (ZKPs) are revolutionizing the landscape of cryptography and privacy. Dive into the essentials with this curated list by Matter Labs, a leading name in the ZKP space. Highlights: General Introduction: Start your journey with primers, whiteboard sessions, and hands-on tutorials. Courses: Learn from the best with courses from institutions like UIUC and MIT. Applications in Blockchain: Explore ZKP applications in Ethereum, Zcash, Monero, and more. Comparison of ZKP Systems: Understand the nuances between SNARKs, STARKs, and Bulletproofs. Implementation Guides: Get practical with implementation resources in various programming languages. Prover Scaling: Discover distributed proof systems like DIZK and SnarkyGPU. Innovative Proof Systems: Dive into the latest advancements such as PLONK, Marlin, and SuperSonic. For a more comprehensive dive, check out https://lnkd.in/eJ4J7wGh Stay ahead in cryptography with Matter Labs’ curated resources!

৭২

২ মন্তব্যসমূহ

AI21Labs just released Jamba 1.5 Mini & Large - MoE, permissively licensed, 256K context, Multilingual, JSON model & Tool use 🔥 > Jamba 1.5 Large - (94B active, 398B total) > Jamba 1.5 Mini - (12B active/ 52B total) > Arena Hard: Large (65.4), Mini (46.1) > MMLU: large (81.2), Mini (69.7) > Architecture: Joint Attention with Mamba + Mixture of Experts > Context length: 256K > Languages supported: English, Spanish, French, Portuguese, Italian, Dutch, German, Arabic and Hebrew > Permissive license for orgs < 50M USD in revenue > Upto 2.5x faster inference with models comparable in size > Allows for tool use & feedback > Supports grounded generation for taking in a list of documents > Comes with an explict JSON mode > Integrated with Transformers 🤗 > Introduce a new ExpertInt8 quantization to quantize 85% of the MoE in int8 > Finetune with Transformers + Axolotl + FSDP on a single H100 node Congrats AI21 Labs for such a brilliant open release and sharing this with us! 🐐

২৩২

৫ মন্তব্যসমূহ

Implementing Post Caching for Lightning-Fast Loading 🔍 The Problem: In my social media app, users were experiencing long delays when navigating between posts, especially on slower connections. Each post view required a fresh API call, even if the post had been recently viewed. 💡 The Solution: I implemented a PostCache system using React's Context API. Here's how it works: - I created a PostCacheContext that stores recently viewed posts in memory. When a user views a post, it is stored in the Cache. - When clicking on the post, we first check the cache. If the post exists, we display it instantly while refreshing the data in the background. Code Snippet: ```js // src/contexts/PostCacheContext.js import React, { createContext, useState, useContext } from 'react'; // Create a context for our post cache const PostCacheContext = createContext(); export const PostCacheProvider = ({ children }) => {  // State to hold our cached posts  const [cachedPosts, setCachedPosts] = useState({});  // Function to add a post to the cache  const cachePost = (post) => {   // Update the cache with the new post   setCachedPosts(prevCache => ({    ...prevCache,    [post.id]: post // Store the post using its ID as the key   }));  };  // Provide the cache and cachePost function to children components  return (   <PostCacheContext.Provider value={{ cachedPosts, cachePost }}>    {children}   </PostCacheContext.Provider>  ); }; // Helper function to use the cache in components export const usePostCache = () => useContext(PostCacheContext); ``` 🎉 The Results: - Instant loading of recently viewed posts - Smoother navigation experience - Reduced API calls, leading to less server load Implementation Tips: -Wrap your relevant container in app.js with the PostCacheProvider -Use the PostCacheContext (accessed via the usePostCache function) in any components that display posts -This should always update the cache when fetching fresh data ``` //src/App.js import { PostCacheProvider } from './contexts/PostCacheContext'; function App() { return ( <PostCacheProvider> {/* This makes the cache available to all child components */} {/* ... other providers and app content ... */} </PostCacheProvider> ); } ``` #ReactJS #WebPerformance #FrontEndDevelopment #WebDevelopment #JavaScript #Cache #SoftwareEngineering #JuniorDev #CodingJourney

৫

২ মন্তব্যসমূহ

5 Kotlin Interview Questions with Answers: Questions: 1. lateinit vs lazy in Kotlin 2. Difference between == and === in Kotlin 3. What is a JvmStatic Annotation in Kotlin? 4. What is a reified keyword in Kotlin? 5. Suspending vs Blocking in Kotlin Coroutines 1. lateinit vs lazy: `lateinit` is used for non-null, late-initialized vars, ideal for dependencies that cannot be initialized in the constructor. `lazy` is for vals, initializing them upon first access, useful for resource-intensive objects.   2. Difference between == and ===: `==` checks structural equality (via the equals method), while `===` checks referential equality, seeing if two references point to the same object. 3. JvmStatic annotation: This Kotlin annotation makes a member function of an object or companion object accessible as a static method from Java code, facilitating smoother Java-Kotlin interoperability. 4. Reified keyword: Used with inline functions, it allows type parameters to be accessed at runtime, which is normally not possible due to type erasure in generics. 5. Suspending vs Blocking: Suspending functions in coroutines free up the thread to do other tasks, unlike blocking, which keeps the thread occupied until the operation completes, leading to potential performance issues. #kotlin #android

৫১

১ মন্তব্য

In the era of distributed computing and all its power, it is important to prioritize the essentials of performance (i.e., things that we already have and know work). These techniques offer significant improvements in performance and resource efficiency, and they can address many common challenges faced in high-traffic applications. Focusing on these approaches allows for more immediate and tangible gains compared to investing heavily in complex, distributed architectures, massive messaging systems, or advanced distributed computing solutions.

২

🚀 𝐋𝐞𝐚𝐫𝐧 𝐀𝐖𝐒 𝐓𝐡𝐫𝐨𝐮𝐠𝐡 𝐈𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭𝐚𝐭𝐢𝐨𝐧 𝐒𝐞𝐫𝐢𝐞𝐬 #𝟗: 𝐒𝟑 𝐏𝐫𝐞-𝐒𝐢𝐠𝐧𝐞𝐝 𝐔𝐑𝐋 𝐟𝐨𝐫 𝐒𝐞𝐜𝐮𝐫𝐞 𝐎𝐛𝐣𝐞𝐜𝐭 𝐀𝐜𝐜𝐞𝐬𝐬 𝐆𝐢𝐭𝐡𝐮𝐛 𝐋𝐢𝐧𝐤 👉 : https://lnkd.in/gaYGansA 🎯 𝐖𝐡𝐲 𝐭𝐡𝐢𝐬 𝐫𝐞𝐩𝐨? This project showcases the generation of pre-signed URLs via AWS Lambda to securely manage object access within an S3 bucket. The infrastructure and code are designed for efficient resource management and streamlined deployment in the Serverless Framework, emphasizing modular configuration, organized Lambda functions, IAM roles, and AWS resources. 💡 𝐖𝐡𝐚𝐭 𝐲𝐨𝐮'𝐥𝐥 𝐥𝐞𝐚𝐫𝐧: 1. ⚒ Utilise S3 Put & Get Object on Bucket. 2. 🌎 Leverage Pre-signed url for secure access of an object. 3. 🔗 Enable access to non-authenticated user to access without any permission for short duration. 4. 📚 Hands-on experience with the Serverless Framework. 📘 𝐏𝐫𝐨 𝐓𝐢𝐩: Don’t skip the ReadMe.Md file—it’s packed with detailed steps and insights to help you succeed. #serverless #aws #awsservices #awsenthusiast #beginners #AWSTips #AWSenthusiast #awsapigateway #awslambda #serverlessframework #learnByImplement #AWSIndia #awsCommunity #AWSCommunity

৮