error handling

Bilingual

Terrible Horrible No Good Very Bad Python
2 months ago
- The code `return return False` returns `False` after the outer `return` is processed from a `finally` block.
- Normally, `os._exit` exits the process without cleanup, but omitting the argument raises a `TypeError`.
- The `finally` block silently swallows the `TypeError` due to the `return` statement, which is a common misuse.
- Python developers plan to issue a `SyntaxWarning` for `return` in `finally` blocks in a future release.
- Dynamic scoping in Python allows `import os` to work even if it appears after the function definition.
- `sys.exit` raises `SystemExit`, which can be caught by `finally`, unlike `os._exit` which directly terminates without running handlers.
Stop helping!
2 months ago
- Don't print long help text with an error message; it can hide the error from the user.
- Users, especially less experienced ones, may overlook the error message if buried in a large help output.
- Long help text is inconvenient on small screens or for users who already know most of the commands.
- It's better to simply remind the user how to access help (e.g., 'Try --help') rather than displaying all help text.
- Help should be displayed only when explicitly requested by the user.
Minimal Viable Zig Error Contexts
2 months ago
- Zig uses strongly-typed error codes for minimal error handling, leaving error reporting to the user via Diagnostics sink pattern.
- For script-like code, a middle-ground approach logs error context as key=value pairs using errdefer, reducing friction by avoiding explicit error messages and preserving try statements.
- The drawback is that error context is logged even when errors are handled, especially problematic for cancellation errors in Zig 0.16 that are meant to be handled gracefully.
Don't Trip[wire] Yourself: Testing Error Recovery in Zig
2 months ago
- - Mitchell Hashimoto wrote Tripwire, a Zig library for injecting failures to test error recovery, which is optimized away outside tests with zero runtime cost.
- - Zig's `errdefer` runs code on block exit only when an error is returned, but testing error codepaths is difficult due to low execution frequency.
- - Tripwire allows named failure points in code, enabling tests to trigger specific errors and verify `errdefer` cleanup via tools like `std.testing.allocator` to detect leaks.
- - The library uses `comptime` to detect test builds, making checks zero-cost (no memory or machine code) in release builds.
- - Integration into Ghostty uncovered ~6 `errdefer` bugs, which were fixed with tests to prevent regression.
Throw, Result, or Neither?
2 months ago
- The author argues that business failures like out-of-stock or item limit should be returned as events rather than exceptions or Result types, allowing them to be queried and used in reports or workflows.
- Exceptions are reserved for invalid operations (e.g., adding to a confirmed cart) or infrastructure errors (e.g., unavailable event store), while Result adds little value beyond success/failure classification in most popular languages.
- Middleware like rejectOn, skipOn, stopOn, and stopAfter in Emmett allows flexible handling of events without persisting them, supporting different use cases (e.g., import rejection vs. saved-list restore).
- Event sourcing enables selective persistence: the decision returns events, but the application decides whether to append them, avoiding unnecessary data retention.
The one-line mistake that makes bash scripts fail silently
2 months ago
- Bash scripts can fail silently, leading to undetected backup failures and other issues, especially in automated environments.
- Use 'set -euo pipefail' as a foundation to stop on errors, undefined variables, and pipe failures, but be aware of its limitations.
- Implement 'trap' for cleanup to ensure temporary files and resources are removed regardless of how the script exits.
- Always quote variables to prevent whitespace splitting and globbing, avoiding common bugs in production.
- Validate dependencies, arguments, and environment before acting to prevent failures in different setups.
- Write detailed logs with timestamps and context to aid troubleshooting, especially during off-hours incidents.
- Use file locking with 'flock' to prevent concurrent execution and data corruption in scheduled scripts.
- Utilize ShellCheck for static analysis and consider Bats for testing to catch errors before deployment.
- Conduct a final pre-production check including flags, cleanup, quoting, validation, logging, concurrency protection, and ShellCheck results.
- Share experiences and tips in communities to learn from common bash script mistakes and improve reliability.
The pandemic of incomplete OpenSSL error handling
3 months ago
- A bug report for APT highlighted TLS failures on FIPS systems due to MD5 errors, suggesting use of ERR_clear_error() around TLS operations.
- The author opposes this as a bad practice, arguing that discarding unrelated errors is unsafe and that the root cause should be fixed instead.
- ERR_clear_error() is widely used as a best practice in many codebases, but it leads to a systemic issue of incomplete error handling.
- Another anti-pattern involves checking top-level errors after OpenSSL operations and discarding them if deemed not severe, which also silences unrelated errors.
- Developers are encouraged to inspect code for ERR_clear_error() calls and consider using ERR_set_mark() for safer error stack management.
- A call is made to OpenSSL authors to avoid promoting practices that compromise security and trust in software.

error handling

Terrible Horrible No Good Very Bad Python

Stop helping!

Minimal Viable Zig Error Contexts

Don't Trip[wire] Yourself: Testing Error Recovery in Zig

Throw, Result, or Neither?

The one-line mistake that makes bash scripts fail silently

The pandemic of incomplete OpenSSL error handling