Mohamed Boughattas’ Post

Day 3 of my Python journey, and I’ve officially hit my first "ego check." Yesterday, I thought I had a simple Even/Odd script figured out. I was wrong. It turns out the computer doesn't care what I meant; it only cares what I wrote. ❌ Moving into Day 3, I’ve been studying the "Laws of the Python Universe" to stop guessing and start structuring: 🔹 The Hierarchy of Operations: I learned that 1 + 2**3 / 4 * 5 isn’t just a string of numbers—it’s a sequence. Python doesn't just read left-to-right; it respects a hierarchy (PEMDAS). If you ignore the order of operations, your data is junk before you even hit 'Enter.' 🔹 The "Wait" State: I built a simple script to convert European floor numbers to US floors. It’s a basic + 1 calculation, but it taught me about "Blocking Calls"—how the program literally pauses its entire existence to wait for the user to provide data. The biggest takeaway? Coding isn't about memorizing syntax; it's about debugging my own thought process. I’m learning that "clean code" starts with a "clear mind." Day 4 is up next. Let’s see if I can outsmart the compiler tomorrow. 🐍 #Python #LearningToCode #BuildInPublic #SoftwareLogic #TechJourney #DataScience

Tired of manually copying event details from flyers into your calendar? I just published a new article on Medium showing how to automate this task using Python, VSCode, and Llama's local GLM-OCR vision model. In this tutorial, you'll learn how to build a 100% free, private, and offline tool to extract structured JSON data from images in less than 100 lines of code. Check out the full guide here: https://lnkd.in/ewSamveh #Python #AI #Automation #Ollama #Coding #LLM

I recently conducted a benchmark comparing Python 3.13 and 3.14 on the same CPU-heavy task, initially out of curiosity. The results were surprising; the performance difference was significant and has changed my perspective on parallelism in Python. While optimizing a CPU-bound data pipeline, my usual approach was to use ProcessPoolExecutor. Although it effectively handles tasks, the OS-level process spawn cost can accumulate quickly. Python 3.14 introduced a new option: InterpreterPoolExecutor. This allows for multiple isolated Python interpreters within the same process, eliminating GIL conflicts. I benchmarked the performance of Python 3.13 versus 3.14 as follows: ───────────────────────────────────────── 📊 1. HEAVY CPU TASKS (8 tasks, 4 workers) 🔴 Threads: 2.519s (GIL serializes everything) 🟠 Processes: 1.222s (parallel, but costly to spawn) 🟢 Subinterpreters: 1.130s (parallel and lighter) ───────────────────────────────────────── ⚡ 2. STARTUP COST (50 tiny tasks, where it really shows) 🟠 Processes: 0.271s 🟢 Subinterpreters: 0.128s (about 2x faster to start) 📈 3. SCALING (1 → 8 workers) 🔴 Threads: flatlined at ~1.9s (no real scaling benefit) 🟢 Subinterpreters: 2.16s → 0.91s (close to linear scaling) ───────────────────────────────────────── The key takeaway is that we can achieve process-level parallelism with thread-like startup speed, without GIL contention or extra process memory overhead, all within the standard library. Are you still using ProcessPoolExecutor for CPU-bound work? I am genuinely interested in whether subinterpreters could be a practical improvement in your stack. #Python #Python314 #SoftwareEngineering #Performance #Concurrency #BackendDevelopment #DataEngineering

I built a Python automation engine that can hit 11ms reaction times. ⚡ To put that in perspective, the average human reaction time is about 250ms. Macro Studio is responding to screen changes before a human brain could even register that something happened. If you've ever tried building a high-speed desktop bot in Python, you know the struggle. Standard libraries are great for simple tasks, but the moment you try to scale up, time.sleep() bottlenecks your logic, and managing OS threads usually ends up freezing your UI thanks to the Global Interpreter Lock (GIL). I wanted an engine that actually respected Python's capabilities while providing ultimate control, so I built it myself. I’m excited to share Macro Studio. It’s a free, open-source automation framework I developed that bridges the gap between simple macro recorders and complex software development. Instead of heavy OS threads, it uses a cooperative multitasking yield architecture and direct GDI polling. The result? High-frequency pixel retrieval that easily averages superhuman reaction times on the Human Benchmark, while keeping the UI and subsequent tasks completely responsive. Because it runs pure Python, the possibilities are infinite. You can hook in OpenCV, ping external APIs, or integrate LLMs directly into your automation loop. Check out the full showcase below demonstrating how it flawlessly navigates complex game environments (like Roblox). Building this architecture from the ground up has been an incredible month-long side project. I'm keeping it 100% free and open-source under GPLv3 for anyone who wants to build high-performance macros without the paywalls. I've dropped a link to the YouTube showcase, the GitHub repository, and the documentation in the comments below. 👇 Drop a star, build something ridiculous, and let me know what you think of the architecture! #Python #SoftwareDevelopment #OpenSource #Automation #ComputerScience

Python isn’t just a programming language. It’s a complete ecosystem that powers data science, machine learning, web development, automation, and more. With libraries like Pandas for data analysis, Scikit-learn and TensorFlow for machine learning, FastAPI and Django for backend systems, and OpenCV for computer vision, Python makes it possible to build real-world, scalable solutions using a single language. The real strength of Python is its versatility. One skill can open doors to multiple fields, from AI engineering to backend development and automation. Still learning. Still building. 🚀 . . . #Python #MachineLearning #ArtificialIntelligence #DataScience #SoftwareDevelopment

Navigating the Infinite Structures of Logical Loops in Python! 💻🌀 The journey of mastering Data Science isn't always a linear path; sometimes, it requires dynamic, repeating, and branching structures. Day 5 was a significant milestone: understanding and applying Python Loops (For and While). These fundamental concepts are the exact groundwork I need to process massive datasets and iterate efficiently: 🔄 FOR Loop: Iterating through structures. A clean, defined pathway that processes an entire set of data—like a cascading aqueduct of items. I visualized this structure iterating through geometric data blocks (10, 20, 30, 40). ⚖️ WHILE Loop: Condition-based mastery. Creating dynamic cycles that continue only as long as a condition holds true (WHILE count < 3). This isn't just repetition; it’s decision-making within the loop. I applied these structures to process large list data and simulate dynamic logical cycles. Moving from simple linear code to optimized, looping logic is how I’m preparing for scalable Machine Learning pipelines down the road. Consistency beats talent when talent doesn't iterate! I've organized these new logical structures and pushed the optimized code to my GitHub. Check out my logic mastery here: **** 🔗 How did you find mastering logical structures like loops? Did you find visualizing the condition-based cycles the hardest part? Let me know in the comments! 👇 #DataScience #Python #100DaysOfCode #MasaiSchool #IITMandi #TechJourney #CareerGrowth #LogicMastery #IterationPath #PythonLoops #MLOps #Consistency

Quick check: what’s the type of bin(10)? int? float? Something else? It’s str. bin(), oct(), and hex() always return strings. That’s why bin(10) + 5 fails and why you use int(bin(10), 2) when you need a number again. I wrote a complete guide to Python base conversion functions so you can: ✓ Use bin(), oct(), and hex() correctly ✓ Know they return strings (and convert back when needed) ✓ Avoid float/complex (only int and bool work) ✓ Fix the usual mistakes and read the common errors ✓ See practical use (e.g. colors, permissions) and try exercises ~23 min read, with examples and solutions. Link: https://lnkd.in/dnUxjXBB #Python #LearnPython #Programming #Tech

#Python + #Agents starts in less than a week! Join us in a new series of 6 livestreams where we'll explore the fundamental concepts for creating AI agents in Python using the #MicrosoftAgentFramework. This series is for anyone who wants to understand how agents work, including how they make tool calls, how they use memory and context, and how to build workflows on top of them. Over two weeks, we'll delve into the practical building blocks that define the real-world behavior of an agent. 🔗 Register here: https://msft.it/6048QdZny See you in class! #MSFTAdvocacy

A small helper tool. This is very much an early early “release” if it can even be called that, but I know that if I go off to make it an actual fortified repo, I’ll get busy and forget about it. The biggest problem it aims to tackle: processing large video datasets into a manageable, streamlined format whilst remaining and being built primarily in python. #opensource #opensauce #dohashtagsdoanythingonlinkedin #computervision

🧠 Python Feature That Makes Type Checking Smarter: typing.Protocol Duck typing… but official 🦆✨ 🤔 The Problem 💻 Python is dynamically typed. 💻 But sometimes you want structure without inheritance. ❌ Traditional Way class Bird: def fly(self): ... def start_flying(bird: Bird): bird.fly() This forces inheritance. ✅ Pythonic Way with Protocol from typing import Protocol class Flyable(Protocol): def fly(self) -> None: ... def start_flying(obj: Flyable): obj.fly() 💫 Now ANY object with fly() works. 💫 No inheritance required 🎯 🧒 Simple Explanation 🦆 If it quacks like a duck and walks like a duck… 🦆 it doesn’t need to be a Duck class. 🦆 That’s Protocol. 💡 Why This Is Powerful ✔ Structural typing ✔ Cleaner architecture ✔ Better static analysis ✔ Used heavily in modern Python frameworks ⚡ Real Example class Drone: def fly(self): print("Flying") start_flying(Drone()) # Works! 🐍 Python believes in behavior, not hierarchy 🐍 typing.Protocol makes duck typing formal and powerful. #Python #PythonTips #PythonTricks #AdvancedPython #CleanCode #LearnPython #Programming #DeveloperLife #DailyCoding #100DaysOfCode