<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"><channel><title>FuryBee Clean Code</title><description>Practical articles on clean code, design patterns, refactoring, architecture, and software craftsmanship.</description><link>https://code.furybee.org/</link><language>en-us</language><item><title>The Cost of Mutable State</title><link>https://code.furybee.org/articles/mutable-state-costs/</link><guid isPermaLink="true">https://code.furybee.org/articles/mutable-state-costs/</guid><description>Shared mutable state is the root of cascading bugs. Learn why mutation is expensive, what it costs in testing and refactoring, and practical patterns to reduce it.</description><pubDate>Sat, 25 Apr 2026 00:00:00 GMT</pubDate><category>Architecture</category><category>mutable-state</category><category>immutability</category><category>refactoring</category><category>debugging</category><category>clean-code</category></item><item><title>Architecture Decision Records: Document Why, Not What</title><link>https://code.furybee.org/articles/architecture-decision-records/</link><guid isPermaLink="true">https://code.furybee.org/articles/architecture-decision-records/</guid><description>Code shows what you built. ADRs explain why you built it that way. A lightweight text file per decision is all you need to stop relitigating the same debates.</description><pubDate>Sat, 21 Mar 2026 00:00:00 GMT</pubDate><category>Best Practices</category><category>adr</category><category>documentation</category><category>architecture</category><category>decision-making</category><category>team</category></item><item><title>Anti-Corruption Layer: Isolate Legacy from Your New Domain</title><link>https://code.furybee.org/articles/anti-corruption-layer/</link><guid isPermaLink="true">https://code.furybee.org/articles/anti-corruption-layer/</guid><description>When integrating with legacy systems or third-party APIs, the Anti-Corruption Layer pattern prevents their messy models from leaking into your clean domain.</description><pubDate>Sat, 21 Mar 2026 00:00:00 GMT</pubDate><category>Architecture</category><category>anti-corruption-layer</category><category>ddd</category><category>legacy</category><category>integration</category><category>architecture</category></item><item><title>API Gateway vs BFF: When to Use Which</title><link>https://code.furybee.org/articles/api-gateway-vs-bff/</link><guid isPermaLink="true">https://code.furybee.org/articles/api-gateway-vs-bff/</guid><description>An API Gateway and a Backend for Frontend are both API layers, but they solve different problems. Here&apos;s how to choose — and why you might need both.</description><pubDate>Sat, 21 Mar 2026 00:00:00 GMT</pubDate><category>Architecture</category><category>api-gateway</category><category>bff</category><category>microservices</category><category>architecture</category><category>backend</category></item><item><title>The 80% Code Coverage Myth: What Coverage Doesn&apos;t Tell You</title><link>https://code.furybee.org/articles/code-coverage-myth/</link><guid isPermaLink="true">https://code.furybee.org/articles/code-coverage-myth/</guid><description>Teams chase 80% coverage targets and feel safe. Then production burns. Coverage measures what was executed, not what was tested — here&apos;s what actually matters.</description><pubDate>Sat, 21 Mar 2026 00:00:00 GMT</pubDate><category>Testing</category><category>testing</category><category>code-coverage</category><category>quality</category><category>best-practices</category><category>metrics</category></item><item><title>Contract Testing with Pact: Test API Contracts Between Services</title><link>https://code.furybee.org/articles/contract-testing/</link><guid isPermaLink="true">https://code.furybee.org/articles/contract-testing/</guid><description>Integration tests are slow and brittle. Contract testing lets consumer and provider verify their API agreement independently — without spinning up the whole system.</description><pubDate>Sat, 21 Mar 2026 00:00:00 GMT</pubDate><category>Testing</category><category>contract-testing</category><category>pact</category><category>microservices</category><category>testing</category><category>api</category></item><item><title>Event Sourcing: Rebuilding State from Events</title><link>https://code.furybee.org/articles/event-sourcing/</link><guid isPermaLink="true">https://code.furybee.org/articles/event-sourcing/</guid><description>Instead of storing the current state, Event Sourcing stores every change as an immutable event. Learn how it unlocks time travel, audit logs, and powerful projections.</description><pubDate>Sat, 21 Mar 2026 00:00:00 GMT</pubDate><category>Architecture</category><category>event-sourcing</category><category>cqrs</category><category>architecture</category><category>events</category><category>audit-log</category></item><item><title>Feature Flags: Deploy Without Risk</title><link>https://code.furybee.org/articles/feature-flags/</link><guid isPermaLink="true">https://code.furybee.org/articles/feature-flags/</guid><description>Feature flags decouple deployment from release. Ship code any time, enable features when you&apos;re ready — and kill them instantly if something goes wrong.</description><pubDate>Sat, 21 Mar 2026 00:00:00 GMT</pubDate><category>Best Practices</category><category>feature-flags</category><category>deployment</category><category>trunk-based-development</category><category>devops</category><category>release-management</category></item><item><title>Monorepo: Why and How (Nx, Turborepo, Tradeoffs)</title><link>https://code.furybee.org/articles/monorepo-why-and-how/</link><guid isPermaLink="true">https://code.furybee.org/articles/monorepo-why-and-how/</guid><description>A monorepo puts all your code in one repository. Done right, it speeds up development, enforces boundaries, and makes refactoring across projects trivial. Here&apos;s the real picture.</description><pubDate>Sat, 21 Mar 2026 00:00:00 GMT</pubDate><category>DevOps</category><category>monorepo</category><category>nx</category><category>turborepo</category><category>architecture</category><category>tooling</category></item><item><title>Outbox Pattern: Guaranteed Consistency Between DB and Message Broker</title><link>https://code.furybee.org/articles/outbox-pattern/</link><guid isPermaLink="true">https://code.furybee.org/articles/outbox-pattern/</guid><description>Publishing events after a database write sounds simple, but it&apos;s a trap. The Outbox pattern guarantees that your database changes and your events always stay in sync.</description><pubDate>Sat, 21 Mar 2026 00:00:00 GMT</pubDate><category>Architecture</category><category>outbox</category><category>messaging</category><category>distributed-systems</category><category>consistency</category><category>microservices</category></item><item><title>Pre-Commit Hooks: Automate Quality from the First Commit</title><link>https://code.furybee.org/articles/pre-commit-hooks/</link><guid isPermaLink="true">https://code.furybee.org/articles/pre-commit-hooks/</guid><description>Bad code shouldn&apos;t make it past your local machine. Pre-commit hooks catch formatting issues, lint errors, and failing tests before they ever touch your repository.</description><pubDate>Sat, 21 Mar 2026 00:00:00 GMT</pubDate><category>DevOps</category><category>pre-commit</category><category>git-hooks</category><category>husky</category><category>lint-staged</category><category>code-quality</category></item><item><title>Saga Pattern: Managing Distributed Transactions Without 2PC</title><link>https://code.furybee.org/articles/saga-pattern/</link><guid isPermaLink="true">https://code.furybee.org/articles/saga-pattern/</guid><description>Distributed transactions are hard. The Saga pattern breaks them into a sequence of local transactions with compensating actions, avoiding the pitfalls of Two-Phase Commit.</description><pubDate>Sat, 21 Mar 2026 00:00:00 GMT</pubDate><category>Architecture</category><category>saga</category><category>distributed-systems</category><category>microservices</category><category>transactions</category><category>architecture</category></item><item><title>Specification Pattern: Encapsulate Complex Business Rules</title><link>https://code.furybee.org/articles/specification-pattern/</link><guid isPermaLink="true">https://code.furybee.org/articles/specification-pattern/</guid><description>When business rules get complex, they scatter across your codebase. The Specification pattern turns rules into composable objects you can combine, reuse, and test in isolation.</description><pubDate>Sat, 21 Mar 2026 00:00:00 GMT</pubDate><category>Design Patterns</category><category>specification-pattern</category><category>ddd</category><category>business-rules</category><category>design-patterns</category><category>clean-code</category></item><item><title>Strangler Fig Pattern: Migrate a Monolith Without Rewriting Everything</title><link>https://code.furybee.org/articles/strangler-fig-pattern/</link><guid isPermaLink="true">https://code.furybee.org/articles/strangler-fig-pattern/</guid><description>The strangler fig tree grows around its host until the host is gone. Use the same approach to incrementally replace a legacy monolith with modern services — safely.</description><pubDate>Sat, 21 Mar 2026 00:00:00 GMT</pubDate><category>Architecture</category><category>strangler-fig</category><category>migration</category><category>monolith</category><category>microservices</category><category>refactoring</category></item><item><title>Trunk-Based Development vs GitFlow: The Debate Settled</title><link>https://code.furybee.org/articles/trunk-based-vs-gitflow/</link><guid isPermaLink="true">https://code.furybee.org/articles/trunk-based-vs-gitflow/</guid><description>GitFlow dominated for a decade. Trunk-Based Development is how high-performing teams actually ship. Here&apos;s why, and how to make the switch.</description><pubDate>Sat, 21 Mar 2026 00:00:00 GMT</pubDate><category>Best Practices</category><category>trunk-based-development</category><category>gitflow</category><category>branching</category><category>devops</category><category>ci-cd</category></item><item><title>Cohesion: The Secret to Long-Lasting Modules</title><link>https://code.furybee.org/articles/cohesion-in-modules/</link><guid isPermaLink="true">https://code.furybee.org/articles/cohesion-in-modules/</guid><description>A cohesive module does one thing and does it well. Learn how to measure and improve the cohesion of your classes and modules for more maintainable code.</description><pubDate>Mon, 16 Feb 2026 00:00:00 GMT</pubDate><category>Architecture</category><category>cohesion</category><category>modules</category><category>architecture</category><category>refactoring</category><category>clean-code</category></item><item><title>Either/Result: Handling Errors Without Exceptions</title><link>https://code.furybee.org/articles/either-result-pattern/</link><guid isPermaLink="true">https://code.furybee.org/articles/either-result-pattern/</guid><description>Replace unpredictable try/catch blocks with the Either/Result pattern for an explicit, typed, and composable error flow.</description><pubDate>Mon, 16 Feb 2026 00:00:00 GMT</pubDate><category>Design Patterns</category><category>either</category><category>result</category><category>error-handling</category><category>typescript</category><category>functional-programming</category></item><item><title>Fail Fast: Fail Early to Debug Less</title><link>https://code.furybee.org/articles/fail-fast-principle/</link><guid isPermaLink="true">https://code.furybee.org/articles/fail-fast-principle/</guid><description>The Fail Fast principle means detecting and reporting errors as early as possible. This leads to less debugging, less silent corruption, and more confidence in your code.</description><pubDate>Mon, 16 Feb 2026 00:00:00 GMT</pubDate><category>Principles</category><category>fail-fast</category><category>defensive-programming</category><category>validation</category><category>clean-code</category></item><item><title>Principle of Least Astonishment: Write Predictable Code</title><link>https://code.furybee.org/articles/principle-of-least-astonishment/</link><guid isPermaLink="true">https://code.furybee.org/articles/principle-of-least-astonishment/</guid><description>The Principle of Least Astonishment (or Surprise) states that the result of an operation should be obvious, consistent, and predictable. Learn why surprising code leads to bugs.</description><pubDate>Wed, 10 Dec 2025 00:00:00 GMT</pubDate><category>Principles</category><category>principles</category><category>clean-code</category><category>api-design</category><category>readability</category><category>consistency</category></item><item><title>TypeScript Type Safety Beyond Basics</title><link>https://code.furybee.org/articles/typescript-type-safety/</link><guid isPermaLink="true">https://code.furybee.org/articles/typescript-type-safety/</guid><description>Advanced TypeScript techniques for bulletproof type safety — branded types, discriminated unions, template literals, and conditional types with practical examples.</description><pubDate>Wed, 10 Dec 2025 00:00:00 GMT</pubDate><category>TypeScript</category><category>typescript</category><category>type-safety</category><category>advanced-types</category><category>generics</category><category>best-practices</category></item><item><title>Separation of Concerns: The Foundation of Clean Architecture</title><link>https://code.furybee.org/articles/separation-of-concerns/</link><guid isPermaLink="true">https://code.furybee.org/articles/separation-of-concerns/</guid><description>Separation of Concerns is a design principle for separating a computer program into distinct sections. Learn how this core idea underpins almost every major software architecture.</description><pubDate>Fri, 05 Dec 2025 00:00:00 GMT</pubDate><category>Principles</category><category>separation-of-concerns</category><category>soc</category><category>architecture</category><category>clean-code</category><category>principles</category><category>srp</category></item><item><title>Mutation Testing: Are Your Tests Actually Testing Anything?</title><link>https://code.furybee.org/articles/mutation-testing/</link><guid isPermaLink="true">https://code.furybee.org/articles/mutation-testing/</guid><description>Your tests pass with 100% code coverage. But does that mean your tests are good? Mutation testing helps you answer this question by changing your code and seeing if your tests fail.</description><pubDate>Sun, 30 Nov 2025 00:00:00 GMT</pubDate><category>Testing</category><category>testing</category><category>mutation-testing</category><category>quality-assurance</category><category>tdd</category><category>typescript</category><category>python</category></item><item><title>Property-Based Testing: Let the Computer Write Your Test Cases</title><link>https://code.furybee.org/articles/property-based-testing/</link><guid isPermaLink="true">https://code.furybee.org/articles/property-based-testing/</guid><description>Example-based testing is great, but it can&apos;t cover every edge case. Property-based testing generates hundreds of random test cases to find bugs you never thought to look for.</description><pubDate>Tue, 25 Nov 2025 00:00:00 GMT</pubDate><category>Testing</category><category>testing</category><category>property-based-testing</category><category>automation</category><category>quality-assurance</category><category>typescript</category><category>python</category></item><item><title>Effective Error Handling Patterns</title><link>https://code.furybee.org/articles/error-handling-patterns/</link><guid isPermaLink="true">https://code.furybee.org/articles/error-handling-patterns/</guid><description>Practical error handling patterns that make code more robust — from custom error hierarchies and Result types to error boundaries and retry strategies.</description><pubDate>Thu, 20 Nov 2025 00:00:00 GMT</pubDate><category>Best Practices</category><category>error-handling</category><category>best-practices</category><category>typescript</category><category>python</category><category>clean-code</category></item><item><title>Vertical Slice Architecture: Organize by Feature, Not Layer</title><link>https://code.furybee.org/articles/vertical-slice-architecture/</link><guid isPermaLink="true">https://code.furybee.org/articles/vertical-slice-architecture/</guid><description>Vertical Slice Architecture organizes code by feature, not by technical layer. Learn how this approach can improve cohesion, reduce coupling, and make your codebase easier to navigate.</description><pubDate>Thu, 20 Nov 2025 00:00:00 GMT</pubDate><category>Architecture</category><category>vertical-slice-architecture</category><category>architecture</category><category>clean-architecture</category><category>cohesion</category><category>coupling</category></item><item><title>Domain-Driven Design: Entities, Value Objects, and Aggregates</title><link>https://code.furybee.org/articles/domain-driven-design-basics/</link><guid isPermaLink="true">https://code.furybee.org/articles/domain-driven-design-basics/</guid><description>An introduction to the core building blocks of Domain-Driven Design (DDD): Entities, Value Objects, and Aggregates. Learn how to model a rich, expressive domain.</description><pubDate>Sat, 15 Nov 2025 00:00:00 GMT</pubDate><category>Architecture</category><category>ddd</category><category>architecture</category><category>domain-driven-design</category><category>entities</category><category>value-objects</category><category>aggregates</category></item><item><title>Async Error Handling Done Right</title><link>https://code.furybee.org/articles/async-error-handling/</link><guid isPermaLink="true">https://code.furybee.org/articles/async-error-handling/</guid><description>Master async error handling in TypeScript — try/catch patterns, Promise.allSettled, retry strategies, error boundaries, and graceful degradation.</description><pubDate>Wed, 12 Nov 2025 00:00:00 GMT</pubDate><category>TypeScript</category><category>async</category><category>error-handling</category><category>typescript</category><category>promises</category><category>best-practices</category></item><item><title>CQRS: Separating Reads from Writes</title><link>https://code.furybee.org/articles/cqrs-pattern/</link><guid isPermaLink="true">https://code.furybee.org/articles/cqrs-pattern/</guid><description>Command Query Responsibility Segregation (CQRS) is an architectural pattern that separates models for reading data from models for updating data. Learn the pros and cons.</description><pubDate>Mon, 10 Nov 2025 00:00:00 GMT</pubDate><category>Architecture</category><category>cqrs</category><category>architecture</category><category>design-patterns</category><category>scalability</category><category>event-sourcing</category></item><item><title>Dead Code: Find It, Kill It, Prevent It</title><link>https://code.furybee.org/articles/dead-code-elimination/</link><guid isPermaLink="true">https://code.furybee.org/articles/dead-code-elimination/</guid><description>Dead code is code that is never executed. It adds clutter, confuses developers, and increases maintenance overhead. Learn how to find and safely remove it.</description><pubDate>Wed, 05 Nov 2025 00:00:00 GMT</pubDate><category>Refactoring</category><category>dead-code</category><category>refactoring</category><category>maintainability</category><category>code-smells</category><category>clean-code</category></item><item><title>Monolith to Microservices: When and How</title><link>https://code.furybee.org/articles/monolith-to-microservices/</link><guid isPermaLink="true">https://code.furybee.org/articles/monolith-to-microservices/</guid><description>A pragmatic guide to breaking a monolith into microservices — when it makes sense, how to identify service boundaries, and patterns to execute the migration safely.</description><pubDate>Wed, 05 Nov 2025 00:00:00 GMT</pubDate><category>Architecture</category><category>architecture</category><category>microservices</category><category>monolith</category><category>migration</category><category>domain-driven-design</category></item><item><title>Shotgun Surgery: When One Change Requires Many Edits</title><link>https://code.furybee.org/articles/shotgun-surgery/</link><guid isPermaLink="true">https://code.furybee.org/articles/shotgun-surgery/</guid><description>Shotgun Surgery is a code smell where a single logical change requires you to modify many different classes. Learn how to identify and fix it by consolidating responsibilities.</description><pubDate>Thu, 30 Oct 2025 00:00:00 GMT</pubDate><category>Code Smells</category><category>shotgun-surgery</category><category>code-smells</category><category>refactoring</category><category>dry</category><category>single-responsibility</category></item><item><title>Magic Numbers and the Power of Named Constants</title><link>https://code.furybee.org/articles/magic-numbers-constants/</link><guid isPermaLink="true">https://code.furybee.org/articles/magic-numbers-constants/</guid><description>Magic numbers are unnamed numeric literals that appear in code without explanation. Learn how to replace them with named constants to improve readability and maintainability.</description><pubDate>Sat, 25 Oct 2025 00:00:00 GMT</pubDate><category>Code Smells</category><category>magic-numbers</category><category>constants</category><category>readability</category><category>maintainability</category><category>code-smells</category><category>refactoring</category></item><item><title>Code Comments: When, Why, and How (Not)</title><link>https://code.furybee.org/articles/code-comments-when-why/</link><guid isPermaLink="true">https://code.furybee.org/articles/code-comments-when-why/</guid><description>Good code is self-documenting, but that doesn&apos;t mean all comments are bad. Learn the difference between valuable comments and harmful noise that hurts maintainability.</description><pubDate>Mon, 20 Oct 2025 00:00:00 GMT</pubDate><category>Best Practices</category><category>comments</category><category>clean-code</category><category>readability</category><category>maintainability</category><category>refactoring</category></item><item><title>Python Type Hints and Why They Matter</title><link>https://code.furybee.org/articles/python-type-hints/</link><guid isPermaLink="true">https://code.furybee.org/articles/python-type-hints/</guid><description>A practical guide to Python type hints — from basics to advanced patterns like Protocols, TypeGuards, and generics. Learn how static typing improves Python codebases.</description><pubDate>Wed, 15 Oct 2025 00:00:00 GMT</pubDate><category>Python</category><category>python</category><category>type-hints</category><category>mypy</category><category>typing</category><category>clean-code</category></item><item><title>Template Method: Define the Skeleton, Defer the Details</title><link>https://code.furybee.org/articles/template-method-pattern/</link><guid isPermaLink="true">https://code.furybee.org/articles/template-method-pattern/</guid><description>The Template Method pattern defines the skeleton of an algorithm in a base class but lets subclasses override specific steps without changing the overall structure.</description><pubDate>Wed, 15 Oct 2025 00:00:00 GMT</pubDate><category>Design Patterns</category><category>design-patterns</category><category>template-method</category><category>behavioral</category><category>framework</category><category>typescript</category><category>python</category></item><item><title>Command Pattern: Encapsulating Actions as Objects</title><link>https://code.furybee.org/articles/command-pattern/</link><guid isPermaLink="true">https://code.furybee.org/articles/command-pattern/</guid><description>The Command pattern turns a request into a stand-alone object that contains all information about the request. Learn how this enables undo, queuing, and logging.</description><pubDate>Fri, 10 Oct 2025 00:00:00 GMT</pubDate><category>Design Patterns</category><category>design-patterns</category><category>command</category><category>behavioral</category><category>typescript</category><category>python</category></item><item><title>The Ultimate Code Review Checklist</title><link>https://code.furybee.org/articles/code-review-checklist/</link><guid isPermaLink="true">https://code.furybee.org/articles/code-review-checklist/</guid><description>A practical checklist for reviewing code effectively — what to look for, how to give constructive feedback, and common pitfalls to avoid.</description><pubDate>Sun, 05 Oct 2025 00:00:00 GMT</pubDate><category>Best Practices</category><category>code-review</category><category>best-practices</category><category>teamwork</category><category>quality</category><category>clean-code</category></item><item><title>Facade Pattern: Simplifying Complex Subsystems</title><link>https://code.furybee.org/articles/facade-pattern/</link><guid isPermaLink="true">https://code.furybee.org/articles/facade-pattern/</guid><description>The Facade pattern provides a simplified, high-level interface to a complex subsystem of classes. Learn how to hide complexity and decouple your code.</description><pubDate>Sun, 05 Oct 2025 00:00:00 GMT</pubDate><category>Design Patterns</category><category>design-patterns</category><category>facade</category><category>architecture</category><category>simplicity</category><category>typescript</category><category>python</category></item><item><title>The Adapter Pattern: Making Incompatible Interfaces Work Together</title><link>https://code.furybee.org/articles/adapter-pattern/</link><guid isPermaLink="true">https://code.furybee.org/articles/adapter-pattern/</guid><description>Learn how the Adapter pattern acts as a bridge, allowing objects with incompatible interfaces to collaborate. A fundamental pattern for integrating new and legacy systems.</description><pubDate>Wed, 01 Oct 2025 00:00:00 GMT</pubDate><category>Design Patterns</category><category>design-patterns</category><category>adapter</category><category>integration</category><category>typescript</category><category>python</category></item><item><title>The State Pattern: Managing Complex State Machines</title><link>https://code.furybee.org/articles/state-pattern/</link><guid isPermaLink="true">https://code.furybee.org/articles/state-pattern/</guid><description>Replace tangled if-else state management with the State pattern. Learn state transitions, finite state machines, and when to reach for libraries like XState.</description><pubDate>Sun, 28 Sep 2025 00:00:00 GMT</pubDate><category>Design Patterns</category><category>design-patterns</category><category>state-pattern</category><category>state-machine</category><category>typescript</category><category>python</category></item><item><title>API Design: REST Best Practices</title><link>https://code.furybee.org/articles/rest-api-design/</link><guid isPermaLink="true">https://code.furybee.org/articles/rest-api-design/</guid><description>Design APIs that developers love. Practical guidance on resource naming, status codes, pagination, versioning, error responses, and common pitfalls.</description><pubDate>Mon, 22 Sep 2025 00:00:00 GMT</pubDate><category>Architecture</category><category>api</category><category>rest</category><category>architecture</category><category>http</category><category>best-practices</category></item><item><title>Hexagonal Architecture Explained</title><link>https://code.furybee.org/articles/hexagonal-architecture/</link><guid isPermaLink="true">https://code.furybee.org/articles/hexagonal-architecture/</guid><description>A practical guide to Hexagonal Architecture (Ports and Adapters), showing how to decouple your business logic from infrastructure with real TypeScript examples.</description><pubDate>Sat, 20 Sep 2025 00:00:00 GMT</pubDate><category>Architecture</category><category>architecture</category><category>hexagonal</category><category>ports-adapters</category><category>clean-architecture</category><category>typescript</category></item><item><title>Functional Programming Patterns for Cleaner Code</title><link>https://code.furybee.org/articles/functional-programming-patterns/</link><guid isPermaLink="true">https://code.furybee.org/articles/functional-programming-patterns/</guid><description>Practical functional programming patterns — pure functions, immutability, pipe/compose, and more — applied to everyday TypeScript and Python code.</description><pubDate>Thu, 18 Sep 2025 00:00:00 GMT</pubDate><category>Best Practices</category><category>functional-programming</category><category>typescript</category><category>python</category><category>immutability</category><category>pure-functions</category><category>clean-code</category></item><item><title>Logging Done Right</title><link>https://code.furybee.org/articles/logging-done-right/</link><guid isPermaLink="true">https://code.furybee.org/articles/logging-done-right/</guid><description>Most logging is useless noise. Learn structured logging, proper log levels, correlation IDs, and what you should never log — with practical TypeScript and Python examples.</description><pubDate>Mon, 15 Sep 2025 00:00:00 GMT</pubDate><category>Best Practices</category><category>logging</category><category>observability</category><category>best-practices</category><category>typescript</category><category>python</category></item><item><title>Database Migration Patterns</title><link>https://code.furybee.org/articles/database-migration-patterns/</link><guid isPermaLink="true">https://code.furybee.org/articles/database-migration-patterns/</guid><description>Schema changes don&apos;t have to mean downtime. Learn expand/contract migrations, backward-compatible changes, and zero-downtime deployment strategies.</description><pubDate>Mon, 08 Sep 2025 00:00:00 GMT</pubDate><category>Architecture</category><category>architecture</category><category>database</category><category>migrations</category><category>deployment</category><category>zero-downtime</category></item><item><title>Null Object Pattern: Eliminate Null Checks</title><link>https://code.furybee.org/articles/null-object-pattern/</link><guid isPermaLink="true">https://code.furybee.org/articles/null-object-pattern/</guid><description>Replace null checks with objects that do nothing gracefully. The Null Object pattern reduces branching, eliminates null pointer errors, and makes code cleaner.</description><pubDate>Mon, 01 Sep 2025 00:00:00 GMT</pubDate><category>Design Patterns</category><category>design-patterns</category><category>null-object</category><category>typescript</category><category>python</category><category>clean-code</category></item><item><title>The Builder Pattern in TypeScript</title><link>https://code.furybee.org/articles/builder-pattern/</link><guid isPermaLink="true">https://code.furybee.org/articles/builder-pattern/</guid><description>Build complex objects step by step with fluent APIs, type-safe builders, and validation. Learn when the Builder pattern shines and when it&apos;s overkill.</description><pubDate>Mon, 25 Aug 2025 00:00:00 GMT</pubDate><category>Design Patterns</category><category>design-patterns</category><category>builder</category><category>typescript</category><category>fluent-api</category><category>clean-code</category></item><item><title>Cyclomatic Complexity: Measuring Code Health</title><link>https://code.furybee.org/articles/cyclomatic-complexity/</link><guid isPermaLink="true">https://code.furybee.org/articles/cyclomatic-complexity/</guid><description>Learn what cyclomatic complexity is, why it matters, and practical techniques to reduce it. Includes real refactoring examples and tooling recommendations.</description><pubDate>Mon, 18 Aug 2025 00:00:00 GMT</pubDate><category>Best Practices</category><category>complexity</category><category>refactoring</category><category>code-quality</category><category>metrics</category><category>best-practices</category></item><item><title>Event-Driven Architecture: Decoupling Done Right</title><link>https://code.furybee.org/articles/event-driven-architecture/</link><guid isPermaLink="true">https://code.furybee.org/articles/event-driven-architecture/</guid><description>Stop coupling your modules with direct calls. Learn how event emitters, message buses, and pub/sub patterns create truly decoupled systems that are easier to extend and maintain.</description><pubDate>Tue, 12 Aug 2025 00:00:00 GMT</pubDate><category>Architecture</category><category>architecture</category><category>event-driven</category><category>pub-sub</category><category>decoupling</category><category>typescript</category><category>design-patterns</category></item><item><title>The Open/Closed Principle in Practice</title><link>https://code.furybee.org/articles/open-closed-principle/</link><guid isPermaLink="true">https://code.furybee.org/articles/open-closed-principle/</guid><description>Software entities should be open for extension but closed for modification. Here&apos;s what that actually looks like in real code — with practical TypeScript and Python examples.</description><pubDate>Tue, 05 Aug 2025 00:00:00 GMT</pubDate><category>SOLID</category><category>solid</category><category>open-closed-principle</category><category>design-patterns</category><category>typescript</category><category>python</category></item><item><title>Dependency Injection Without a Framework</title><link>https://code.furybee.org/articles/dependency-injection/</link><guid isPermaLink="true">https://code.furybee.org/articles/dependency-injection/</guid><description>Learn how to implement dependency injection manually using constructor injection in TypeScript and Python — no framework required.</description><pubDate>Sat, 02 Aug 2025 00:00:00 GMT</pubDate><category>Design Patterns</category><category>dependency-injection</category><category>testing</category><category>typescript</category><category>python</category><category>design-patterns</category><category>clean-code</category></item><item><title>Immutability: Why Const Isn&apos;t Enough</title><link>https://code.furybee.org/articles/immutability/</link><guid isPermaLink="true">https://code.furybee.org/articles/immutability/</guid><description>Const only prevents reassignment — it doesn&apos;t make your data immutable. Learn how to truly protect your data with Object.freeze, readonly types, and structural sharing.</description><pubDate>Fri, 01 Aug 2025 00:00:00 GMT</pubDate><category>Best Practices</category><category>immutability</category><category>typescript</category><category>functional-programming</category><category>best-practices</category><category>data-structures</category></item><item><title>The Art of Naming Things</title><link>https://code.furybee.org/articles/naming-things/</link><guid isPermaLink="true">https://code.furybee.org/articles/naming-things/</guid><description>Naming is the hardest problem in computer science. Learn practical strategies for naming variables, functions, and classes that make your code self-documenting.</description><pubDate>Thu, 10 Jul 2025 00:00:00 GMT</pubDate><category>Best Practices</category><category>naming</category><category>readability</category><category>clean-code</category><category>best-practices</category><category>refactoring</category></item><item><title>SOLID Principles Explained with Real Examples</title><link>https://code.furybee.org/articles/solid-principles-explained/</link><guid isPermaLink="true">https://code.furybee.org/articles/solid-principles-explained/</guid><description>A comprehensive guide to the five SOLID principles with practical TypeScript examples that show how each principle improves your code.</description><pubDate>Sun, 15 Jun 2025 00:00:00 GMT</pubDate><category>SOLID</category><category>solid</category><category>principles</category><category>typescript</category><category>oop</category><category>clean-code</category></item><item><title>Guard Clauses Over Nested Ifs</title><link>https://code.furybee.org/articles/guard-clauses/</link><guid isPermaLink="true">https://code.furybee.org/articles/guard-clauses/</guid><description>Flatten your code by replacing deeply nested conditionals with early returns. Guard clauses make the happy path obvious and errors impossible to miss.</description><pubDate>Tue, 10 Jun 2025 00:00:00 GMT</pubDate><category>Refactoring</category><category>guard-clauses</category><category>refactoring</category><category>readability</category><category>clean-code</category></item><item><title>Clean Architecture in Node.js</title><link>https://code.furybee.org/articles/clean-architecture-nodejs/</link><guid isPermaLink="true">https://code.furybee.org/articles/clean-architecture-nodejs/</guid><description>Apply Uncle Bob&apos;s Clean Architecture to Node.js applications with practical TypeScript examples showing layers, dependencies, and boundaries.</description><pubDate>Thu, 05 Jun 2025 00:00:00 GMT</pubDate><category>Architecture</category><category>clean-architecture</category><category>nodejs</category><category>layers</category><category>typescript</category></item><item><title>Factory Pattern in TypeScript</title><link>https://code.furybee.org/articles/factory-pattern-typescript/</link><guid isPermaLink="true">https://code.furybee.org/articles/factory-pattern-typescript/</guid><description>Learn how to use the Factory pattern to create objects without exposing instantiation logic, with practical TypeScript examples.</description><pubDate>Sun, 01 Jun 2025 00:00:00 GMT</pubDate><category>Design Patterns</category><category>factory</category><category>design-patterns</category><category>typescript</category><category>creational</category></item><item><title>Extract Method: The Most Powerful Refactoring</title><link>https://code.furybee.org/articles/extract-method/</link><guid isPermaLink="true">https://code.furybee.org/articles/extract-method/</guid><description>Master the Extract Method refactoring — the single most impactful technique for improving code readability and reducing complexity.</description><pubDate>Fri, 30 May 2025 00:00:00 GMT</pubDate><category>Refactoring</category><category>extract-method</category><category>refactoring</category><category>readability</category><category>clean-code</category></item><item><title>Writing Tests That Actually Help</title><link>https://code.furybee.org/articles/writing-useful-tests/</link><guid isPermaLink="true">https://code.furybee.org/articles/writing-useful-tests/</guid><description>Not all tests are created equal. Learn to write tests that catch real bugs, serve as documentation, and don&apos;t break on every refactor.</description><pubDate>Sun, 25 May 2025 00:00:00 GMT</pubDate><category>Testing</category><category>testing</category><category>unit-tests</category><category>best-practices</category><category>clean-code</category></item><item><title>DRY, KISS, YAGNI — The Holy Trinity</title><link>https://code.furybee.org/articles/dry-kiss-yagni/</link><guid isPermaLink="true">https://code.furybee.org/articles/dry-kiss-yagni/</guid><description>Master the three fundamental principles every developer should know: Don&apos;t Repeat Yourself, Keep It Simple Stupid, and You Aren&apos;t Gonna Need It.</description><pubDate>Tue, 20 May 2025 00:00:00 GMT</pubDate><category>Principles</category><category>dry</category><category>kiss</category><category>yagni</category><category>principles</category><category>clean-code</category></item><item><title>Observer Pattern — When and How</title><link>https://code.furybee.org/articles/observer-pattern/</link><guid isPermaLink="true">https://code.furybee.org/articles/observer-pattern/</guid><description>A practical guide to the Observer pattern: implementing event-driven architectures with type-safe event emitters in TypeScript.</description><pubDate>Sat, 10 May 2025 00:00:00 GMT</pubDate><category>Design Patterns</category><category>observer</category><category>design-patterns</category><category>events</category><category>typescript</category></item><item><title>God Class: How to Break It Down</title><link>https://code.furybee.org/articles/god-class/</link><guid isPermaLink="true">https://code.furybee.org/articles/god-class/</guid><description>Recognize and dismantle God Classes — those massive classes that do everything and know everything — into focused, maintainable components.</description><pubDate>Mon, 05 May 2025 00:00:00 GMT</pubDate><category>Code Smells</category><category>god-class</category><category>code-smells</category><category>refactoring</category><category>srp</category></item><item><title>Strategy Pattern for Clean Conditionals</title><link>https://code.furybee.org/articles/strategy-pattern/</link><guid isPermaLink="true">https://code.furybee.org/articles/strategy-pattern/</guid><description>Replace complex if/else chains and switch statements with the Strategy pattern for more maintainable and extensible code.</description><pubDate>Fri, 25 Apr 2025 00:00:00 GMT</pubDate><category>Design Patterns</category><category>strategy</category><category>design-patterns</category><category>conditionals</category><category>typescript</category></item><item><title>TDD in Practice: Building a Real Feature</title><link>https://code.furybee.org/articles/tdd-in-practice/</link><guid isPermaLink="true">https://code.furybee.org/articles/tdd-in-practice/</guid><description>A practical walkthrough of Test-Driven Development building a shopping cart feature, showing the Red-Green-Refactor cycle in action.</description><pubDate>Sun, 20 Apr 2025 00:00:00 GMT</pubDate><category>Testing</category><category>tdd</category><category>testing</category><category>red-green-refactor</category><category>typescript</category></item><item><title>Replace Conditional with Polymorphism</title><link>https://code.furybee.org/articles/replace-conditional-polymorphism/</link><guid isPermaLink="true">https://code.furybee.org/articles/replace-conditional-polymorphism/</guid><description>Learn to transform complex conditional logic into clean polymorphic designs using TypeScript interfaces and classes.</description><pubDate>Tue, 15 Apr 2025 00:00:00 GMT</pubDate><category>Refactoring</category><category>refactoring</category><category>polymorphism</category><category>conditionals</category><category>typescript</category></item><item><title>The Boy Scout Rule: Leave Code Better Than You Found It</title><link>https://code.furybee.org/articles/boy-scout-rule/</link><guid isPermaLink="true">https://code.furybee.org/articles/boy-scout-rule/</guid><description>How the simple practice of making small improvements every time you touch code leads to dramatically better codebases over time.</description><pubDate>Thu, 10 Apr 2025 00:00:00 GMT</pubDate><category>Principles</category><category>boy-scout-rule</category><category>refactoring</category><category>clean-code</category><category>principles</category></item><item><title>Feature Envy and How to Fix It</title><link>https://code.furybee.org/articles/feature-envy/</link><guid isPermaLink="true">https://code.furybee.org/articles/feature-envy/</guid><description>When a method is more interested in another class&apos;s data than its own, you have Feature Envy. Learn to spot it and move behavior where it belongs.</description><pubDate>Sat, 05 Apr 2025 00:00:00 GMT</pubDate><category>Code Smells</category><category>feature-envy</category><category>code-smells</category><category>refactoring</category><category>encapsulation</category></item><item><title>Composition Over Inheritance: Why and How</title><link>https://code.furybee.org/articles/composition-over-inheritance/</link><guid isPermaLink="true">https://code.furybee.org/articles/composition-over-inheritance/</guid><description>Understanding why composition is often preferred over inheritance, with practical examples showing how to refactor class hierarchies into flexible, composable designs.</description><pubDate>Tue, 25 Mar 2025 00:00:00 GMT</pubDate><category>Principles</category><category>composition</category><category>inheritance</category><category>oop</category><category>design</category><category>typescript</category></item><item><title>Test Doubles: Mocks, Stubs, Fakes, Spies</title><link>https://code.furybee.org/articles/test-doubles/</link><guid isPermaLink="true">https://code.furybee.org/articles/test-doubles/</guid><description>Understand the differences between mocks, stubs, fakes, and spies — and when to use each for effective testing.</description><pubDate>Thu, 20 Mar 2025 00:00:00 GMT</pubDate><category>Testing</category><category>testing</category><category>mocks</category><category>stubs</category><category>fakes</category><category>spies</category></item><item><title>Repository Pattern for Data Access</title><link>https://code.furybee.org/articles/repository-pattern/</link><guid isPermaLink="true">https://code.furybee.org/articles/repository-pattern/</guid><description>Isolate your data access logic with the Repository pattern, making your application testable and database-agnostic.</description><pubDate>Sat, 15 Mar 2025 00:00:00 GMT</pubDate><category>Design Patterns</category><category>repository</category><category>design-patterns</category><category>data-access</category><category>typescript</category><category>architecture</category></item><item><title>Introduce Parameter Object</title><link>https://code.furybee.org/articles/introduce-parameter-object/</link><guid isPermaLink="true">https://code.furybee.org/articles/introduce-parameter-object/</guid><description>When functions have too many parameters, group them into meaningful objects. A simple refactoring that dramatically improves API design.</description><pubDate>Wed, 05 Mar 2025 00:00:00 GMT</pubDate><category>Refactoring</category><category>refactoring</category><category>parameter-object</category><category>api-design</category><category>typescript</category></item><item><title>Decorator Pattern in Practice</title><link>https://code.furybee.org/articles/decorator-pattern/</link><guid isPermaLink="true">https://code.furybee.org/articles/decorator-pattern/</guid><description>Learn to use the Decorator pattern to add responsibilities to objects dynamically, with TypeScript examples for logging, caching, and retry logic.</description><pubDate>Fri, 28 Feb 2025 00:00:00 GMT</pubDate><category>Design Patterns</category><category>decorator</category><category>design-patterns</category><category>typescript</category><category>structural</category></item><item><title>Integration Tests vs Unit Tests — Finding the Balance</title><link>https://code.furybee.org/articles/integration-vs-unit-tests/</link><guid isPermaLink="true">https://code.furybee.org/articles/integration-vs-unit-tests/</guid><description>Understanding the tradeoffs between unit and integration tests, and how to build a testing strategy that catches bugs efficiently.</description><pubDate>Tue, 25 Feb 2025 00:00:00 GMT</pubDate><category>Testing</category><category>testing</category><category>integration-tests</category><category>unit-tests</category><category>strategy</category></item><item><title>Law of Demeter: Don&apos;t Talk to Strangers</title><link>https://code.furybee.org/articles/law-of-demeter/</link><guid isPermaLink="true">https://code.furybee.org/articles/law-of-demeter/</guid><description>How the Law of Demeter reduces coupling, makes code more testable, and why train wrecks like a.getB().getC().doThing() are a design smell.</description><pubDate>Tue, 18 Feb 2025 00:00:00 GMT</pubDate><category>Principles</category><category>law-of-demeter</category><category>coupling</category><category>encapsulation</category><category>clean-code</category></item><item><title>Long Parameter Lists: Causes and Cures</title><link>https://code.furybee.org/articles/long-parameter-lists/</link><guid isPermaLink="true">https://code.furybee.org/articles/long-parameter-lists/</guid><description>Functions with too many parameters are hard to call, hard to test, and hard to maintain. Learn systematic approaches to taming them.</description><pubDate>Mon, 10 Feb 2025 00:00:00 GMT</pubDate><category>Code Smells</category><category>code-smells</category><category>parameters</category><category>refactoring</category><category>api-design</category></item><item><title>Primitive Obsession: When Strings Aren&apos;t Enough</title><link>https://code.furybee.org/articles/primitive-obsession/</link><guid isPermaLink="true">https://code.furybee.org/articles/primitive-obsession/</guid><description>Stop using primitive types for domain concepts. Learn how Value Objects and branded types catch bugs at compile time.</description><pubDate>Thu, 30 Jan 2025 00:00:00 GMT</pubDate><category>Code Smells</category><category>primitive-obsession</category><category>value-objects</category><category>typescript</category><category>code-smells</category></item><item><title>Singleton: When It&apos;s OK and When It&apos;s Not</title><link>https://code.furybee.org/articles/singleton-pattern/</link><guid isPermaLink="true">https://code.furybee.org/articles/singleton-pattern/</guid><description>The Singleton pattern is controversial. Learn when it&apos;s genuinely useful, when it&apos;s an anti-pattern, and better alternatives.</description><pubDate>Mon, 20 Jan 2025 00:00:00 GMT</pubDate><category>Design Patterns</category><category>singleton</category><category>design-patterns</category><category>anti-patterns</category><category>typescript</category></item><item><title>From Spaghetti to Clean: A Step-by-Step Refactoring</title><link>https://code.furybee.org/articles/spaghetti-to-clean/</link><guid isPermaLink="true">https://code.furybee.org/articles/spaghetti-to-clean/</guid><description>Walk through a complete refactoring of a messy real-world function, applying clean code principles one step at a time.</description><pubDate>Wed, 15 Jan 2025 00:00:00 GMT</pubDate><category>Refactoring</category><category>refactoring</category><category>step-by-step</category><category>before-after</category><category>clean-code</category></item></channel></rss>