I had a client come to me with a custom-built plugin that was causing major headaches. On the surface, the request was simple: “Can you add a new shipping zone option?” But when I got into the codebase, I found a total spaghetti junction. Changing the shipping logic would break the inventory reporting, which would also break a special shortcode on the homepage. Total mess. The previous developer had created a tightly-coupled system, and it’s a perfect example of poor WordPress code quality.
This is a classic problem. It’s not about bad intentions; it’s about understanding two key ideas from software design that are often overlooked in the WordPress world: coupling and cohesion. These concepts are explained in great academic detail over at carlalexander.ca, but I’ll give you the straight-up dev-to-client version.
The “Christmas Lights” Problem: Tight Coupling
Imagine a tangled ball of Christmas lights. You pull one wire, and the whole knot gets tighter. That’s tight coupling. It’s when different parts of your code are so dependent on each other that a change in one place has unpredictable effects elsewhere. In WordPress, a common culprit is the overuse of global variables. You’ve got functions that all rely on the global $post object to work. It seems easy at first, but it makes your code rigid and fragile.
My first thought with the client’s plugin was to find the main shipping function and just add a conditional. A quick fix. But because everything was so tangled, that “quick fix” would have silently broken two other features. That’s the danger of tight coupling. The right way is to aim for loose coupling, where each piece of code is more like a LEGO block—self-contained and predictable.
<?php
// Bad: Tightly coupled to the global state. Hard to test or reuse.
function my_plugin_show_title() {
global $post;
echo '<h1>' . esc_html( $post->post_title ) . '</h1>';
}
// Good: Loosely coupled. The dependency is passed in. Predictable.
function my_plugin_show_title( WP_Post $post_object ) {
echo '<h1>' . esc_html( $post_object->post_title ) . '</h1>';
}The “Junk Drawer” Class: Low Cohesion
The other side of this coin is cohesion. Think about that junk drawer in your kitchen. It’s got batteries, rubber bands, some old keys, a single earring… nothing is related. That’s a class or a file with low cohesion. The code is grouped together not because it belongs together, but just… because. The client’s plugin had a file called `class-utilities.php` that was over 2,000 lines long. It had everything from database queries to shortcode rendering to CSS generation. A total nightmare to navigate.
High cohesion, on the other hand, is like a well-organized toolbox. You have a drawer for screwdrivers, a drawer for wrenches. Each class has one clear job. A `StripeApiHandler` class only handles Stripe API calls. A `CustomPostTypeManager` only registers and manages post types. This makes the code understandable, maintainable, and reusable.
So, What’s the Point?
When code is tightly coupled and has low cohesion, every single update or bug fix takes longer and costs more. Period. It’s technical debt that you, the client, end up paying for. Writing clean, well-structured code isn’t about some academic ideal; it’s about respecting your time and money. The goal is to build something that can evolve without falling apart.
- Low Coupling: Aim for independent components.
- High Cohesion: Ensure every class has a single, clear purpose.
Look, this stuff gets complicated fast. If you’re tired of debugging someone else’s mess and just want your site to work, drop my team a line. We’ve probably seen it before.
Leave a Reply