Marcelo Barbosa’s Post

If you want to run your Python programs up to 10x faster without altering your code, the new free threading version of Python just changed the game. Yes, Python 3.14 frees up the Global Interpreter Lock (GIL), bringing true parallelism and significant performance gains. In my latest article on the Towards Data Science blog, I cover: - How to download GIL-free Python 3.14 - Benchmarks showing up to 10x faster performance for some operations - Practical code examples you can run today If you’ve ever hit performance limits with Python’s Global Interpreter Lock, this release is a big deal. Read the full article for FREE using the link below. https://lnkd.in/e4TTMphY

YESSS, PYTHON IS FASTER NOW! Python 3.14 can now run some programs much faster using the GIL-free build: Reading files or doing I/O tasks → 3x faster Doing heavy math or CPU tasks → 10x faster But remember, Python is Python. It still slower than some other languages if you need top speed. 💡 Tips for programmers: If you want to build games or very fast programs, use C or C++ If you want to make backend systems or websites that handle many users, use Go If you want to work on AI, machine learning, data science, or make projects quickly, use Python Always choose the right language for the job. #Python314 #Programming #GILFree #AI #ML #Backend #HighPerformance

How bit is the impact of the end of GIL in Python though, for most people? For embarrassingly parallel loads, you could use threading for a while (see link to my year-old post showing one way to do it, with code, in the first comment). Can you think about a case when you thought "Oh, threading would be nice here" that wasn't embarrassingly parallel?

A nice step towards making recursive actions a bit faster. As noted, good numpy broadcasting is still faster, but there is a way forward to speed things up. Looking at Tom's example, I think he could break apart matrices along one outside dimension and THEN use broadcasting to handle large matrices.

The Biggest Misconception About Python Many people assume Python is inherently “slow.” The truth is more nuanced: Python itself isn’t magically slow—performance often comes down to the logic developers choose. In the backend, Python still handles memory and executes operations that cost time and resources, just like C++ or Java. One-liners or convenient constructs can hide expensive operations, making code inefficient if you’re not mindful. At the same time, Python shines when using optimized libraries like NumPy, Pandas, or TensorFlow, which handle heavy computation efficiently in compiled code under the hood. Python’s strength is its productivity, readability, and ecosystem, but careful design is key to keeping it performant. Have you ever been surprised by Python code that seemed “easy” but ran slow? How did you optimize it?

Hello! 😊 I got inspired to write this because Python 3.14 was just released two weeks ago, and now we can use Free-threaded Python. 😁 If you’ve ever wondered why Python doesn’t fully use multiple CPU cores — or what the Global Interpreter Lock really does — this one’s for you. I wanted to explain it in a clear, friendly way, so you can actually feel how the GIL impacts concurrency and performance. Whether you’re building high-performance APIs, working with async code, or just curious about how Python runs behind the scenes — I think you’ll enjoy this one. 👉 Check it out here: https://lnkd.in/ehmGHk_x And I promise — my next article will dive deep into asyncio itself: how it works under the hood, and how to truly take advantage of it in your Python apps. 🤓 #python #performance #asyncio #gil #threading #hcp

Python’s GIL is on its way out! One of the most controversial features in Python is finally taking a turn. On October 7 — while we (Israelis) were occupied with more important things — Python released version 3.14, which now lets you install CPython (the official Python) without the GIL. A PEP is basically a design document for features people want to add to Python (anyone can write one). PEP 703 passed the second stage of the council — meaning it’s a stable feature that ships with Python, just not as the default yet (that’s stage 3). So why did the GIL annoy so many people? Basically, because it disturbs asynchronous and parallel work. In Python with GIL, you can’t do multi-threaded parallel work — the lock (GIL = Global Interpreter Lock) blocks it. It was originally done this way to avoid complex thread-safety issues and make the single thread python faster, but it came with a price people we'rent happy to pay. With the new feature, a single thread actually runs a bit slower — but multi-threaded, CPU-intensive tasks run way faster! Beyond the performance boost, it’s just amazing to see how one of the most hated parts of Python — that survived 35 years — is finally being retired. Nothing lasts forever.

The recent release of Python 3.14 was one of the most hotly anticipated of recent years. Why? Well, there are a number of enhancements to the language but the most significant of these is the release of an official version without the Global Interpreter Lock (GIL). This opens up a whole new world of potential runtime improvements for your own code as well as third party libraries. In my latest piece for the Towards Data Science platform I do a deep dive on free threading (otherwise known as GIL-free) Python. I show you how to download it, explain what the GIL does and the ramifications of it's removal. I also provide numerous code examples comparing the run-times of regular versus GIL-free Python for different scenarios. You can read the article for FREE using the link below. https://lnkd.in/e4TTMphY

Advanced Static Typing in Python: How to type a Decorator In this article I walk the journey from untyped, to basic typing, to TypeVars aka Generics, and lastly how to accurately specify the type of a Decorator (a function that takes and returns a function). Disclaimer: As always, if you want anything resembling compile time safety in Python, you need to run a static analyzer like mypy, otherwise your annotations are worthless. https://lnkd.in/eE47kumT

We all love Python for its readability and ease of use, but what happens when you hit a computational bottleneck? While Python is fantastic for many tasks, it can struggle with time-critical operations. But what if you could get the best of both worlds? I've written a comprehensive guide on how to supercharge your Python code by integrating C for the heavy lifting. In my latest article on the Towards Data Science platform, I outline 3 different ways of offloading performance critical sections of Python code to C, resulting in performance boosts of up to **150x**. These techniques could be game-changing for anyone working on data processing, scientific computing, or any application where speed is paramount. Dive in now to learn how to combine the simplicity of Python with the raw power of C. Read the full guide for free using the link below https://lnkd.in/evmT7xyM