Banias Baabe’s Post

Stop passing the same variable through five different functions in Python. We have all been there. You need a user ID in a deeply nested database call. So you clutter up every single function signature just to pass it down. Thread local storage used to be the classic workaround for this problem. But modern asynchronous programming breaks thread locals entirely. If async task A pauses and task B takes over, they share the same underlying thread. That means they suddenly share the same thread local variables. This is a fast track to silent data corruption in concurrent applications. Try the Python 𝗰𝗼𝗻𝘁𝗲𝘅𝘁𝘃𝗮𝗿𝘀 module. It solves this by storing state that is strictly bound to your current asynchronous task. You simply declare a 𝗖𝗼𝗻𝘁𝗲𝘅𝘁𝗩𝗮𝗿 object at the top of your module. When a new web request arrives, you use the set method to store the request data. Any function running inside that specific task can then use the get method to retrieve it. Even if a hundred other concurrent tasks are running, they will only see their own isolated values. You get the convenience of global access without the nightmare of shared global state. Your function signatures stay clean and focused on their actual business logic. --- ♻️ Found this useful? Share it with another builder. ➕ For daily practical AI and Python posts, follow Banias Baabe.

🚀 Building a Simple Encrypted Messaging Tool in Python. In movies, spies use encrypted messages and I thought to myself about creating a simple Python tool that lets you encrypt and decrypt messages using a password-based key. It’s a great way to explore Python binary data types, i.e., bytes, bytearray, and memoryview. Here’s what I experimented with: Bytes & Bytearray: I split messages into halves and converted them into bytearray to apply custom shifts. This allowed low-level manipulation of each byte before encryption. Binary & Hexadecimal Shifts: Each character is represented in 8-bit binary, and I performed arithmetic shifts to scramble the message, demonstrating how raw binary can be transformed. Fernet Encryption: After manipulating bytes, I wrapped the message in Fernet, which expects data as bytes, ensuring secure encryption that can be reversed with the correct password. 🛠 Outcome The result is a small Python messaging tool where one can type a message, provide a password and encrypt or decrypt it. The app handles all low-level byte manipulations behind the scenes, providing a secure and user-friendly interface.

Now, let's build another Python Project: *🚀 Project 7: Password Generator 🔐* *🎯 Project Goal* Build a tool that generates a strong random password using letters, numbers, and symbols, with user-defined length. *🧠 Basic Structure* - random module → generate random characters - string module → get letters, digits, symbols - loop → build password - input → take length from user *💻 Python Code* ``` import random import string def generate_password(length): characters = string.ascii_letters + string.digits + string.punctuation password = "" for _ in range(length): password += random.choice(characters) return password length = int(input("Enter password length: ")) password = generate_password(length) print("Generated Password:", password) ``` *🧠 Explanation (Step-by-step flow)* 1. Character Pool: Combines letters (a-z, A-Z), digits, and symbols for a strong password. 2. Password Generation: Loop runs for given length, picking a random character each time. 3. Function Usage: `generate_password()` makes code reusable. 4. User Input: User controls password length. *🚀 Outcome* - Work with built-in modules (random, string) - Generate secure data - Build utility tools - Write reusable functions *Double Tap ❤️ For More*🚀

Understanding Python Objects: Mutability, Identity, and Function Arguments Introduction In this project, we explored how Python treats objects, focusing on identity, mutability, and how arguments are passed to functions. These concepts are fundamental to writing reliable and efficient Python code. id and type Every object in Python has an identity (id) and a type. The id represents the memory address where the object is stored, and the type tells us what kind of object it is. For example: IMAGE BELOW Objects with the same value may or may not share the same identity depending on how Python manages them. Mutable objects Mutable objects can be changed after creation. Lists are a classic example: IMAGE BELOW Here, both l1 and l2 point to the same list, so modifying one affects the other. Immutable objects Immutable objects cannot be changed after creation. Integers and tuples are immutable: IMAGE BELOW This produces a new tuple rather than modifying the original. Why does it matter? Understanding mutability and immutability is crucial because Python treats them differently. Mutating an object keeps its identity, while reassigning creates a new object. This distinction affects performance, memory usage, and program behavior. Function arguments When passing arguments to functions, Python passes references to objects. For mutable objects, changes inside the function affect the original: IMAGE BELOW For immutable objects, reassignment inside the function does not affect the original: IMAGE BELOW Conclusion By mastering these concepts—identity, mutability, immutability, and argument passing—you gain deeper insight into Python’s object model. This knowledge helps avoid subtle bugs and write more predictable, efficient code.

In Python, multithreading and multiprocessing are two powerful ways to run tasks concurrently. Multithreading: Runs multiple threads within the same process, sharing memory. Ideal for I/O-bound tasks like file reading, web scraping, or network requests. Multiprocessing: Runs multiple processes in parallel, each with its own memory. Perfect for CPU-bound tasks like heavy computations, data processing, or machine learning training. 💡 Key Takeaways: GIL Awareness: Python’s Global Interpreter Lock (GIL) allows only one thread to execute Python bytecode at a time, limiting parallelism for CPU-heavy tasks. Memory Usage: Threads share memory, making them lightweight; processes use separate memory, which increases overhead but avoids GIL limitations. Task Suitability: Multithreading → I/O-bound tasks Multiprocessing → CPU-bound tasks Communication: Threads communicate easily via shared memory; processes communicate via queues, pipes, or other IPC mechanisms. Performance Boost: Using the right approach can drastically reduce execution time and make your applications scalable. Error Isolation: Errors in one process don’t crash others; threads are more sensitive to shared state issues. Python Libraries: threading for multithreading multiprocessing for multiprocessing Practical Example: Downloading multiple files → multithreading Image processing for large datasets → multiprocessing 🔥 Mastering concurrency in Python helps you write faster, smarter, and scalable programs! Manivardhan Jakka GALI VENKATA GOPI 10000 Coders Aravala Vishnu Vardhan

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

Why Python Had the Global Interpreter Lock (GIL) Initially? 1. Reference Counting Memory Management Python uses reference counting to manage memory. Every object tracks how many variables point to it. The problem was with threads, without the GIL, you'd need a lock on every single object to protect its reference count — which would be enormously complex and slow. The GIL solves this with one simple lock instead of millions of per-object locks. 2. Historical Context — 1991 When Guido van Rossum created Python: a. Multi-core CPUs didn't exist for consumers — single core was the norm b. Threading was rare and mainly used for I/O, not CPU parallelism c. The GIL had zero real cost in that environment d. Making CPython simple and portable was the priority 3. It Made C Extensions Easy & Safe Python was designed to be easily extensible with C. The GIL meant: a. C extension authors didn't need to worry about thread safety b. Massive ecosystem of C extensions grew up assuming GIL protection Now Python has introduced Free-Threaded mode. What is Free-Threaded Mode? Free-Threaded mode (introduced experimentally in Python 3.13) is a build of CPython that removes the GIL, allowing multiple threads to run Python code truly in parallel across multiple CPU cores. It's also called "NoGIL" mode. Caveats & Risks a. Thread safety is now your job — you need locks/mutexes for shared data b. C extensions may not be compatible — many assume the GIL protects them c. ~5–10% slower in single-threaded code due to fine-grained locking overhead d. Popular libraries (NumPy, etc.) are gradually adding free-threaded support Why It Matters This is one of the biggest changes in Python's history. It opens the door to: a. True parallel data processing b. Better performance on multi-core servers c. Python competing more seriously with Go/Rust for concurrent workloads Note: Python version 3.14 is officially supported or you can say more stable for Free-Threaded Mode as compare to Python 3.13 which is considered as Experimental for NoGIL.

The Tidyverse is a Ferrari, but Python reminded me that I still need to know how the internal combustion engine works 🏎️ I’ve been using R for years and I thoroughly enjoy it but while working through DTSC 575 Principles of Python Programming, I hit a realization: 𝑰’𝒗𝒆 𝒃𝒆𝒆𝒏 𝒎𝒆𝒎𝒐𝒓𝒊𝒛𝒊𝒏𝒈 "𝒗𝒆𝒓𝒃𝒔" 𝒊𝒏𝒔𝒕𝒆𝒂𝒅 𝒐𝒇 𝒍𝒆𝒂𝒓𝒏𝒊𝒏𝒈 "𝒍𝒐𝒈𝒊𝒄." In the Tidyverse, we have a verb for everything. ✅ Need to change a column? 𝘮𝘶𝘵𝘢𝘵𝘦() ✅ Need to filter rows? 𝘧𝘪𝘭𝘵𝘦𝘳() It’s elegant, fast, and readable. But it’s not all gravy 😭 If you rely solely on these abstracted "verbs," you’re essentially learning proprietary slang. Those skills stay siloed. Which means that when you venture out of R and into Python, SQL, or what have you……those verbs disappear. During my Python course, I had to:  📍 Create custom functions & applications 📍 Loop over strings manually 📍 Count indexes 📍 Perform functions based on strict conditional logic It felt clunky at first and I constantly questioned: why loop when I can just pipe (%>%)? But as Norman Matloff often argues, 𝑩𝒂𝒔𝒆 𝑹 (𝒂𝒏𝒅 𝒇𝒐𝒖𝒏𝒅𝒂𝒕𝒊𝒐𝒏𝒂𝒍 𝒑𝒓𝒐𝒈𝒓𝒂𝒎𝒎𝒊𝒏𝒈) 𝒊𝒔 𝒄𝒍𝒐𝒔𝒆𝒓 𝒕𝒐 𝒕𝒉𝒆 𝒎𝒆𝒕𝒂𝒍. The "clunky" logic of loops and custom functions isn't necessarily just task solving.....you're building a universal mental framework. 𝐖𝐡𝐲 𝐝𝐨𝐞𝐬 𝐭𝐡𝐢𝐬 𝐦𝐚𝐭𝐭𝐞𝐫 𝐟𝐨𝐫 𝐇𝐞𝐚𝐥𝐭𝐡𝐜𝐚𝐫𝐞 𝐃𝐚𝐭𝐚 𝐚𝐧𝐝 𝐄𝐑𝐏𝐬? Because systems like Infor or Altera Paragon don't always give you a "verb" to fix a broken interface or a data mapping error. They require you to understand the underlying flow or the "If/Then" of the data. I’m realizing now that: 💡Verbs make you fast. 💡Logic makes you 𝐟𝐮𝐭𝐮𝐫𝐞-𝐩𝐫𝐨𝐨𝐟. Understanding the "clunkier" Base R/Python principles means you can take your talents into any language, not just the one with the best shortcuts. Maybe the goal isn’t just to write code that works today but rather to build a foundation that lasts a lifetime by serving you well regardless of the syntax or language.

Python is an interpreted, high-level programming language created by Guido van Rossum in 1991. It is widely utilized for web development, data analysis, automation, and artificial intelligence. An interpreter executes code line-by-line without the need for compilation. Python uses CPython as its default interpreter, which allows for faster development but has a slower runtime compared to compiled languages. Variables in Python are named storage for data values and are dynamically typed, meaning their type is inferred at runtime. For example: - age = 30 (int) - name = "Bonus" (str) Python includes several built-in data types such as int, float, str, bool, list, tuple, dict, and set. Mutable types like list, dict, and set can change their contents, while immutable types like int, str, and tuple cannot be modified after creation. A list is an ordered, mutable collection of items that allows duplicates and is indexed from 0. For example: customers = ["A", "B", "A"]. A dictionary consists of unordered key-value pairs (ordered since Python 3.7), where keys are unique and values can be of any type. For example: user = {"id": 1, "name": "Bonus"}. Key differences between lists and tuples include: - Lists are mutable (denoted by []), while tuples are immutable (denoted by ()). - Lists are generally slower, whereas tuples are faster and hashable. - Use tuples for fixed data, such as coordinates. Loops in Python include: - For loops, which iterate over sequences (e.g., for i in range(5)). - While loops, which are condition-based (e.g., while x < 10). These constructs are essential for repeating tasks efficiently. Functions are reusable code blocks defined with the keyword def. They can take parameters and return values. For example: def greet(name): return f"Hello {name}"