Understanding Exit Codes: 0 to 143 Explained

I used to think bugs come from bad code. Yes obviously bugs comes from bad codes, but is that only the case? Lately I’m starting to feel it’s usually something else. Wrong assumptions. When something breaks, my first instinct is always: “this part must be wrong” So I start changing things. Trying fixes. Going back and forth. And somehow it just gets more confusing. But most of the time, the issue isn’t even there. It’s in something I already assumed was correct. Like: – thinking the API response looks a certain way – assuming state has already updated – expecting a function to run in a certain order And I don’t question those. That’s what actually slows things down. Not the bug itself — but being confident about something that’s not true. Recently I’ve been trying a different approach. Instead of asking: “what’s broken?” I pause and ask: “what am I assuming right now?” That usually gets me to the real issue faster than random fixes ever did. Still figuring it out… but debugging feels a lot clearer this way. #SoftwareEngineering #Debugging #Developers #Learning

How to trace and debug an error. Most people debug by guessing. That’s the slowest way to fix anything. Real debugging starts when you stop touching code and start understanding it. First rule: Don’t change anything yet. Do this instead: Reproduce it If you can’t make it happen again, you don’t understand it yet. Find the boundary Where does it break? Frontend? Backend? API? Database? Don’t debug everything. Find where things go wrong. Follow the data Take one request: Input → Processing → Output Trace it step by step. Log with intention Not random logs. Log: What came in What changed What went out Now you can see the story. Challenge assumptions “It should work” is not debugging. Verify everything. Fix the root cause Not the symptom. Not the quick patch. The real issue. Debugging isn’t about being clever. It’s about being systematic. #SoftwareEngineering #Debugging #BackendDevelopment #Programming #TechCareers #CleanCode #DeveloperTips

Nobody talks enough about this: Being a developer is 70% debugging. Not writing code. Not watching tutorials. Just… figuring out why something isn’t working. Lately, I’ve spent more time: • Reading error messages carefully • Tracing bugs step by step • Fixing things I didn’t even write • Breaking and rebuilding features just to understand them And honestly? That’s where the real growth is happening. Because every bug forces you to: think deeper understand the system better become more patient Clean code is great. But the ability to fix messy code under pressure is what makes you valuable. Still learning. Still debugging. Still improving. #SoftwareEngineering #Debugging #CSharp #DotNet #BackendDevelopment #ProblemSolving #DevLife

Every developer has had this moment. You run a simple UPDATE query to fix one record… feeling confident and in control. And then suddenly: “1,255,399 rows affected.” That one second changes everything 😅 This is not just about a mistake. It’s a reminder of how powerful and risky our tools can be. In development, small actions can have big consequences. That’s why: • Always double-check your queries • Use WHERE conditions carefully • Test in a safe environment first • And never underestimate the impact of your code Mistakes like these are part of the journey. They teach us to be more careful, more responsible, and more aware. Because in tech… one line of code can change everything. #Developers #Programming #SQL #CodingLife #SoftwareEngineer #Debugging #TechLife #Learning #WebDevelopment

The No. 1 debugging skill isn't better logs (it actually costs you nothing): The average engineer spends 8 hours per week debugging. Where is most of the time spent? Reproducing the bug. Think about it. You can't fix what you can't trigger on demand. Here's what a solid repro unlocks: 0️⃣ You can bisect → Git, feature flag, config. Binary search only works if both sides are repeatable. 1️⃣ You can test a hypothesis in minutes → Every guess becomes a 60-second experiment instead of a 45-minute wait. 2️⃣ You can hand it off → A bug you can trigger is a bug a teammate can pick up tonight. 3️⃣ You can guard it forever → A reliable repro becomes a regression test the day you fix it. 4️⃣ You stop confusing symptoms with causes → Half of "fixes" are actually the bug hiding behind a new timing window. Reproduction IS most of debugging: Minimize scope: strip inputs until only the breaking path remains. → Freeze inputs: fixed seeds, fixed data, fixed clock. → Control time: fake clocks beat "wait for it to happen again." → Control concurrency: serialize first, add parallelism back deliberately. Never trust a fix you couldn't trigger on demand beforehand. What's the last bug you "fixed" without reproducing first? _____ Btw grab my 12 systems design sheet: https://lnkd.in/g7BEtcNZ Follow Alexandre Zajac for memes and software 🫡  _____

“My code passed 𝟏𝟎𝟎+ test cases… so I thought I was done.” 😌 Then test case 118 happened. 💀 I was solving the 𝐋𝐨𝐧𝐠𝐞𝐬𝐭 𝐈𝐧𝐜𝐫𝐞𝐚𝐬𝐢𝐧𝐠 𝐒𝐮𝐛𝐬𝐞𝐪𝐮𝐞𝐧𝐜𝐞 (LIS) problem using Dynamic Programming (𝐑𝐞𝐜𝐮𝐫𝐬𝐢𝐨𝐧 + 𝐌𝐞𝐦𝐨𝐢𝐳𝐚𝐭𝐢𝐨𝐧). Everything looked perfect. Clean code. Correct logic. And most importantly — it was passing. Until it didn’t. Large test cases started crashing with runtime errors. That’s when it hit me… 👉 The problem wasn’t my code. 👉 The problem was my thinking. I was using an O(n²) approach for constraints up to 10⁵. No matter how “correct” it is… it’s not scalable. So I switched to the O(n log n) solution using 𝐁𝐢𝐧𝐚𝐫𝐲 𝐒𝐞𝐚𝐫𝐜𝐡. Same problem. Same goal. Completely different performance. 💡 That moment changed how I look at problems: Correct ≠ Efficient Passing ≠ Scalable 𝘿𝙤 𝙮𝙤𝙪 𝙥𝙧𝙞𝙤𝙧𝙞𝙩𝙞𝙯𝙚 𝙘𝙤𝙧𝙧𝙚𝙘𝙩𝙣𝙚𝙨𝙨 𝙛𝙞𝙧𝙨𝙩 𝙤𝙧 𝙨𝙘𝙖𝙡𝙖𝙗𝙞𝙡𝙞𝙩𝙮 ? #DataStructures #Algorithms #DynamicProgramming #CodingJourney #SoftwareEngineering #ProblemSolving #TechLearning #LearnInPublic #Developers #Coding

Debugging sometimes takes longer than writing the actual code. But that’s where most of the learning and improvement happens. #Developers #Debugging #TechLife

I recently spent some time digging through a repo by Damian Tedrow — a self-hosting compiler project called Codex, built by four AI agents and a human coordinating through git. The compiler itself is impressive: a literate programming language that compiles itself to bare metal on x86-64 with no OS, runtime, or libc. 268 KB kernel, 15 backends, and fixed-point self-compilation. But the interesting part wasn’t the compiler — it was the engineering process documented in the repo. Damian and his agents have been doing multi-agent software development in a fairly disciplined way, and some of the protocols they evolved are directly applicable to anyone using AI in their dev loop: 🔧 A Tool Error Registry cataloging 10 classes of silent tool failures — along with the observation that automation works better than discipline. 🤝 A coordination protocol where four agents with defined identities and authority scopes work in isolated branches and review each other’s changes. 📋 Session handoff documents to prevent context loss between agent runs (what changed, what’s incomplete, key files, stashed work). 🐛 A minimal reproduction workflow that traced ~1,600 type errors back to a three-line parser bug using a 40-line repro case. With Damian’s permission, we extracted a number of these practices and filed 10 issues against PromptKit (aka.ms/PromptKit) to explore integrating them as reusable protocols and templates. Thanks to Damian for building in the open and making the process visible — not just the outcome.

🐞🔍 Debugging Strategy Every Developer Should Follow Debugging isn’t about guessing… It’s about following a clear process. 💡 Step-by-Step Mindset: 1️⃣ Reproduce the Bug Understand when and where it happens. 2️⃣ Check Logs Logs never lie — start there. 3️⃣ Validate API/Data Is the backend response correct? 4️⃣ Inspect UI Logic Check conditions, bindings, and state. 5️⃣ Fix & Verify Apply the fix and test edge cases. 🎯 Simple Flow: Bug → Logs → API → UI → Fix ⚡ Pro Tip: Don’t jump to conclusions. Follow the flow — you’ll save hours. 🔥 Great developers aren’t just good at coding… They’re great at debugging. 💭 What’s your go-to debugging trick? #Debugging #Developers #Coding #SoftwareEngineering #ProblemSolving #Programming #TechTips