Manaam Rehan’s Post

Randomly changing your code to debug is frustrating: ❌ You're not sure if the "fix" you make really fixed the issue (hint: it didn't) ❌ You're afraid the "fix" will cause the firmware crash later (hint: very likely) ❌ You can't explain the situation (let alone the root cause) to your boss It's like playing a "whack-a-mole" game with the bug. In my early days, my mindset was "fix it as fast as possible", so I tried my best to make the symptoms disappear. For example, If my firmware crashed after 1 hour, I would add code to auto-reset the system in minute 50 (yes, dumb, I know, I know). Did the firmware still crash after 1 hour? No. So the bug was fixed, right? But little did I know, I was just treating the symptoms and not really identifying the root cause. It's like adding more buckets instead of fixing the leaking roof. I thought the problem was gone, so I moved on the the next ticket. Only to find out the bug bit me even harder the next time we met again. Ouch! From that point, I spent the next several years developing my technique to debug better, faster, and actually more enjoyable. I called it the Relief Method. Using my Relief approach, debugging feels more systematic, and really improved my intuition for future debugging sessions. And more importantly, helped me prevent similar bugs from happening ever again. Tomorrow, I will share the exact steps I used to debug using Relief Method to my newsletter subscribers. Join 4000+ embedded engineers here: newsletter.rosmianto.com

Debugging isn't just about fixing errors; it's about understanding the root cause. Develop a systematic approach, utilize debugging tools effectively, and think critically to solve problems efficiently.

Node-Level Debugging with kubectl debug Most of the debugging techniquest focus on the application level, however it’s also possible to debug a specific kubernetes node using kubectl debug node command. Node-level debugging is crucial for diagnosing issues that affect the Kubernetes nodes themselves, such as resource exhaustion, misconfigurations, or hardware failures. This way the debugging Pod can access the root filesystem of the Node, mounted at /host in the Pod. Create a Debugging Session: Use the kubectl debug command to start a debugging session on a node. This command creates a pod running a debug container on the specified node. kubectl debug node/<node-name> -it --image=busybox Replace <node-name> with the name of the node you want to debug. The -it flag opens an interactive terminal, and --image=busybox specifies the image to use for the debug container. For more details, refer to the official Kubernetes documentation on node-level debugging.

A fascinating article by Shai Almog that explains how to prepare your application for handling failures, extensive logs, and debugging. He discusses the best practices for debugging the application in a production environment. https://lnkd.in/dF5qNQZn

Start debugging like a pro: It's not more code you need. It's better debugging. This guide will help you master it. 1. What is a debugger? A debugger is a tool. It helps you find and fix bugs in your code. 2. Why use a debugger? It saves time and effort. It makes your code more reliable. 3. How does a debugger look? It usually has a user interface. You can see your code and variables. 4. Setting breakpoints. Pause your code at specific points. Inspect variables and flow. 5. Stepping through code. Move through your code line by line. Understand exactly what happens. 6. Viewing the call stack. See the sequence of function calls. Track down where things go wrong. Use these tips. Debug better. Then code. This is how the best developers do it. follow Muhammad Nouman for more useful content.

Debugging errors is a skill must have. Dealing with errors and logs can be challenging and time-consuming: No idea what the issue or error is about. No clue where to start. Not sure if you are fixing the issue or just making it worse. ( I realized debugging is part of the journey; the only way to get better is with practice) Here are my top debugging tips: 1. Enable debug mode: ↳ Usually, this can be done from your app config file 2. Read the error message carefully ↳ It sounds simple, but understanding the error itself will solve 50% of the issue 3. Break down the problem ↳ Isolate the problem, test each part, and move step by step 4. Use "print" or "logging" ↳ Adding this can help you see what the code is doing. It makes things clearer Remember: Each error you solve or a bug you fix is a step closer to your growth P.S. What’s your favorite debugging tip ? ===== Helpful? ♻️ Repost to help someone else.

Six Stages of Debugging 1. That can’t happen😲❗ At this stage, surprise and denial are the initial reactions. 2. That doesn’t happen on my machine. 🤔 When there is confirmation that the code works correctly on the personal development environment, but shows errors in other environments. 3. That shouldn’t happen. 😤 After accepting that something is indeed wrong, comes a feeling of frustration and surprise. Because the code should not produce these errors based on the logic and assumed design. 4. Why does that happen? 🔍 Now the analysis and investigation phase begins. Trying to understand the real reason behind the error. May use exploration and tracking tools to get to the root of the problem. 5. Oh, I see. 💡 At this point, understand the actual cause of the problem. Discover the real cause of the error and start developing a plan to fix it. 6. How did that ever work? 🤯 Finally, after you solve the problem, start thinking about how the code worked before with this bug. This can lead to a deeper review of systems and procedures to ensure similar issues do not occur in the future.

Debugging isn’t just fixing what’s broken—it’s understanding a mystery. When you trace a bug to its source, you’re learning more than just why the system failed. You’re gaining insights into how the system works. Great engineers don’t hate bugs—they respect them. Each one is a lesson in how to build better.

#Debugging Debugging is the process of finding and fixing errors or bugs in a computer program or system. When a program doesn't work correctly, debugging helps identify why it's not working and what needs to be changed to fix it. Think of it like solving a puzzle to make sure everything works smoothly.

#Kubernates Debugging Container Image 1. kubectl run -i --tty --image=<image-name> -- sh - This command starts a new pod using the specified container image, and opens an interactive shell session inside the pod. You can use this shell session to investigate issues with the container image. 2. kubectl exec -it <pod-name> -- sh - This command opens an interactive shell session inside an existing pod. You can use this shell session to investigate issues with the container image running inside the pod. 3. kubectl describe pod <pod-name> - This command displays detailed information about a specific pod, including the image name and version. You can use this command to verify that the correct container image is being used. 4. kubectl logs <pod-name> - This command displays the logs of a specific pod. You can use this command to investigate any error messages or warnings that might be related to the container image. 5. kubectl port-forward <pod-name> <local-port>:<remote-port> - This command forwards a local port to a port on the container running inside a specific pod. 6. kubectl exec -it <pod-name> -- <command> - This command allows you to execute a specific command inside a container running inside a pod.