Budhdev Kaushik’s Post

Exception Nostalgia!! Coded in Java for several years and moved to Python recently, nevertheless the core concepts remain the same be it the classes, functions or exception handling :) 🚀 FastAPI Insight: Why Your 4xx Errors Still Show “detail” (and how to fix it cleanly) While working with FastAPI, I came across a subtle but important behavior in error handling. 🔍 The Situation You raise an exception like this: raise HTTPException( status_code=422, detail={ "error_code": "VALIDATION_ERROR", "message": "Something went wrong" } ) But the response always comes back as: { "detail": { "error_code": "...", "message": "..." } } 🤔 Even though you passed a custom structure, FastAPI wraps everything inside "detail". 🧠 Key Insight HTTPException → controls the status code FastAPI → always wraps response inside detail You cannot change this behavior directly ⚠️ Common Mistake Catching all exceptions like this: except Exception as e: This also catches HTTPException ❌ Result → Your intended 4xx/5xx error may get converted into a 200 response (bad API design) ✅ Correct Pattern except HTTPException: raise # preserve original status code 💡 The Real Solution If you want a clean, consistent API response like: { "status": "error", "error": { ... } } 👉 You need to override FastAPI’s default behavior: @app.exception_handler(HTTPException) async def custom_handler(request, exc): return JSONResponse( status_code=exc.status_code, content={ "status": "error", "error": exc.detail } ) 🎯 Final Takeaway ✔️ Use HTTPException for proper HTTP semantics ✔️ Always re-raise it inside except blocks ✔️ Use a custom exception handler for consistent API contracts This small tweak can make your API: Cleaner More predictable Easier to integrate with frontend systems #FastAPI #BackendDevelopment #Python #APIDesign #SoftwareEngineering #CleanCode #Microservices

Write native. Preview human.  🚀 I just published my first VS Code extension - bin2prev Lets stop writing code in natural language, Lets just preview if needed.  Machines don't speak Java, Python, or JavaScript. They speak native binary.  High-level languages were invented for developers - not for machines. Every line of code you write gets compiled down to the binary that the CPU  actually executes. The native code is the real code. Everything else is a translation.  With AI agents, we can now write native binary directly - the way machines actually think. No compiler, no runtime, no abstraction layers.  bin2prev bridges the gap: write native with your AI agent, then preview it in your preferred language - Java, JavaScript, Python, Ruby, or Go —  so you can read what the machine already understands.  ✅ Opens binary files directly in VS Code ✅ Raw hex dump with ASCII view ✅ Equivalent source code in 5 languages ✅ Supports Mach-O & ELF  formats   ✅ ARM64 instruction decoding  Write native. Preview human.  🔗 Install it now — search "bin2prev" in VS Code Extensions or visit: https://lnkd.in/dytMK2fm Open for all to contribute: https://lnkd.in/dpsSkVen #VSCode #Extension #Binary #NativeCode #AI #OpenSource #Developer #Hackathon  💻 Source code: https://lnkd.in/dpsSkVen

The Golang String Trap: Why len("🚀") does not equal 1 🤯 Quick backend nugget for the timeline today that completely blows the minds of developers coming from JavaScript or Python. Let’s say you are building an API in Go, and you need to validate that a user's password is at least 8 characters long. You instinctively write: if len(password) < 8 { return error } Seems mathematically perfect, right? But what if the user’s password is "Pass🚀🚀"? In Go, len("Pass🚀🚀") returns 12, not 6. Your validation just let a 6-character password slip through. Wait, why? Because in Go, strings are NOT arrays of characters. They are read-only slices of bytes. The letters P-a-s-s take up 1 byte each. But those rocket emojis? They take up 4 bytes each! The Production Fix: If you want to count actual, human-readable characters in Go, you have to use Runes (Go’s way of handling Unicode code points). Instead of len(), you must use utf8.RuneCountInString(). Why this matters: If you are setting database limits, handling password validation, or truncating text for a UI, using the standard len() function on user input that contains emojis or foreign characters will introduce silent, hard-to-track bugs into your system. When validating text length from users, always count Runes, not bytes. Did you know about the Byte vs. Rune difference in Go? Let’s gist in the comments 👇🏾 #Golang #BackendEngineering #SoftwareDevelopment #TechBro #TechInNigeria #SystemDesign #WeMove

Stop writing Python like Java/C++. Most backend developers, coming from languages like Java or C++, tend to think about performance in terms of threading and blocking I/O. While that's a valid concern, Python offers a more idiomatic and often simpler approach to managing background tasks that can significantly boost backend performance. The 'Pythonic' way to think about background workers isn't about squeezing more out of a single process with complex threading. Instead, it's about offloading work that doesn't need to happen right now from the main request-response cycle. This allows your web server to respond to users faster, while the heavy lifting happens asynchronously in the background. Think of it like a restaurant: the waiter (your web server) takes your order quickly, and the chefs (background workers) prepare your meal without you waiting at the counter. Here's a quick example of the core idea: Okay (Blocking): from flask import Flask import time app = Flask(name) def longrunningtask(): time.sleep(5) # Simulates a slow operation print("Task finished!") @app.route('/') def index(): longrunningtask() # This blocks the entire request return "Request processed!" Best (Async with a Worker Queue - conceptual): from flask import Flask import time from yourworkerlibrary import enqueue_task # e.g., Celery, RQ app = Flask(name) def longrunningtask(): time.sleep(5) print("Task finished!") @app.route('/') def index(): enqueuetask(longrunning_task) # This returns immediately return "Request received! Task is processing in the background." The key insight here is that your main application should focus on quickly serving user requests. Anything that takes time and doesn't need to be in the immediate response – like sending emails, processing images, or generating reports – should be handled by a separate background worker process. This decoupling keeps your web server responsive and your users happy. Background workers improve backend performance by removing slow, non-essential tasks from the critical request-response path, allowing the main application to serve users much faster. #Python #CodingTips

A thought-provoking piece for crafters: "GitHub - Distributive-Network/PythonMonkey: A Mozilla SpiderMonkey JavaScript engine embedded into the Python VM, using the Python engine to provide the JS host environment." PythonMonkey embeds Mozilla's SpiderMonkey JavaScript engine directly into the Python runtime, letting developers call JavaScript from Python and Python from JavaScript within the same process — no serialization or IPC required. The project shares memory backing stores between languages for strings, typed arrays, and buffers, making cross-language data transfer extremely fast. Python dicts and lists automatically behave as JS objects and arrays (and vice versa), with full method support through proxy wrappers. It ships with a CommonJS module system, an event loop (supporting setTimeout and Promises as Python awaitables), and standard JS globals like console and XMLHttpRequest. The project reached MVP in September 2024, installs via `pip install pythonmonkey`, and Distributive actively maintains it while welcoming external contributions.

💡 How SQL, JavaScript, and Python Work Together In modern applications, three powerful technologies often work together: SQL, Python, and JavaScript. SQL is used to store and manage data in databases. Python is used to process, analyze, and apply logic to that data. JavaScript is used to display the data interactively on websites. 👉 Simple Workflow: Database (SQL) → Backend Processing (Python) → Frontend Display (JavaScript) This combination is used in: ✔ Data Analytics ✔ Web Development ✔ Machine Learning Projects 🚀 If you learn these three skills, you can build complete real-world applications. #DataScience #Python #SQL #JavaScript #WebDevelopment #Learning

Most Python developers use Flask, FastAPI, or Django… But many still overlook one fundamental concept: HTTP methods. No matter which framework you choose, everything comes down to how your application handles these requests: • GET – Retrieve data • POST – Create a resource • PUT – Replace an entire resource • PATCH – Update specific fields • DELETE – Remove a resource Here’s where it gets interesting 👇 A lot of developers confuse PUT and PATCH. PUT → Replaces the entire resource PATCH → Updates only what’s necessary Why does this matter? Because choosing the right method leads to: ✔ Cleaner API design ✔ Better performance ✔ Easier maintainability Frameworks may differ in style and complexity, but the foundation remains the same: HTTP. Master these basics once, and switching between Flask, FastAPI, and Django becomes much easier. What’s one concept in backend development that took you time to fully understand? #Python #WebDevelopment #APIDesign #BackendDevelopment #Flask #FastAPI #Django #HTTPMethods

I compared the same logic in JS and Rust. The result? The "complex" Rust version wasn't just drastically faster — it was actually shorter and cleaner. If you’ve worked with JavaScript, Python, or Java, you’ve likely encountered the classic problem of counting how many times each character appears in a string. In JavaScript, the typical approach looks like this: if (map.has(ch)) { map.set(ch, map.get(ch) + 1); } else { map.set(ch, 1); } While this seems straightforward, there’s a hidden performance flaw: The Double Lookup & Value Copying. This one-liner requires extra work from the engine: 1️⃣ map.get(ch): Calculates the hash, traverses memory, finds the bucket, and extracts a copy of the number. 2️⃣ + 1: Creates a brand-new number primitive in memory. 3️⃣ map.set(ch, ...): Calculates the hash again, traverses memory again, finds the same bucket, and copies the new number back into it. Now, let's see how Rust handles the same logic: *counts.entry(ch).or_insert(0) += 1; This isn't just syntactic sugar; it utilizes Rust's Entry API, designed for maximum hardware efficiency. Here’s why it’s blazingly fast: - It calculates the hash exactly once. - It locates the memory bucket exactly once. - It returns a &mut (a direct mutable pointer/reference) right to that memory slot. The += operator modifies the primitive value in-place without copying it out or needing a .set() method to put it back. This results in code that reads like a high-level script but executes with the speed of a systems language. Zero-cost abstractions at their finest! #Rust #JavaScript #Programming #Performance #SoftwareEngineering #WebDev #RustLang

Stop writing Python like Java/C++ when thinking about backend performance. The 'Pythonic' way to approach background tasks isn't about threads for every little thing. It's about offloading work that doesn't need to happen immediately, so your main request handler can respond quickly. This frees up your web server to serve more incoming requests, rather than getting stuck waiting for a long-running process. Think of it like a restaurant: the waiter (your main request handler) takes your order and brings it to the kitchen. The kitchen staff (background workers) then prepare your food without the waiter standing there waiting. The waiter can then go take the next order. Here's a quick look: Okay (Blocking) # In your web request handler def process_data(request): longrunningtask() # This blocks the request until it's done return HttpResponse("Done!") Best (Non-Blocking with Background Worker) # In your web request handler def processdataasync(request): enqueuetask(longrunning_task) # Task is put in a queue, request returns immediately return HttpResponse("Task accepted, processing in background!") # Separate process/thread manages enqueuetask and longrunning_task Background workers improve backend performance by separating time-consuming operations from the main request-response cycle, allowing your application to handle more concurrent users. #Python #CodingTips

GitVoyant v0.3.0. Temporal code intelligence now runs across Python, JavaScript, Java, and Go. Four language-specific analyzers behind a single protocol. Tree-sitter for unified AST parsing. Automatic language detection. Static analysis tells you a file is complex. GitVoyant tells you whether that complexity is growing, shrinking, or stable, and at what rate. https://lnkd.in/g4fNbdRg