Category: python

Think of Python like a big toolkit of tools (the interpreter and all its libraries). On Windows, you need to install that toolkit in one place so the operating system knows “Here’s where Python lives.” Once that’s in place, each application can make its own little copy of the toolkit (a venv) to keep its dependencies separate. Here’s why this setup is necessary:

https://docs.python.org/3/library/pathlib.html

https://stashsoftware.com/blog/article/using-codetqdmcode-for-dynamic-progress-bars-in-python-78

https://thenewstack.io/nvidia-finally-adds-native-python-support-to-cuda

https://nvidia.github.io/cuda-python/latest

Check your Cuda version, it will be the release version here:

>>> nvcc --version
nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2024 NVIDIA Corporation
Built on Wed_Apr_17_19:36:51_Pacific_Daylight_Time_2024
Cuda compilation tools, release 12.5, V12.5.40
Build cuda_12.5.r12.5/compiler.34177558_0

or from here:

>>> nvidia-smi
Mon Jun 16 12:35:20 2025
+-----------------------------------------------------------------------------------------+
| NVIDIA-SMI 555.85                 Driver Version: 555.85         CUDA Version: 12.5     |
|-----------------------------------------+------------------------+----------------------+

https://nielscautaerts.xyz/python-dependency-management-is-a-dumpster-fire.html

For many modern programming languages, the associated tooling has the lock-file based dependency management mechanism baked in. For a great example, consider Rust’s Cargo. 

Not so with Python.

The default package manager for Python is pip. The default instruction to install a package is to run pip install package. Unfortunately, this imperative approach for creating your environment is entirely divorced from the versioning of your code. You very quickly end up in a situation where you have 100’s of packages installed. You no longer know which packages you explicitly asked to install, and which packages got installed because they were a transitive dependency. You no longer know which version of the code worked in which environment, and there is no way to roll back to an earlier version of your environment. Installing any new package could break your environment.
…

Pyper is a flexible framework for concurrent and parallel data-processing, based on functional programming patterns.

https://github.com/pyper-dev/pyper

GIL or Global Interpreter Lock can be disabled in Python version 3.13. This is currently experimental.

What is GIL? It is a mechanism used by the CPython interpreter to ensure that only one thread executes the Python bytecode at a time.

https://medium.com/@r_bilan/python-3-13-without-the-gil-a-game-changer-for-concurrency-5e035500f0da

Advantages of the GIL

1. Simplicity of Implementation: The GIL simplifies memory management in CPython by preventing concurrent access to Python objects, which can help avoid race conditions and other threading issues.
2. Ease of Use for Single-Threaded Programs: For applications that are single-threaded, the GIL eliminates the overhead associated with managing thread safety, allowing for straightforward and efficient code execution.
3. Compatibility with C Extensions: The GIL allows C extensions to operate without needing to implement complex threading models, which simplifies the development of Python extensions that interface with C libraries.
4. Performance for I/O-Bound Tasks: In I/O-bound applications, the GIL does not significantly hinder performance since threads can be switched out during I/O operations, allowing other threads to run.

Disadvantages of the GIL

1. Limited Multithreading Performance: The GIL can severely restrict the performance of CPU-bound multithreaded applications, as it only allows one thread to execute Python bytecode at a time, leading to underutilization of multicore processors.
2. Thread Management Complexity: Although the GIL simplifies memory management, it can complicate the design of concurrent applications, forcing developers to carefully manage threading issues or use multiprocessing instead.
3. Hindrance to Parallel Processing: With the GIL enabled, achieving true parallelism in Python applications is challenging, making it difficult for developers to leverage multicore architectures effectively.
4. Inefficiency in Context Switching: Frequent context switching due to the GIL can introduce overhead, especially in applications with many threads, leading to performance degradation.

https://geekpython.in/gil-become-optional-in-python

(more…)

https://www.efinancialcareers.com/news/2023/06/which-programming-language-uses-the-most-energy

https://black.readthedocs.io/en/stable/the_black_code_style/current_style.html

The Black code style guide emphasizes consistency, readability, and minimizing diffs in Python code. Key formatting rules include ignoring previous formatting, preferring double quotes, adding trailing commas, and wrapping lines to fit within 88 characters. Black standardizes whitespace usage, avoids unnecessary vertical space, and ensures uniform handling of parentheses, comments, and numeric literals. The formatter also aligns with PEP 8 and PEP 257 standards, and provides options to adjust line length and skip string normalization for specific projects.