2025-11-01 –, Hall 1
Python's asynchronous capabilities, powered by asyncio, have revolutionized how we build responsive and efficient applications, especially for I/O-bound tasks. However, truly leveraging Python for scalable solutions requires a clear understanding of both concurrency and parallelism. This talk will guide attendees through the core "Awaitables" – Coroutines, Tasks, and Futures – demystifying how async/await orchestrates concurrent operations within a single event loop.
Building on this foundation, we'll explore practical strategies for managing asynchronous workloads using a hands-on task scheduler project as a case study. Finally, we'll tackle the critical distinction between concurrency and parallelism, addressing Python's Global Interpreter Lock (GIL) and demonstrating how ProcessPoolExecutor enables true parallel execution for CPU-bound computations. Attendees will leave with a comprehensive understanding of how to design and implement robust, scalable Python applications by strategically combining asyncio for concurrency and multiprocessing for parallelism.
This talk is designed for Python developers looking to deepen their understanding of modern concurrency and parallelism patterns. We will cover:
-
Understanding AsyncIO Fundamentals: A deep dive into Coroutines, Tasks, and Futures, explaining their roles in building non-blocking applications. We'll clarify common misconceptions and provide clear examples of when and how to use each.
-
Practical AsyncIO Task Management: Learn how to effectively manage multiple asynchronous operations. We'll demonstrate these concepts through a practical, interactive task scheduler project, showcasing techniques for creating, scheduling, and monitoring asyncio tasks.
-
Concurrency vs. Parallelism in Python: Demystifying the differences between these two crucial concepts. We'll discuss the implications of the Global Interpreter Lock (GIL) on multi-threading for CPU-bound tasks.
-
Achieving True Parallelism with ProcessPoolExecutor: Discover how to overcome GIL limitations by leveraging ProcessPoolExecutor for CPU-intensive operations. Practical examples will illustrate how to effectively distribute workloads across multiple CPU cores for enhanced performance and scalability.
Architecting Scalable Python Applications: Best practices and design patterns for integrating asyncio with ProcessPoolExecutor to build applications that are both highly responsive and computationally efficient.
Attendees should have a basic familiarity with Python. Prior exposure to asyncio is helpful but not required. This session will provide valuable insights for anyone aiming to write high-performance and scalable Python code.