Problems

Maintainability
Error Prone
Performance Penalties
Premature optimization
The principle of least astonishment principle violation
Bijection Violation
Duplication of Logic on breaking the attributes
Coupling

Solutions

Break Orthogonal behavior and properties

Context

Parsing data is always a problem, where joining elements is much easier than breaking them.

If you use a separator to break the attributes, you need to make sure the separator does not belong to the domain, and you should escape it.

If you map your data to relational databases, search queries will be more difficult and less performant for concatenated attributes.

Sample Code

Wrong

class Point {
    constructor(coordString) {
        this.coordString = coordString;
    }

    x() {
        const coords = this.coordString.split(',');
        if (coords.length !== 2) {
            throw new Error('Invalid coordinate string format');
        }
        return parseFloat(coords[0]);
    }

    y() {
        const coords = this.coordString.split(',');
        if (coords.length !== 2) {
            throw new Error('Invalid coordinate string format');
        }
        return parseFloat(coords[1]);
    }
}

Right

class Point {
    constructor(x, y) {
        this.x = x;
        this.y = y;
    }
}

Detection

[x]Semi-Automatic

This is a semantic smell, but you can find suspicious concatenation actions on peer reviews.

Level

[x]Beginner

AI Assistants

AI Assistants don't usually suggest this kind of premature optimization of bad rules.

Conclusion

Don't mix unrelated things since breaking things is always harder than having them separated.

Relations

Code Smell 20 - Premature Optimization

Disclaimer

Code Smells are my opinion.

Credits

Photo by Tomas Sobek on Unsplash

Design is choosing how you will fail.

Ron Fein

Software Engineering Great Quotes

This article is part of the CodeSmell Series.

How to Find the Stinky Parts of your Code

Code Smell 243 - Concatenated Properties