DEV Community

Cover image for Code Smell 266 - Collection Aliasing
Maxi Contieri
Maxi Contieri

Posted on • Originally published at maximilianocontieri.com

3

Code Smell 266 - Collection Aliasing

Exposing your collections couples your solution

TL;DR: Use immutable collections to prevent unintended side effects.

Problems

  • Unpredictable behavior
  • Debugging challenges
  • Data corruption
  • Violation of the Principle of Least Astonishment
  • Premature optimization
  • Unexpected Mutations
  • Concurrency problems
  • Compromised thread safety
  • Increased coupling

Solutions

  1. Use immutable collections
  2. Create immutable classes
  3. Copy the collection before modification
  4. Avoid collection getters
  5. Avoid automatic properties
  6. Favor information hiding and encapsulation

Context

Aliasing happens when two or more variables refer to the same object.

This can lead to unexpected side effects, especially when one variable modifies the shared object.

You can't change immutable collections after creation helping you prevent accidental aliasing.

Premature optimizators will argue that copying collections is an expensive operation that you should avoid.

This is a special case of Object Aliasing

Sample Code

Wrong

public class MutableExample {
  public static void main(String[] args) {
    List<Integer> numbers = List.of(1, 2, 3);
    List<Integer> otherNumbers = numbers; // Aliasing
    otherNumbers.add(4);
    System.out.println(numbers); // Output: [1, 2, 3, 4]
  }
}
Enter fullscreen mode Exit fullscreen mode

Right

public class ImmutableExample {
  public static void main(String[] args) {
    List<Integer> numbers = List.of(1, 2, 3);
    List<Integer> otherNumbers = List.copyOf(numbers); // Creating a copy
    otherNumbers.add(4);
    System.out.println(numbers); // Output: [1, 2, 3]
  }
}
Enter fullscreen mode Exit fullscreen mode

Detection

[X] Semi-Automatic

Several static analysis tools can warn you of aliasing abuse.

Tags

  • Immutability

Level

[x] Intermediate

AI Generation

AI code generators might not always create immutable objects by default, especially when working with mutable collections.

You can prompt them to prioritize immutable collections and wrap existing ones to avoid aliasing.

AI Detection

AI tools can analyze code for potential aliasing issues and suggest using immutable collections instead.

Conclusion

You can avoid unintended side effects using immutable collections.

This will make your code more predictable and easier to reason about.

Relations

More Info

Disclaimer

Code Smells are my opinion.

Credits

Photo by Martino Pietropoli on Unsplash


If an object is immutable, it can be in only one state, and you win big.

Joshua Bloch


This article is part of the CodeSmell Series.

Image of Docusign

🛠️ Bring your solution into Docusign. Reach over 1.6M customers.

Docusign is now extensible. Overcome challenges with disconnected products and inaccessible data by bringing your solutions into Docusign and publishing to 1.6M customers in the App Center.

Learn more

Top comments (0)

Billboard image

The Next Generation Developer Platform

Coherence is the first Platform-as-a-Service you can control. Unlike "black-box" platforms that are opinionated about the infra you can deploy, Coherence is powered by CNC, the open-source IaC framework, which offers limitless customization.

Learn more

👋 Kindness is contagious

Please leave a ❤️ or a friendly comment on this post if you found it helpful!

Okay