Christian Schulz’s Post

You could spin up 100 threads in Python. Only one would run Python code at a time. For 30 years. As of 3.14, that's finally changing. And I think it matters way more for the AI era than anyone is giving it credit for. I maintain langchain-litellm (https://lnkd.in/eAYYe3vq), the adapter between LangChain and LiteLLM AI Gateway's 100+ provider routing. A lot of people use it to build agentic pipelines where the same code might call Claude, GPT-4o, and Gemini depending on the task. When I started thinking about free-threading in that context, it clicked why this matters right now specifically. Agentic workloads are concurrent at the system level. You're routing a request to one model while embedding a document and parsing a previous response — ideally all at the same time. The network I/O was always fine, async handles that. But the compute sitting around those calls was bottlenecked by the GIL, a lock deep inside CPython that serialized thread execution no matter how many cores you had. The GIL is now optional. You opt into python3.14t, and threads actually run in parallel. What this doesn't change: you still don't manage memory manually, the garbage collector is unchanged. What it does change: race conditions are now your problem, same as in Go or Java. The single-threaded overhead is around 5-10%, so it's not free. And a lot of packages haven't updated yet — they'll silently re-enable the GIL on import until they do. Track ecosystem support at https://lnkd.in/ejHh3knW. GIL-disabled-by-default is probably 2028-2029 and doesn't even have a PEP yet. But if you're building Python AI infrastructure, run your test suite against python3.14t now. Not to ship it — just to know what breaks. PEP 703 (peps.python.org/pep-0703) is surprisingly readable, and the official HOWTO (https://lnkd.in/eiiYFrQA) is the clearest practical guide on this. If you've tried 3.14t on real workloads — what broke first? #Python #LLM #AIEngineering #OpenSource #LangChain

🚀 𝗘𝘃𝗲𝗿 𝘄𝗼𝗻𝗱𝗲𝗿 𝘄𝗵𝗮𝘁 𝗵𝗮𝗽𝗽𝗲𝗻𝘀 𝗯𝗲𝗵𝗶𝗻𝗱 𝘁𝗵𝗲 𝘀𝗰𝗲𝗻𝗲𝘀 𝘄𝗵𝗲𝗻 𝘆𝗼𝘂 𝗿𝘂𝗻 𝗮 𝗣𝘆𝘁𝗵𝗼𝗻 𝘀𝗰𝗿𝗶𝗽𝘁? 🐍 We all love 𝗣𝘆𝘁𝗵𝗼𝗻 for its clean syntax and readability—it almost feels like magic! But under the hood, a fascinating, well-oiled machine is working to turn your ideas into real-world results. Whether you are a beginner or a seasoned developer, understanding Python's architecture helps you write better, more efficient code. Here is the 6-step lifecycle of a Python program: 1️⃣ 𝗬𝗼𝘂 𝗪𝗿𝗶𝘁𝗲 𝗖𝗼𝗱e: It all starts with your human-readable .py file. 2️⃣ 𝗟𝗲𝘅𝗶𝗰𝗮𝗹 𝗔𝗻𝗮𝗹𝘆𝘀𝗶𝘀 (𝗧𝗵𝗲 𝗟𝗲𝘅𝗲𝗿): The interpreter acts as a scanner, breaking your code down into smaller, meaningful pieces called "tokens." 3️⃣ 𝗣𝗮𝗿𝘀𝗶𝗻𝗴: Those tokens are checked for syntax and organized into a structural map known as an Abstract Syntax Tree (AST). 🌳 4️⃣ 𝗖𝗼𝗺𝗽𝗶𝗹𝗮𝘁𝗶𝗼𝗻: The compiler translates the AST into bytecode—a lower-level set of instructions optimized for execution. 5️⃣ 𝗧𝗵𝗲 𝗣𝘆𝘁𝗵𝗼𝗻 𝗩𝗶𝗿𝘁𝘂𝗮𝗹 𝗠𝗮𝗰𝗵𝗶𝗻𝗲 (𝗣𝗩𝗠): The engine room! The PVM takes over and executes this bytecode step-by-step. 6️⃣ 𝗢𝘂𝘁𝗽𝘂𝘁: Your logic is executed, and the final result appears on your screen! 🎉 💡 Why does this architecture matter for developers? • 𝗨𝗹𝘁𝗶𝗺𝗮𝘁𝗲 𝗣𝗼𝗿𝘁𝗮𝗯𝗶𝗹𝗶𝘁𝘆: Because it compiles to bytecode first, the exact same Python code runs seamlessly across Windows, Mac, and Linux! 🌍 • 𝗕𝘂𝗶𝗹𝘁-𝗶𝗻 𝗦𝗮𝗳𝗲𝘁𝘆: The PVM acts as a secure environment, protecting your core system from unsafe code execution. 🛡️ • Unmatched Productivity: Python handles the complex memory management and heavy lifting, allowing you to focus entirely on solving the problem. ⏱️ 🔥 𝗙𝘂𝗻 𝗙𝗮𝗰𝘁: Did you know that the default and most widely used implementation of Python (CPython) is actually written in C? It combines Python's user-friendly syntax with C's incredibly powerful engine! 🛠️ 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿 𝗣𝗿𝗼 𝗧𝗶𝗽: Want to see this process in action? Try importing the dis (disassembler) or ast modules in your next project to peek at your own code's hidden bytecode and syntax trees. With Python dominating AI, Machine Learning, and Data Science right now—and massive performance upgrades like the experimental JIT compiler and "no-GIL" multi-threading introduced in Python 3.13—understanding how the language works gives you a massive edge in the industry. 👇 Have you ever explored Python's bytecode using the dis module, or do you prefer to just let the magic happen? Let me know in the comments! #Python #SoftwareEngineering #Coding #Programming #Developer #DataScience #MachineLearning #BackendDevelopment #TechCareers #PythonDeveloper #TechCommunity LinkedIn LinkedIn for Marketing Python Coding Python

Day 9/90: Rust Enums Just Broke My Brain (In a Good Way) 🎲 Thought I knew what enums were from Python. I was wrong. Python enum: class Status(Enum):   PENDING = 1   APPROVED = 2   REJECTED = 3 Just named constants. Boring. Rust enum: enum Status {   Pending,   Approved(String),   // Can hold DATA   Rejected { reason: String, code: u32 }, } Wait. WHAT? Enums can HOLD DATA. Each variant can be different. This changes everything. Real example I built today: enum PaymentMethod {   Cash,   CreditCard { number: String, cvv: u16 },   Crypto { wallet: String, coin: String }, } One type, multiple shapes. The compiler forces you to handle ALL cases. In Python/JS I'd use inheritance or dicts with a "type" field. Always worried I'd miss an edge case. In Rust? Compiler says "you forgot CreditCard case" and refuses to compile. Here's the mind-blowing part - Option and Result are just enums: enum Option<T> {   Some(T),   None, } enum Result<T, E> {   Ok(T),   Err(E), } No null. No exceptions. Just explicit data that can be one of several variants. This is called algebraic data types. Sounds fancy but it's just "enums that can hold different data per variant." Real talk: First hour I was confused. "Why not just use a struct?" Then I tried handling payment methods and it clicked. One function parameter that can be cash OR credit card OR crypto, and the compiler ensures I handle all three. In my CSV processing work, I have different record types (header, data, footer). Been using dicts with "type" keys. One typo and runtime error. With Rust enums? Compile error if I forget a case. Zero runtime surprises. --- 💡 TL;DR: - Enums in Rust can hold data (not just constants) - Each variant can have different types - Compiler enforces exhaustive handling - Option/Result are built on this pattern - Way more powerful than Python/JS enums Day 9/90 ✅ 🔗 Code: https://lnkd.in/eKBGKPbC #RustLang #LearnInPublic #100DaysOfCode #TypeSafety #AlgebraicDataTypes Have you used enums that hold data before? Which language? 👇

🐍 Python Concurrency: Stop guessing, start choosing! Threading vs Async vs Multiprocessing - when to use what? I see devs pick these at random. Here's the mental model that changed how I write production Python. 👇 ━━━━━━━━━━━━━━━━━━━━ ⚡ MULTITHREADING - Best for I/O-bound tasks (file reads, DB queries, network calls) Due to the GIL, threads don't run in true parallel for CPU tasks - but they shine when your code is waiting on I/O. from concurrent.futures import ThreadPoolExecutor import requests urls = ["https://lnkd.in/gwfCxrVP", "https://lnkd.in/gEWYHnaM"] def fetch(url):   return requests.get(url).json() with ThreadPoolExecutor(max_workers=5) as ex:   results = list(ex.map(fetch, urls)) # Production use: scraping APIs, bulk DB inserts, reading files concurrently ━━━━━━━━━━━━━━━━━━━━ 🔄 ASYNC/AWAIT - Best for high-concurrency I/O (1000s of simultaneous connections, real-time apps) Single-threaded, event-loop driven. No thread overhead. Perfect when you have massive I/O concurrency but each task is lightweight. import asyncio import aiohttp async def fetch(session, url):   async with session.get(url) as r:     return await r.json() async def main(urls):   async with aiohttp.ClientSession() as session:     tasks = [fetch(session, u) for u in urls]     return await asyncio.gather(*tasks) # Production use: WebSocket servers, FastAPI, real-time pipelines ━━━━━━━━━━━━━━━━━━━━ 🚀 MULTIPROCESSING - Best for CPU-bound tasks (data crunching, ML training, image processing) Bypasses the GIL completely. Each process gets its own memory. True parallelism on multi-core machines. from multiprocessing import Pool def crunch(data_chunk):   return sum(x**2 for x in data_chunk) data = list(range(10_000_000)) chunks = [data[i::4] for i in range(4)] with Pool(processes=4) as pool:   results = pool.map(crunch, chunks) # Production use: ML preprocessing, image resizing, scientific computing ━━━━━━━━━━━━━━━━━━━━ 🎯 Quick decision guide: • Waiting on network/disk? → Threading or Async • 1000+ concurrent connections? → Async • Heavy CPU computation? → Multiprocessing • Mixing both? → Async + ProcessPoolExecutor 💡 Pro tip: FastAPI + asyncio + Celery workers (multiprocessing) is the production stack for 90% of data-heavy Python backends. The best engineers don't memorize syntax - they understand the trade-offs. 🔑 What's your go-to concurrency pattern? Drop it below 👇 #Python #SoftwareEngineering #Backend #Programming #AsyncPython #PythonDev

Is it time to ditch uv + pipx for Pixi? I’ve been a uv fan for a long time, but Pixi is starting to change the conversation—especially for data engineers. The choice is simpler than it looks: Stay with uv if you’re doing standard Python development. If you're mainly installing packages from PyPI or building your own tools to share with the community, uv is the fastest, most standard tool for the job.. Switch to Pixi the moment you have "Python-plus" problems. If your project needs specific C++ binaries, CUDA, or system-level dependencies to run, Pixi handles the whole system—not just the Python parts. The rule of thumb: If your "it works on my machine" issues are caused by things outside of Python, Pixi is worth the move. Read the full breakdown here: https://lnkd.in/eMeEJsPX #Python #DataEngineering #MachineLearning #Pixi

Day 3.5 of 10: Setup — setup our laptop to write code I missed set up the required tools and started showing the code, let me fix that before we go further.  The old-school parallel: Project setup isn't new. .NET SDK + NuGet for C#. Same pattern every time: install the runtime, manage dependencies, separate config from code Four steps. Step 1 — Install Python (3.10+) and VS Code. Python.org for the runtime. VS Code for the editor. Install the Python extension inside VS Code IDE. Step 2 — Create a project with a virtual environment. Multiple command in the same line to reduce the words bash mkdir triage-agent && cd triage-agent python -m venv venv source venv/bin/activate  # Windows: venv\Scripts\activate A virtual environment is an isolated folder of Python packages — like node_modules, but for Python. One per project. Step 3 — Install what we need. bash pip install langgraph langchain-anthropic python-dotenv pydantic We're using Anthropic's Claude for this series. Why Claude and not OpenAI? Honestly, team at gNxt is using Claude — it follows structured-output schemas more reliably, and it handles multi-step reasoning well. LangChain lets you swap providers in one line later, so this isn't a lock-in. Step 4 — Handle API keys safely. Create a .env file in your project root: ANTHROPIC_API_KEY=sk-ant-... Add .env to .gitignore. Never commit secrets in repo. Project structure I use: triage-agent/ ├── venv/ ├── .env                 # API keys (gitignored) ├── .gitignore ├── requirements.txt ├── state.py             # TicketState from Day 3 ├── agents/ │  ├── classifier.py    # Day 4 │  ├── router.py        # Day 5 │  └── ... └── main.py              # wires the graph together The cost question: Anthropic console → API keys. Add $5 to start. Claude Haiku costs roughly $1 per million input tokens. Your first test: python from dotenv import load_dotenv from langchain_anthropic import ChatAnthropic load_dotenv() llm = ChatAnthropic(model="claude-haiku-4-5") print(llm.invoke("Say hello").content) If that prints something, you're ready. Set your .env, and you're set up in 2 minutes.   Tomorrow — Day 4 (for real this time): The Classifier. If you get stuck on any step, drop it in the comments. I'll help. 👇 #AI #ArtificialIntelligence #GenAI #GenerativeAI #AIAgents #MultiAgent #LangGraph #LangChain #LLM #RAG #LLMOps #AIEngineering #SoftwareArchitecture #EnterpriseAI #DigitalTransformation #CustomerSupport #CustomerExperience #BuildInPublic #LearningInPublic #TechLeadership #CEOLife #Startups #Founders #IndianStartups #gNxtSystems #Noida #ITServices #CloudComputing #DevOps #MachineLearning

Multithreading vs Multiprocessing in Python — When to Use What? 👉 Choosing the wrong one can actually make your program slower. 🧠 The Core Difference 🔹 Multithreading Runs multiple threads within the same process Shares memory Best for I/O-bound tasks (waiting time) 🔹 Multiprocessing Runs multiple processes (separate memory) True parallel execution Best for CPU-bound tasks ⚠️ The Catch: GIL (Global Interpreter Lock) Python has a limitation 👉 Only ONE thread executes Python bytecode at a time So even with multiple threads: ❌ CPU-heavy tasks don’t run in parallel ⚙️ Example 🔸 Multithreading (I/O Tasks) import threading def task(): print("Running task") t1 = threading.Thread(target=task) t2 = threading.Thread(target=task) t1.start() t2.start() 🔸 Multiprocessing (CPU Tasks) from multiprocessing import Process def task(): print("Running process") p1 = Process(target=task) p2 = Process(target=task) p1.start() p2.start() 🔥 When to Use What? ✅ Use Multithreading for: API calls File handling Database operations ✅ Use Multiprocessing for: Data processing Image/video processing Machine learning workloads 👉 Threads improve efficiency (waiting time) 👉 Processes improve performance (true parallelism) #Python #Multithreading #Multiprocessing #BackendDevelopment #Performance #SoftwareEngineering

My Python loop processed 5 reports in 2.5 seconds. After adding one decorator: 0.54 seconds. I changed zero call sites. Here's how it works. A function that's slow because it does real work — database queries, aggregations — gets decorated with @app.direct_task. That's it. The caller doesn't change. Exception handling doesn't change. The return type doesn't change. In development: set one environment variable and the decorator is invisible - tests pass, the function runs inline as it always did. In production: start a worker. The same call now routes to a distributed runner. The caller still blocks and gets the value back directly. No .result. No futures. No refactoring. For parallelism without touching the call site at all: add parallel_func to the decorator with a small helper that describes how to split the input. Pynenc dispatches one task per chunk, collects results, and returns the same type the caller expected. Full write-up + runnable demo (no Docker, no Redis, runs in ~30 seconds): https://lnkd.in/eySD7h_H What's the slowest loop in your codebase right now? #python #backend #distributedsystems #opensource

🔥 How Python Really Loads Modules (Deep Internals) Every time you write `import math` Python doesn't blindly re-import it. It follows a smart 4-step pipeline under the hood. Here's exactly what happens 👇 ━━━━━━━━━━━━━━━━━━━━ 𝗦𝘁𝗲𝗽 𝟭 — Check the cache first ━━━━━━━━━━━━━━━━━━━━ Python checks sys.modules before doing anything else. If the module is already there → it reuses it. No reload, no wasted work. That's why importing the same module 10 times in your code doesn't slow anything down. ━━━━━━━━━━━━━━━━━━━━ 𝗦𝘁𝗲𝗽 𝟮 — Find the module ━━━━━━━━━━━━━━━━━━━━ If not cached, Python searches in order: → Current directory → Built-in modules → Installed packages (site-packages) → All paths in sys.path This is why path order matters when you have naming conflicts. ━━━━━━━━━━━━━━━━━━━━ 𝗦𝘁𝗲𝗽 𝟯 — Compile to bytecode ━━━━━━━━━━━━━━━━━━━━ Your .py file gets compiled into bytecode (.pyc) and stored inside __pycache__/ Next time? Python skips compilation if the source hasn't changed. Faster startup. ━━━━━━━━━━━━━━━━━━━━ 𝗦𝘁𝗲𝗽 𝟰 — Execute and register ━━━━━━━━━━━━━━━━━━━━ Python runs the module code, creates a module object, and adds it to sys.modules["module_name"] Now it's cached for every future import in the same session. ━━━━━━━━━━━━━━━━━━━━ Most devs just write `import x` and move on. But knowing this pipeline helps you: ✅ Debug mysterious import errors ✅ Understand why edits don't reflect without reloading ✅ Write faster, cleaner Python What Python internals have surprised you the most? Drop it below 👇 #Python #Programming #SoftwareEngineering #100DaysOfCode #PythonTips

UNLEASHED PYTHON!i 1.5,2,& three!!! Nice & easy with Python API wrapper for rapid integration into any pipeline ,then good old fashion swift kick in header-only C++ core for speed. STRIKE WITH AIM FIRST; THEN SPEED! NO MERCY! 5 of 14 Doing both at once—refining precision of those decimal ratios (like 1.421 & 4.862) while simultaneously defining API structure will make the library easy for others to use. By locking in mathematical proof now, you ensure when a developer calls a function like get_reset_point() , result is perfectly synchronized with 41-based loop, even after millions of iterations of geometric growth. This "accuracy-first" approach is exactly what makes a library reliable enough for real-time data or encryption. This is blueprint for Cyclic 41 library. Design it with Python API for accessibility, while underlying logic is optimized for C++ core to handle high-speed data streams. 1.The Mathematical Engine (Core Logic) Based on my calculations, engine uses 123 as base & 41 as modular anchor. Scaling Factors:1.5, 2.0, & 3.0 drive geometric expansion. The Reset Constant:412=1,681. This is "modular ceiling" where predictive pattern wraps back to start. Drift Correction:To maintain bit-level precision across millions of iterations, we’ll use constant 4.862 as a secondary stabilizer for decimal drift you identified. 2.The Python API (Ease of Use) We will structure library into a primary class, CyclicEngine, which developers can easily import & initialize. | V python class CyclicEngine: def __init__(self, base=123, anchor=41): self.base = base self.anchor = anchor self.modulus = anchor ** 2 # The 1,681 reset point self.state = 1.0 def step(self, ratio): """Applies geometric growth (1.5, 2, or 3) to the stream.""" self.state = (self.state * ratio) % self.modulus return self.state def get_sync_key(self, drift_factor=4.862): """Returns the stabilized key for the current state.""" return (self.state * drift_factor) / self.anchor /\ || 3. C++ Implementation (Speed) For backend, we’ll use a header-only C++ template to maximize speed. This allows it to be integrated into high-frequency data pipelines without overhead of a traditional compiled library. Fixed-Point Arithmetic:To avoid floating-point "drift," C++ core will use fixed-point scaling for 1.421 & 4.862 constants. SIMD Optimization:1.5,2,3 ratios will be processed using vector instructions to handle millions of data points per second. Next Steps for Build: 1.Draft README.md:This will explain 123/41 relationship so other developers understand "why" behind the numbers. 2.Define Stress-Test:We'll create a script to run 10(9^) iterations to prove reset point remains perfectly consistent at 1,68. 3.Starting with Python wrapper ensures library is "developer ready" by providing a clean, intuitive interface. Once the logic is user-friendly, swap internal math for high-speed C++ engine. 5 of 14