Bilingual

Designing bug-proof engines
a day ago
- Two strategies for designing bug-proof engines: make it impossible for bugs to get inside, or design it to tolerate bugs.
- Examples include Saturn V (perfectionist) vs Falcon 9 (tolerant), C (manual memory) vs Java (garbage collection), and storyboarding vs sloppy draft in writing.
- Engineers often assume failure is unacceptable; always question requirements and consider both ends of the solution spectrum.
- Bimodal systems have a perfectionist happy path and a sweeper sad path; often cheaper to just use the sad path to reduce complexity.
Design Patterns
a day ago
- Design patterns are common solutions to recurring problems in software design, meant to be used naturally rather than forced.
- The Strategy pattern encapsulates behavior via functions or objects, useful for clean code and deduplication.
- The Factory pattern creates objects, encapsulating state or hiding construction logic.
- The Visitor pattern is the inverse of an iterator, useful for trees/graphs but less ergonomic than iterators.
- The Builder pattern constructs objects with many configurable fields, primarily useful in libraries for non-breaking API changes.
- The Singleton pattern ensures only one instance of a class exists (e.g., loggers, thread pools), but harms testability.
- Other patterns like Facade and Command are considered trivial and intuitive, not worth special discussion.
- Explicitly naming patterns (e.g., FooBuilder, visit) helps communicate intent in code.
Beej's Bit Bucket
a day ago
- Design patterns are reusable solutions to common software design problems, not algorithms but structures for data flow.
- The Observer Pattern allows an observable object to notify multiple observer objects when an event occurs.
- Common uses include asynchronous events (e.g., network data receipt) and GUI event handling (e.g., button clicks).
- Observers register callbacks; the observable notifies all registered observers when the event happens.
- Benefits: decoupling, easy addition of new observers without modifying existing code, and support for multiple listeners.
- Example: a GoatDetector class that notifies observers when the word 'goat' appears in input.
- A more advanced version uses a dictionary to map events to lists of observers, supporting multiple event types.
- The Observer Pattern is a concept, not a rigid implementation; it can be adapted to fit various scenarios.
Redis Patterns for Coding Agents
21 days ago
- Optimized website for developers and AI agents with Redis patterns, practices, and commands.
- Human-friendly browsing with clickable sections and machine-readable index (llms.txt).
- AI agents start by fetching llms.txt, then individual .md files with Markdown and Redis commands.
- Local mirror of official Redis documentation including command index and detailed docs.
- Core architectural patterns, community-developed use cases, and real-world scale examples available.

Hasty Briefsbeta

design patterns

Designing bug-proof engines

Design Patterns

Beej's Bit Bucket

Redis Patterns for Coding Agents