Webentra’s Post

⚠️ “My code is correct… but the API still doesn’t work!” If you’ve ever faced this, you’re not alone. API integration is one of the biggest challenges for students and beginners. 👉 Most common mistakes: 🔹 Using the wrong endpoint or URL 🔹 Missing authentication (API key / token) 🔹 Not handling JSON responses properly 🔹 Ignoring CORS issues 🔹 Writing code without testing the API first 💡 The truth: Good developers are not the ones who never face errors… They are the ones who know how to debug them effectively. 🎯 Smart approach: ✔ Test APIs using tools like Postman before coding ✔ Carefully read error messages in the console ✔ Understand status codes (200, 400, 500…) ✔ Debug step-by-step instead of guessing 🚀 API integration becomes easy when your debugging skills improve. 💬 Which API error frustrates you the most? --- #API #WebDevelopment #Developers #Programming #BackendDevelopment #FrontendDevelopment #FullStackDeveloper #Debugging #Coding #SoftwareDevelopment #TechCareers #LearningToCode #StudentLife #ProblemSolving #DevelopersLife #EngineeringStudents #TechEducation #SkillDevelopment

Recently, I accidentally fell into a rabbit hole… and instead of climbing out, I opened the source code of an AI coding agent 👀 I’ve been curious about agentic coding for a while, so I gave Opencode a spin. And yes, my selection criteria were extremely rigorous… mainly “ooh nice UI” and “that name sounds cool” 😄 While using it, I noticed something odd (atleast to me): It only listed my sessions when I was inside the same folder where they were created. Switching folders? No sessions. Naturally, curiosity kicked in — so I dug into the source code 🔍 Here’s what I found: 👉 Project Identification Opencode generates a unique project ID to track sessions. It does this in two ways:  - If the folder is a Git repo:      It runs   $ git rev-list --max-parents=0 HEAD       to get the Git directory, then derives the project identity from it.       And here’s the fun part — it caches this inside .git/opencode.   Yes, it casually writes into your .git folder. Pretty clever.  - If Git is not initialized:       It falls back to a constant global value (so basically, all such folders look the same to it, no because there are some other conditions too). 👉 Session Tracking Each session gets its own unique ID. 👉 How it links everything It stores sessions in a SQLite database and connects them using the project ID as a foreign key. You can even find where this DB lives with: opencode db path 💡 Why sessions don’t show across folders? Because each folder = different project ID (especially if Git is initialized). No shared project ID → no shared session list. Honestly, I love these small design decisions. Simple idea, clean implementation, and very “developer-minded.” Diving into source code like this always feels like uncovering tiny engineering stories hidden beneath the UI 🚀 #OpenSource #AI #AgenticAI #CodingAgent #DeveloperLife #SoftwareEngineering #TechDeepDive #CodeReading #LearnInPublic #Git #SQLite #Programming #Developers #TechCuriosity #BuildInPublic #EngineeringInsights #Debugging #DevTools #BackendEngineering #CleanDesign

Have you ever felt overwhelmed by object types in TypeScript? Understanding the keyof and typeof operators can really streamline your code. They're like the secret sauce for type safety and clarity. ────────────────────────────── Understanding keyof and typeof Operators in TypeScript Let's dive into the powerful keyof and typeof operators in TypeScript and how they can simplify your code. #typescript #programming #webdevelopment #coding #tech ────────────────────────────── Key Rules • The typeof operator allows you to get the type of a variable or property. • The keyof operator creates a union type of all the keys in an object type. • You can combine both operators to create powerful type manipulations. 💡 Try This type Person = { name: string; age: number; }; const key: keyof Person = 'name'; // 'name' or 'age' ❓ Quick Quiz Q: What does the keyof operator return? A: A union of all keys of the given object type. 🔑 Key Takeaway Mastering keyof and typeof can enhance your TypeScript skills and make your code safer and more expressive. ────────────────────────────── Small JavaScript bugs keep escaping to production and breaking critical user flows. Debugging inconsistent runtime behavior steals time from feature delivery.

People often think of QML as just a scripting layer. I used to look at it the same way, until I actually started building with it. Coming from a backend dev mindset, I assumed this would be the easier side. Something lightweight on top while the real work happens in cpp. Not quite. QML has its own way of structuring things, state, components, data flow. And if you’ve worked with JavaScript, it feels oddly familiar. Dynamic, expressive, UI-first thinking. The real shift for me was seeing how cleanly it connects with the backend. Things like Q_PROPERTY and qmlRegisterType just bridge the gap so naturally, it almost feels seamless. Add to that property bindings reacting on their own and signals flowing across layers, and you start thinking very differently about how apps should behave. Also, QML lets you move fast while building. You just keep building. And then you run it. Runtime errors 🙂 Definitely not just a scripting layer. It’s a proper part of the stack, and easily one of the more interesting parts to work with. #Qt #QML #Cpp #EmbeddedDev #QtQuick #UI #CrossPlatformDev #DevThoughts

Some thing which is very underrated and actually important in software engineering is code deletion. YES, not creating new code, but code deletion. Deleting code is one of the most important things I learned during my journey of writing production code. As a junior, I thought my job was adding features. Every edge case got a new function. Years later, that codebase was an unmaintainable nightmare. Over time, I have realized that the best engineers aren't writing the most code, but they're deleting it. Our team once built a report exporter for PDF, Excel, CSV, JSON, and XML. Logs showed 99% of users only used PDF and Excel. The three unused formats took up 40% of the module's code and maintenance overhead. Despite team's pushback ("What if someone needs XML?"), we deleted them. We cut the module size by 40%, halved our bug rate, and shipped 30% faster. Not a single user noticed. Codebases fail because they have too many features. Obsolete features and "just in case abstractions" still require maintenance. Every line of code is a liability. It can break, it needs testing, and it adds complexity. The best code is no code. There are signs that one can look out for to decide whether you should delete code: - Low usage: Less than 5% adoption after six months. - Forgotten origins: You have to dig through git history to understand why it exists. - Spaghetti logic: It scatters if statements across the codebase. - Test bloat: The tests are more complex than the implementation. - Fear: Developers avoid touching it because it might break. I now do a quarterly codebase purge, where in lookout for unused features. There are expected pushback: "We might need it." - It’s in Git. You can bring it back in an hour. "We spent time on it." - Sunk cost fallacy. "It’s not hurting anything." - It is. It makes the system harder to maintain. Your job as an engineer isn't just to write code. It is to solve problems. That often means deleting code to make systems simpler and more reliable. Next time you're about to add a feature, ask yourself: "Do I really need a new functionality OR can we enhance on the existing functionality.?" #coding #softwaredev #software #production

Atomic Habits breaks every habit into 4 steps. Cue, craving, response, reward. The cue triggers your brain. The craving motivates you. The response is the action you take. The reward reinforces the loop. I mapped my own coding habit to this today. 🔵 Cue: I open my laptop every morning at the same time. 🔥 Craving: I want to feel like I am making progress. ⚡ Response: I write code, solve DSA problems, learn something new. ✅ Reward: The feeling of having built something real by end of day. Today that response was understanding JavaScript control flow deeply, loops, early return patterns and why they matter beyond just syntax. Also dug into GitHub API integration using shell scripts for DevOps. Solved 5 DSA problems. The book also says to break a bad habit, make it invisible, unattractive, difficult and unsatisfying. Small friction. Big difference. Day 2 of showing up publicly. 🚀 #100DaysOfCode #JavaScript #DSA #LearningInPublic #SoftwareEngineering

𝗦𝗽𝗲𝗻𝘁 𝘁𝗵𝗲 𝗹𝗮𝘀𝘁 𝘄𝗲𝗲𝗸 𝗱𝗲𝗯𝘂𝗴𝗴𝗶𝗻𝗴 𝗮 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻 𝗶𝘀𝘀𝘂𝗲 𝘁𝗵𝗮𝘁 𝗰𝗮𝗺𝗲 𝗱𝗼𝘄𝗻 𝘁𝗼 𝗼𝗻𝗲 𝘁𝗵𝗶𝗻𝗴 — 𝗮 𝗽𝗼𝗼𝗿𝗹𝘆 𝘄𝗿𝗶𝘁𝘁𝗲𝗻 𝗗𝗼𝗰𝗸𝗲𝗿𝗳𝗶𝗹𝗲. 𝗦𝗼 𝗵𝗲𝗿𝗲 𝗮𝗿𝗲 𝘁𝗵𝗲 𝗗𝗼𝗰𝗸𝗲𝗿 𝗯𝗲𝘀𝘁 𝗽𝗿𝗮𝗰𝘁𝗶𝗰𝗲𝘀 𝗜 𝘄𝗶𝘀𝗵 𝘀𝗼𝗺𝗲𝗼𝗻𝗲 𝗵𝗮𝗱 𝘁𝗼𝗹𝗱 𝗺𝗲 𝗲𝗮𝗿𝗹𝗶𝗲𝗿: 𝟭. 𝗨𝘀𝗲 𝗮 𝘀𝗽𝗲𝗰𝗶𝗳𝗶𝗰 𝗯𝗮𝘀𝗲 𝗶𝗺𝗮𝗴𝗲 𝘁𝗮𝗴, 𝗻𝗲𝘃𝗲𝗿 :𝗹𝗮𝘁𝗲𝘀𝘁  latest can silently change between builds. Pin your version — node:20.12-alpine, python:3.12-slim. Your future self will thank you. 𝟮. 𝗢𝗿𝗱𝗲𝗿 𝘆𝗼𝘂𝗿 𝗹𝗮𝘆𝗲𝗿𝘀 𝗳𝗿𝗼𝗺 𝗹𝗲𝗮𝘀𝘁 𝘁𝗼 𝗺𝗼𝘀𝘁 𝗳𝗿𝗲𝗾𝘂𝗲𝗻𝘁𝗹𝘆 𝗰𝗵𝗮𝗻𝗴𝗲𝗱  COPY package.json first → RUN npm install → then copy the rest of your code. This keeps your dependency layer cached and builds stay fast. 𝟯. 𝗥𝘂𝗻 𝗮𝘀 𝗮 𝗻𝗼𝗻-𝗿𝗼𝗼𝘁 𝘂𝘀𝗲𝗿  By default, containers run as root. That's a security risk. Add: RUN adduser --disabled-password appuser USER appuser 𝟰. 𝗨𝘀𝗲 .𝗱𝗼𝗰𝗸𝗲𝗿𝗶𝗴𝗻𝗼𝗿𝗲  Stop shipping node_modules, .git, test files, and .env into your images. A bloated image is a slow image — and a leaky one. 𝟱. 𝗠𝘂𝗹𝘁𝗶-𝘀𝘁𝗮𝗴𝗲 𝗯𝘂𝗶𝗹𝗱𝘀 𝗮𝗿𝗲 𝗮 𝗴𝗮𝗺𝗲 𝗰𝗵𝗮𝗻𝗴𝗲𝗿  Build your code in one stage, copy only the final artifact to a clean runtime image. I've seen image sizes go from 1.2GB → 80MB just from this one change. 𝟲. 𝗢𝗻𝗲 𝗽𝗿𝗼𝗰𝗲𝘀𝘀 𝗽𝗲𝗿 𝗰𝗼𝗻𝘁𝗮𝗶𝗻𝗲𝗿  Don't run your app + cron + nginx in a single container. Separate concerns. Use docker-compose or orchestration for that. 𝟳. 𝗛𝗘𝗔𝗟𝗧𝗛𝗖𝗛𝗘𝗖𝗞 𝗶𝘀 𝗻𝗼𝘁 𝗼𝗽𝘁𝗶𝗼𝗻𝗮𝗹 𝗶𝗻 𝗽𝗿𝗼𝗱  HEALTHCHECK --interval=30s --timeout=5s CMD curl -f http://localhost:8080/health || exit 1 If you're not doing this, your orchestrator doesn't know if your app is actually alive.  • 𝗦𝗺𝗮𝗹𝗹 𝗶𝗺𝗽𝗿𝗼𝘃𝗲𝗺𝗲𝗻𝘁𝘀 𝗶𝗻 𝗗𝗼𝗰𝗸𝗲𝗿𝗳𝗶𝗹𝗲𝘀 𝗰𝗮𝗻 𝘀𝗮𝘃𝗲 𝗵𝗼𝘂𝗿𝘀 𝗶𝗻 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻. #Docker #DevOps #SoftwareEngineering #Backend #CloudNative

Me: "This will take 2 hours" Also me 6 hours later: Still debugging why my code works perfectly on my machine but crashes spectacularly in production. The plot twist? A missing environment variable I confidently set 3 months ago and completely forgot about. We've all been there. That sinking feeling when your "quick fix" turns into an archaeological dig through your own code. You question everything: • Is Docker lying to me? • Did I break the entire CI/CD pipeline? • Why didn't I document this better? • Was I drunk when I wrote this? Then you find it. One tiny DATABASE_URL sitting in your local .env file, mocking you. The variable you added during that late-night coding session when you were "just testing something real quick." The worst part? You spend 30 seconds adding it to production and everything works flawlessly. Time estimation in software development is already hard enough without our past selves setting traps for our future selves. What's the most ridiculous production bug you've spent hours debugging, only to find an embarrassingly simple fix? #viral #trending #trend #coding #programming #developer #softwaredeveloper #webdev #debugging #production #environment #variables #deploymentfails #developerlife #tech #javascript #python #docker

GitHub just shipped an embedding model update that actually matters. Their new Copilot embedding model for VS Code isn't just incrementally better — it's 37.6% more accurate at finding the right code context, runs twice as fast, and uses 8x less memory for indexing. For C# and Java devs, acceptance rates for suggestions have doubled. That's not a feature update. That's a productivity shift. What's interesting: they used contrastive learning techniques (InfoNCE loss + Matryoshka Representation Learning) to train this. The model now powers chat, agent, edit, and ask modes — so the improvements cascade across every interaction you have with Copilot. But here's what I'm thinking about: we're moving from "AI suggests code" to "AI understands your codebase architecture." Better embeddings mean better context retrieval. Better context means suggestions that feel less like autocomplete and more like pair programming with someone who's read your entire repo. For QA folks and builders working in complex codebases, this changes test automation workflows and API integration work significantly. Question: Are you seeing improved Copilot suggestions in your stack after this update, or is acceptance rate still a coin flip for you? #GitHubCopilot #AICoding #DeveloperProductivity #CodeEmbeddings #DevTools

🐞 Every developer writes code… but not every developer knows how to fix bugs properly. When I started, I used to randomly change code and hope the bug disappears. That’s not debugging — that’s guessing. So I wrote a simple step-by-step guide for beginners on how to actually fix bugs the right way. 🔍 In this blog, I covered: • How to reproduce and analyze bugs • Checking data, APIs, and root causes • Using debugger effectively • Fixing issues without breaking other features • Testing all scenarios before closing the bug 💡 Debugging is a skill — not luck. If you follow a structured approach, you save hours of frustration and avoid creating more bugs. If you're a beginner or struggling with debugging, this will help: 🔗 https://lnkd.in/dXMcyxmF ❓ What’s the hardest bug you’ve ever faced? #Debugging #SoftwareDevelopment #Java #NodeJS #Developers #Coding #Learning