Code Smell - 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 numbers = List.of(1, 2, 3); List otherNumbers = numbers; // Aliasing otherNumbers.add(4); System.out.println(numbers); // Output: [1, 2, 3, 4] } }

Right

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

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

Code Smell 86 - Mutable Const Arrays

Maxi Contieri ・ Aug 25 '21

#javascript #oop #programming #codenewbie

Code Smell 127 - Mutable Constants

Maxi Contieri ・ Apr 5 '22

#tutorial #webdev #javascript #beginners

Code Smell 256 - Mutable Getters

Maxi Contieri ・ Jun 29

#webdev #beginners #programming #java

Code Smell 109 - Automatic Properties

Maxi Contieri ・ Dec 7 '21

#oop #webdev #codenewbie #tutorial

Code Smell 68 - Getters

Maxi Contieri ・ Apr 29 '21

#codenewbie #tutorial #oop #programming

More Info

Les pouvoirs maléfiques des mutants

Maxi Contieri ・ 19 décembre 20

#webdev #programmation #mutation #oop

Modèles nus — Partie II : Getters

Maxi Contieri ・ 23 février 21

#webdev #programmation #oop #tutoriel

Couplage : le seul et unique problème de conception logicielle

Maxi Contieri ・ 6 février 21

#webdev #programmation #oop #tutoriel

Clause de non-responsabilité

Les odeurs de code sont mon opinion.

Crédits

Photo de Martino Pietropoli sur Unsplash

Si un objet est immuable, il ne peut être que dans un seul état, et vous gagnez gros.

Josué Bloch

Citations intéressantes sur le génie logiciel

Maxi Contieri ・ 28 décembre 20

#codenewbie #programmation #citations #logiciel

Cet article fait partie de la série CodeSmell.

Comment trouver les parties puantes de votre code

Maxi Contieri ・ 21 mai '21

#codenewbie #tutoriel #qualitéducode #débutants

The above is the detailed content of Code Smell - Collection Aliasing. For more information, please follow other related articles on the PHP Chinese website!