Stamp Coupling

The Bloated Signature Crisis As applications grow, functions inevitably gather parameters. You start with a search query, then add filters for dates, regions, and limits. Soon, your clean code morphs into an unmaintainable mess. This parameter explosion does not just hurt readability; it spreads through your codebase like a virus. When a group of arguments consistently travels together across multiple layers—like validation, caching, and database queries—it signals a missing domain concept. The Parameter Object Pattern solves this by packaging related data points into a cohesive, single object. Prerequisites To implement this pattern, you should have a solid grasp of basic object-oriented programming in Python and understand how functions receive arguments. Key Libraries & Tools * **dataclasses**: A built-in Python module that automatically generates special methods like `__init__()` and `__repr__()` for user-defined classes. Bundling Parameters with Dataclasses Let's refactor a messy search function. Instead of passing seven raw variables, we group them into a frozen data class. ```python from dataclasses import dataclass @dataclass(frozen=True) class VideoSearchQuery: query: str category: str limit: int = 10 region: str = "US" ``` Now, your high-level orchestration functions look incredibly clean because they only accept the query object: ```python def search_videos(query: VideoSearchQuery): # Much simpler to read and maintain cache_key = query.region return execute_search(query) ``` Syntax Notes: Post-Initialization Python dataclasses feature a special hook called `__post_init__`. This method executes immediately after the class constructs itself, providing the perfect place to run validation logic on your data group. Because the dataclass is frozen, you ensure your parameter object remains immutable throughout its lifecycle. The Threat of Stamp Coupling Beware of overusing this pattern. If a utility function only needs a single string like `region`, do not pass the entire `VideoSearchQuery` object to it. Doing so introduces stamp coupling. This anti-pattern binds your low-level helper functions to high-level query objects, making them hard to reuse in other parts of your app. Keep low-level utility functions simple by passing only the exact primitive values they need.