error-handling-patterns

A circuit breaker pattern prevents cascading failures by halting requests to a failing service and implementing graceful degradation, such as falling back to cached data during recurring network errors. This approach isolates faults and maintains application stability during outages.

Error handling in Rust and Go relies on Result types and explicit error values rather than traditional exceptions used in Python. This Skill provides language-specific implementations for each, detailing error propagation and custom exception hierarchies to ensure robust fault tolerance across different programming paradigms.

Creating a custom exception hierarchy in Python involves defining domain-specific exception classes that inherit from a base exception, which improves debugging by categorizing errors precisely. This Skill offers guidance on structuring these hierarchies and avoiding common error management pitfalls.

Yes, this error handling guidance applies to TypeScript and JavaScript applications, providing specific patterns for error propagation and fault tolerance. It covers language-specific implementations alongside universal patterns like error aggregation to build resilient applications across multiple environments.

Error aggregation should be used instead of failing fast when you need to collect multiple validation or processing errors simultaneously to report them together. This universal design pattern improves user feedback and debugging by preventing cascading failures and supporting graceful degradation.

Common pitfalls in implementing fault tolerance include swallowing exceptions without logging, overusing catch-all handlers, and misconfiguring circuit breaker thresholds. This Skill details best practices for effective error management to avoid these mistakes and ensure robust application reliability.