Grokking Event-Driven Web App with Python

Schedule

Room: Room 228

April 4

12:00–12:25

Abstract

Crafting scalable event-driven applications using Python can be a tricky endeavor, requiring careful consideration of various factors, from understanding synchronous and asynchronous network calls to tackling the Python Global Interpreter Lock (GIL) bottleneck and implementing robust auto-scaling strategies. This talk delves into advanced techniques and concepts for designing and implementing scalable event-driven applications with Python, empowering you to overcome these challenges effectively.

Prerequisites

Basic of Python

Description

Challenges in Event-Driven Python:

• Performance Pitfalls: Navigating the intricacies of asynchronous versus synchronous network protocols in Python can be a maze, with numerous available libraries offering varying approaches to efficient network communication.

• Global Interpreter Lock (GIL): The GIL, a fundamental aspect of the Python runtime, restricts the execution of multiple CPU threads within a single Python process. This can hinder the ability of event-driven applications to handle simultaneous I/O and CPU-bound tasks efficiently.

• Event Processing Reliability: In distributed environments with a high volume of incoming events, ensuring event processing without duplicates is crucial. Ensuring consistency across multiple event processing instances and maintaining data integrity requires careful design and implementation strategies.

What You'll Learn:

• Python Synchronization Breakdown: Delve into the implementation of synchronous and asynchronous network protocols in Python, understanding the trade-offs and implications for event-driven applications.

• Overcoming the GIL Barrier: Discover effective techniques and libraries that mitigate the limitations of the GIL, unleashing the full power of multi-core architectures for your event-driven applications.

• Event Processing at Scale Mastery: Grasp the nuances of various event processing semantics, including at-least-once, at-most-once, and exactly-once message processing, and how to implement them in your applications.

• Design Patterns for Failure Resilience: Uncover proven design patterns for handling failures in event-driven systems, ensuring resilience and robustness in the face of unexpected events.

• Python Code Patterns for Scalability: Learn practical Python code patterns for building event-driven applications from scratch, incorporating scalability considerations from the get-go.

Target Audience:

• Software Engineers
• Web Developers