Python 3.11 asyncio TaskGroup vs asyncio.gather()

Most tutorials get this wrong. When building high-performance backend services in Python, it's easy to fall into patterns that feel familiar from languages like Java or C++. But Python offers a more elegant and efficient path. The 'Pythonic' way to think about building fast backend services with FastAPI is to embrace its asynchronous nature and leverage Python's built-in concurrency features. Instead of blocking operations, think in terms of non-blocking I/O. This allows your server to handle many requests simultaneously without getting bogged down. "Okay" Approach (Synchronous, Blocking): from fastapi import FastAPI import time app = FastAPI() @app.get("/process") async def processdatasync(): # Simulating a blocking I/O operation time.sleep(5) return {"message": "Data processed (slowly)"} "Best" Approach (Asynchronous, Non-blocking with async/await): from fastapi import FastAPI import asyncio app = FastAPI() @app.get("/process") async def processdataasync(): # Simulating a non-blocking I/O operation await asyncio.sleep(5) return {"message": "Data processed (quickly)"} The key difference is async def and await. This tells Python to run these functions concurrently, meaning the server isn't stuck waiting for one request to finish before starting another. Insight: FastAPI is built around Python's asyncio library. Using async and await for I/O-bound tasks is crucial for unlocking its high-performance potential. Fix: * Define your endpoints with async def. * Use await for any I/O operations (database calls, external API requests, file operations). * Consider using libraries that support asyncio for I/O (e.g., httpx for HTTP requests, asyncpg for PostgreSQL). FastAPI lets you build performant Python backends by thinking asynchronously, not by writing imperative, blocking code. #Python #CodingTips

Python 3.15 might be shipping one of the most exciting performance tools Python has added in a while, that too right after the GIL-free release. It is called Tachyon. Python is adding a new statistical sampling profiler under `profiling.sampling` called Tachyon, and the positioning is what caught my attention: - attach to a running Python process - no code changes - no restart - designed for low-overhead profiling - supports outputs like flamegraphs, speedscope-compatible stacks, Firefox Profiler, heatmaps, live TUI, async-aware views, and even opcode-level profiling The docs go even further and describe it as capable of sampling at up to 1,000,000 Hz and suitable for production performance debugging. With ML pipeline domination and RESTful servers now written increasingly in Python, this profiler will be a great addition. No longer will the notion of “run a profiler locally and hope the issue reproduces” carry on, and profiling becomes a first-class citizen, as in languages like Java. This is from the Python 3.15 alpha docs, so details may change before final release. But this is absolutely worth watching. A big thanks to the Python Software Foundation and Hugo van Kemenade for the updates and articles. Read more in the link below: https://lnkd.in/eUJ3C4N7 #Python #Python315 #Performance #Profiling #SystemsEngineering #Observability #Backend #SoftwareEngineering

🚨 A Small DSA Bug That Taught Me a BIG Concept (C++ vs Python) While solving a simple “subarrays” problem, I stumbled upon something that completely changed how I think about data structures across languages. Same logic. Same algorithm. Different outputs. 🤯 💻 C++ Code → ✅ Correct Output 🐍 Python Code → ❌ Wrong Output At first, it made no sense. But the reason is a core concept every developer MUST understand: ⚡ Value vs Reference Semantics 🔹 In C++: When you do: result.push_back(vector) 👉 It stores a copy of the vector Each subarray is independent No side effects 🔹 In Python: When you do: result.append(list1) 👉 It stores a reference, not a copy All entries point to the SAME list One change = changes everywhere 🧠 The Realization I wasn’t debugging a “DSA problem” I was debugging a memory model problem 🔥 The Fix in Python: Use: result.append(list1.copy()) or simply: arr[i:j] (which creates a new list automatically) 🎯 Key Takeaway 👉 C++ = Value-based by default 👉 Python = Reference-based for mutable objects And this difference can silently break your logic. 💡 Why This Matters This isn’t just about DSA: Prevents bugs in APIs & backend systems Helps in debugging shared state issues Builds strong fundamentals for system design 🚀 Final Thought Sometimes, the smallest bugs teach the deepest concepts. This one took me from: “I know how to code” to “I understand how code actually works underneath.” #DSA #Python #CPP #Programming #SoftwareEngineering #Debugging #Learning #CodingJourney

Ever wondered why FastAPI is so fast even though it's built with Python? Python is often considered slower than languages like Go or Node.js. Yet FastAPI can deliver performance that competes with them. So why is FastAPI so fast? The answer lies in the architecture underneath it. 1️⃣ Starlette (Lightweight ASGI framework) FastAPI is built on Starlette, which is an ASGI (Asynchronous Server Gateway Interface) framework. FastAPI uses Starlette for the core web functionality such as: • Routing • Middleware • WebSockets • Background tasks • Request/response handling Majorly performance is coming from the Starlette. 2️⃣ Pydantic for data validation FastAPI relies heavily on type hints in Python. These are used by Pydantic to automatically validate the incoming data. Pydantic v2 which is written in Rust, making validation extremely fast compared to traditional Python validation logic. 3️⃣ Uvicorn as the ASGI server FastAPI typically runs on Uvicorn, which is optimized for performance. Uvicorn uses: • uvloop — a high-performance event loop written in C • httptools — a fast HTTP parser also written in C FastAPI isn’t fast because Python suddenly became faster. It’s fast because of it underlying Architecture. Good architecture often matters more than the language itself.

Python is powerful, but it has one well-known limitation: the Global Interpreter Lock (GIL). Because of the GIL, only one thread can execute Python bytecode at a time inside a single process. This means that traditional multi-threaded web servers in Python often don’t scale efficiently for high-concurrency workloads, especially when thousands of requests are waiting for network or database responses. This is where FastAPI comes in. FastAPI is a modern Python web framework built on top of ASGI (Asynchronous Server Gateway Interface). Instead of relying on heavy threads for every request, FastAPI uses async programming with an event loop. Here’s the simple idea: • A request comes in • If the request is waiting for I/O (database, API call, file read) • The event loop pauses that task and switches to another request So instead of 1 thread per request, a single event loop can handle thousands of concurrent requests. Think of it like a waiter in a restaurant: A traditional threaded server: The waiter stands at one table until the food arrives. FastAPI async model: The waiter takes the order, moves to other tables while the kitchen prepares the food, and comes back when it's ready. Because of this: • Much lower memory usage • Higher concurrency • Faster APIs for I/O heavy applications • Better scalability FastAPI doesn’t remove the GIL, but it works around the limitation by avoiding thread blocking and using non-blocking asynchronous execution. That’s why FastAPI has become one of the fastest growing frameworks for building high-performance Python APIs. #fastapi #python #backenddevelopment #softwareengineering #asyncio #systemdesign #programming #webdevelopment #tech

Last week, the popular Python llm client library: litellm got hit by a supply chain attack[1]. Yesterday, it was the popular JS/TS HTTP client library axios[2]. If you’re doing any development / vibe-coding on your machine, a simple heuristic to avoid compromising it is to not install the latest versions of packages. Waiting 7 days is a reasonable tradeoff. The conservative bet is that any supply chain attacks on packages will be discovered and mitigated within a week. Package managers like uv (Python), and npm, pnpm (JS/TS) natively support this: uv: Add the following line to ~/.config/uv/uv.toml exclude-newer = "7 days" If you’re still using pip, you might want to consider using either uv’s pip interface “uv pip” or pipask instead. npm: Add the following to ~/.npmrc min-release-age=7 pnpm: Run pnpm update -rLi --config.minimum-release-age=10080 # 10,080 minutes in 7 days Or add the following to your pnpm-workspace.yaml file: minimumReleaseAge: 10080 [1]: https://lnkd.in/de8Pjztp [2]: https://lnkd.in/de8fhtH7

Unofficial Python API and agentic skill for Google NotebookLM. Full programmatic access to NotebookLM's features—including capabilities the web UI doesn't expose—via Python, CLI, and AI agents like Claude Code, Codex, and OpenClaw. https://lnkd.in/dUPanrdc

Python has a dirty secret. It will let you write broken code that runs perfectly fine. No errors. No warnings. No stack traces. Just wrong answers, silently, confidently wrong. Scope bugs are the #1 reason this happens. You think you're reading a local variable. Python is reading a global one. Your function returns a result. The result is garbage. And the interpreter couldn't care less. I've seen this trip up beginners on day 3. I've seen it trip up senior engineers on year 5. The fix isn't talent. It's knowing the rules Python plays by. So I wrote them down. All of them. In plain English. Get the free Python Scope Guide: https://lnkd.in/djp6HJdD Save it. Share it. Send it to that colleague who keeps asking why their variable "has the wrong value". #Python #Programming #SoftwareEngineering #PythonTips

💡 Understanding REST APIs while learning Python Backend While learning backend development with Python, I recently explored how REST APIs work using Flask. REST APIs allow different applications to communicate with each other using HTTP methods like GET and POST. For example: • GET can be used to retrieve data from the server • POST can be used to send new data to the server Using Flask, we can create routes that handle these requests and return responses in formats like JSON. This is how many modern web and mobile applications communicate with their backend services. Sharing a small example from my practice. Currently continuing to learn more about Flask, SQL, and backend development concepts. #Python #Flask #RESTAPI #BackendDevelopment #WebDevelopment

I once spent 3 hours debugging a Python script. The logic was right. The data was right. The tests were passing. But the output was wrong. Every. Single. Time. Turns out? A variable I thought was local was leaking from an outer scope. One line. Three hours. A lesson I never forgot. Scope bugs are brutal because Python doesn't yell at you, it just silently uses the wrong value. So I put together a free guide that breaks down exactly how Python scope works: → The LEGB rule, explained simply → The most common scope bugs (and why they're so sneaky) → How to read your own code the way Python reads it → global and nonlocal, when to use them, when to avoid them If you've ever been confused by a variable that "shouldn't" have that value... this guide is for you. Get it free here: https://lnkd.in/dY8az6hc Save this post. Your future self will thank you. #Python #SoftwareDevelopment #Programming #PythonTips #ChiefOfCode