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 Use immutable collections
Create immutable classes
Copy the collection before modification
Avoid collection getters
Avoid automatic properties
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]
  }
} 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]
  }
} 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. Related Reading https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xviii https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxvi https://hackernoon.com/finding-the-stinky-parts-of-your-code-code-smell-256-mutable-getters https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxii https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xiv More Info https://hackernoon.com/is-it-crystal-clear-for-everybody-that-a-date-should-not-mutate-wuoy3z03?embedable=true https://hackernoon.com/nude-models-part-ii-getters-sjo3ua2?embedable=true https://hackernoon.com/coupling-the-one-and-only-software-designing-problem-9z5a321h?embedable=true 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 https://hackernoon.com/400-thought-provoking-software-engineering-quotes?embedable=true This article is part of the CodeSmell Series on HackerNoon: How to Find the Stinky Parts of your Code Exposing your collections couples your solution Exposing your collections couples your solution TL;DR: Use immutable collections to prevent unintended side effects. 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 Unpredictable behavior Debugging challenges Data corruption Violation of the Principle of Least Astonishment Premature optimization Unexpected Mutations Mutations Concurrency problems Compromised thread safety Increased coupling coupling Solutions Use immutable collections Create immutable classes Copy the collection before modification Avoid collection getters Avoid automatic properties Favor information hiding and encapsulation Use immutable collections Create immutable classes Copy the collection before modification Avoid collection getters collection getters Avoid automatic properties automatic properties 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]
  }
} 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]
  }
} 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]
  }
} 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]
  }
} Detection [x]Semi-Automatic [x] Semi-Automatic [x] Several static analysis tools can warn you of aliasing abuse. Tags Immutability Immutability Level [x]Intermediate [x] Intermediate [x] 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. Related Reading https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xviii https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xviii https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxvi https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxvi https://hackernoon.com/finding-the-stinky-parts-of-your-code-code-smell-256-mutable-getters https://hackernoon.com/finding-the-stinky-parts-of-your-code-code-smell-256-mutable-getters https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxii https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxii https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xiv https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xiv More Info https://hackernoon.com/is-it-crystal-clear-for-everybody-that-a-date-should-not-mutate-wuoy3z03?embedable=true https://hackernoon.com/is-it-crystal-clear-for-everybody-that-a-date-should-not-mutate-wuoy3z03?embedable=true https://hackernoon.com/nude-models-part-ii-getters-sjo3ua2?embedable=true https://hackernoon.com/nude-models-part-ii-getters-sjo3ua2?embedable=true https://hackernoon.com/coupling-the-one-and-only-software-designing-problem-9z5a321h?embedable=true https://hackernoon.com/coupling-the-one-and-only-software-designing-problem-9z5a321h?embedable=true Disclaimer: Code Smells are my opinion. Disclaimer: Code Smells are my opinion . opinion Credits: Photo by Martino Pietropoli on Unsplash Credits: Photo by Martino Pietropoli on Unsplash Martino Pietropoli Unsplash If an object is immutable, it can be in only one state, and you win big. If an object is immutable, it can be in only one state, and you win big. Joshua Bloch Joshua Bloch https://hackernoon.com/400-thought-provoking-software-engineering-quotes?embedable=true https://hackernoon.com/400-thought-provoking-software-engineering-quotes?embedable=true This article is part of the CodeSmell Series on HackerNoon: How to Find the Stinky Parts of your Code This article is part of the CodeSmell Series on HackerNoon: How to Find the Stinky Parts of your Code How to Find the Stinky Parts of your Code

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

Code Smell 267 - Objects Aliasing

Code Smell 265 - Linguistic Confusion

Buy My Book

Share your ideas with me!

Read My Stories

Buy Me a Coffee

Too Long; Didn't Read

Make resilience your competitive advantage

Code Smell 266 - Collection Aliasing

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

10 Predictions About the Future of Finance

106 Stories To Learn About Clean Code

100 Pieces of Programming Advice from the Book Clean Code by Robert Martin

110 Stories To Learn About Refactoring

3 Things Coding And Prose Writing Have In Common According To Cory House

10 Predictions About the Future of Finance

106 Stories To Learn About Clean Code

100 Pieces of Programming Advice from the Book Clean Code by Robert Martin

110 Stories To Learn About Refactoring

3 Things Coding And Prose Writing Have In Common According To Cory House

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps