Benno Rice

North Bay Python

State of Exception(s) - Benno Rice - 2026

System Reliability and Error Handling: Comparing paradigms from C to Rust Result to build resilient cloud infrastructure.

Ethical Technology and Social Justice: Analyzing the intersection of AI, eugenics, and data labor to advocate for empathetic software design.

Practical Development Skills: Mastering web scraping, designing Python APIs for volatile data, and building civic tech on a budget.

Open Source and Community Building: Learning best practices for project scope management, contributing to large open-source projects, and technical communication.

Explore advanced topics in Python development, system reliability, ethical AI, and community-driven open source projects.

A deep dive into error handling paradigms (C, Exceptions, Rust Result) and the systemic failures that define modern cloud infrastructure. Learn how to build truly robust systems by understanding complex failure modes.

State of Exception(s)

A critical examination of the tech industry's ideological roots, connecting eugenics, data labor, and techno-optimism. Learn to build technology with social justice and empathy.

An Economy of Empathy

A practical framework for applying technology to local activism and civic engagement, focusing on maximizing impact with minimal resources.

Running Resistance Tech on a Shoestring

Learn to build robust Python scrapers and APIs for volatile open web data, focusing on handling silent failures and maintaining data contracts.

Designing Python APIs for Data You Don’t Control

Explore essential technical communication and crisis communication skills needed to navigate rapid technological change and social uncertainty.

Crisis (Technical) Communication: Teaching Survival Skills You Didn’t Know...

A personal journey detailing the growth of an open-source project, emphasizing community building, vulnerability, and technical contribution.

Bumbling into BeeWare: From typo-fix to core developer

A retrospective on web development, covering embedded systems, SSGs, and AI tools, showing the evolution of modern developer workflows.

While I've changed gears... I've managed to find my web development tribe

Applying feminist theory to network engineering, arguing that systemic problems (like latency) require intersectional, non-linear thinking.

What Feminist Theory & Praxis Says About Internet Networking

A case study on maintaining project scope in large open-source projects, crucial for sustainable software architecture.

No Project Scope Survives Contact with Users

North Bay Python 2026

Error handling is a fundamental design concern that varies drastically by language paradigm (e.g., manual return codes vs. exceptions vs. result types).

Modern systems failures often stem from complex interactions, not single points of failure, requiring deep system understanding for diagnosis and recovery.

Rust's `Result<T, E>` type forces explicit error handling at compile time, promoting safer, more predictable code compared to unchecked operations like `unwrap()`.

System resilience requires human adaptability and pattern matching—skills crucial for diagnosing complex, unexpected outages that automated systems (including LLMs) may miss.

A deep dive into error handling paradigms (C, Exceptions, Rust Result) and the systemic failures that define modern cloud infrastructure.

The talk traces how different languages encourage developers to think about failure. 

*   **C/C++:** Error handling relies on return codes, global variables (`errno`), and manual cleanup (often using `goto` patterns) to maintain consistency. This approach is prone to undefined behavior and complexity.
*   **Exceptions:** Languages like Python and C++ use exceptions to separate the error handling logic from the main control flow. While powerful for separating concerns, they can make control flow difficult to follow and require runtime support (stack unwinding).
*   **Rust's `Result` Type:** Rust avoids runtime exceptions by using `Result<T, E>`, a public enumeration. This forces the developer to explicitly handle both the `Ok` and `Err` variants, leveraging the type system and compile-time guarantees to ensure that error paths are considered, leading to safer, more predictable code.

The discussion uses real-world cloud outages (like the Cloudflare incident) to illustrate that large-scale failures are rarely due to a single bug. Instead, they are often the result of:

1.  **Complex Interactions:** Failures arise from the interaction of multiple, seemingly unrelated components.
2.  **Systemic Blind Spots:** Developers are good at modeling obvious failure modes, but the most dangerous failures are the non-obvious ones.
3.  **The Role of Humans:** Human practitioners remain the most adaptable element in complex systems, capable of pattern matching and reasoning through obscure scenarios that automated tools or AI may not predict.

State of Exception(s): Rethinking Error Handling in Complex Systems

State of Exception(s) - 2026

transcriptions/transcription-slZsSksCX00-v1.txt

cotalks.dev

Benno Rice

Videos