Favor immutability to retain control of your objects TL;DR: Use immutable objects to prevent unexpected changes caused by aliasing. Problems Unexpected mutations
Difficult bug tracking
Unpredictable code behavior
Reduced code predictability
Increased coupling
Compromised thread safety Solutions Use immutable objects
Implement defensive copying
Favor functional programming Refactorings https://maximilianocontieri.com/refactoring-008-convert-variables-to-constant?embedable=true Context Aliasing happens when multiple references point to the same mutable object. This can lead to unexpected changes in them when one part of the code modifies the object, affecting all references. Immutable objects mitigate this risk by ensuring you cannot change their internal representation once you create an object. Collection Aliasing is a notable example of this issue. Sample Code Wrong public class Person {
  private String name; 
}

public void modifyPerson(Person person) {
  person.setName("Cosmo Kramer");
}

public static void main(String[] args) {
  Person p1 = new Person("Newman");
  Person p2 = p1; // p1 and p2 refer to the same object

  modifyPerson(p1);

  System.out.println(p1.name()); // Output: Cosmo Kramer
  System.out.println(p2.name()); // Output: Cosmo Kramer (unexpected)
} Right public class ImmutablePerson {
  private final String name; 

  public ImmutablePerson(String name) {
    this.name = name; 
  } 
}

public ImmutablePerson withName(String newName) {
    return new ImmutablePerson(newName);
}

public static void main(String[] args) {
  ImmutablePerson p1 = new ImmutablePerson("Newman");
  ImmutablePerson p2 = p1; // p1 and p2 refer to the same object

  // Modifying p1 creates a new object
  ImmutablePerson p3 = p1.withName("Cosmo Kramer");
  // but this is a bad practice 
  // since only constructors should create new objects
  // A better option is
  ImmutablePerson p3 = new ImmutablePerson("Cosmo Kramer");

  System.out.println(p1.name()); // Output: Newman
  System.out.println(p2.name()); // Output: Newman
  System.out.println(p3.name()); // Output: Cosmo Kramer
} Detection [x]Semi-Automatic You can detect this smell by reviewing your code for mutable objects shared across different parts of your program. Tag(s) Mutability Level [x]Intermediate AI Generation AI generators might introduce this smell if they're not specifically trained to prioritize immutability and avoid aliasing issues. AI Detection AI detectors identify this smell by analyzing code for mutable shared objects and suggesting immutable alternatives. They need specific instructions on the context and the importance of immutability in the codebase. Try Them! Remember AI Assistants make lots of mistakes ChatGPT	 Claude
Perplexity
Gemini Conclusion Using immutable objects and avoiding aliasing can significantly improve your code's predictability, reduces bugs, and improves thread safety. It requires a shift in thinking and the benefits of immutability far outweigh the initial learning curve. Related Reading https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxxvi https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxvi https://hackernoon.com/code-smell-266-collection-aliasing?embedable=true https://hackernoon.com/is-it-crystal-clear-for-everybody-that-a-date-should-not-mutate-wuoy3z03?embedable=true Disclaimer: Code Smells are my opinion. Credits: Photo by Natural Photos on Unsplash Immutability changes everything. Pat Helland 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 Favor immutability to retain control of your objects Favor immutability to retain control of your objects TL;DR: Use immutable objects to prevent unexpected changes caused by aliasing. TL;DR: Use immutable objects to prevent unexpected changes caused by aliasing. Problems Unexpected mutations Difficult bug tracking Unpredictable code behavior Reduced code predictability Increased coupling Compromised thread safety Unexpected mutations mutations Difficult bug tracking Unpredictable code behavior Reduced code predictability Increased coupling Compromised thread safety Solutions Use immutable objects Implement defensive copying Favor functional programming Use immutable objects Implement defensive copying Favor functional programming Refactorings https://maximilianocontieri.com/refactoring-008-convert-variables-to-constant?embedable=true https://maximilianocontieri.com/refactoring-008-convert-variables-to-constant?embedable=true Context Aliasing happens when multiple references point to the same mutable object. This can lead to unexpected changes in them when one part of the code modifies the object, affecting all references. Immutable objects mitigate this risk by ensuring you cannot change their internal representation once you create an object. Collection Aliasing is a notable example of this issue. Collection Aliasing Sample Code Wrong public class Person {
  private String name; 
}

public void modifyPerson(Person person) {
  person.setName("Cosmo Kramer");
}

public static void main(String[] args) {
  Person p1 = new Person("Newman");
  Person p2 = p1; // p1 and p2 refer to the same object

  modifyPerson(p1);

  System.out.println(p1.name()); // Output: Cosmo Kramer
  System.out.println(p2.name()); // Output: Cosmo Kramer (unexpected)
} public class Person {
  private String name; 
}

public void modifyPerson(Person person) {
  person.setName("Cosmo Kramer");
}

public static void main(String[] args) {
  Person p1 = new Person("Newman");
  Person p2 = p1; // p1 and p2 refer to the same object

  modifyPerson(p1);

  System.out.println(p1.name()); // Output: Cosmo Kramer
  System.out.println(p2.name()); // Output: Cosmo Kramer (unexpected)
} Right public class ImmutablePerson {
  private final String name; 

  public ImmutablePerson(String name) {
    this.name = name; 
  } 
}

public ImmutablePerson withName(String newName) {
    return new ImmutablePerson(newName);
}

public static void main(String[] args) {
  ImmutablePerson p1 = new ImmutablePerson("Newman");
  ImmutablePerson p2 = p1; // p1 and p2 refer to the same object

  // Modifying p1 creates a new object
  ImmutablePerson p3 = p1.withName("Cosmo Kramer");
  // but this is a bad practice 
  // since only constructors should create new objects
  // A better option is
  ImmutablePerson p3 = new ImmutablePerson("Cosmo Kramer");

  System.out.println(p1.name()); // Output: Newman
  System.out.println(p2.name()); // Output: Newman
  System.out.println(p3.name()); // Output: Cosmo Kramer
} public class ImmutablePerson {
  private final String name; 

  public ImmutablePerson(String name) {
    this.name = name; 
  } 
}

public ImmutablePerson withName(String newName) {
    return new ImmutablePerson(newName);
}

public static void main(String[] args) {
  ImmutablePerson p1 = new ImmutablePerson("Newman");
  ImmutablePerson p2 = p1; // p1 and p2 refer to the same object

  // Modifying p1 creates a new object
  ImmutablePerson p3 = p1.withName("Cosmo Kramer");
  // but this is a bad practice 
  // since only constructors should create new objects
  // A better option is
  ImmutablePerson p3 = new ImmutablePerson("Cosmo Kramer");

  System.out.println(p1.name()); // Output: Newman
  System.out.println(p2.name()); // Output: Newman
  System.out.println(p3.name()); // Output: Cosmo Kramer
} Detection [x]Semi-Automatic [x] Semi-Automatic [x] You can detect this smell by reviewing your code for mutable objects shared across different parts of your program. Tag(s) Mutability Mutability Level [x]Intermediate [x] Intermediate [x] AI Generation AI generators might introduce this smell if they're not specifically trained to prioritize immutability and avoid aliasing issues. AI Detection AI detectors identify this smell by analyzing code for mutable shared objects and suggesting immutable alternatives. They need specific instructions on the context and the importance of immutability in the codebase. Try Them! Remember AI Assistants make lots of mistakes Remember AI Assistants make lots of mistakes ChatGPT Claude Perplexity Gemini ChatGPT Claude Perplexity Gemini Conclusion Using immutable objects and avoiding aliasing can significantly improve your code's predictability, reduces bugs, and improves thread safety. It requires a shift in thinking and the benefits of immutability far outweigh the initial learning curve. Related Reading https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxxvi https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxxvi 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/code-smell-266-collection-aliasing?embedable=true https://hackernoon.com/code-smell-266-collection-aliasing?embedable=true 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 Disclaimer: Code Smells are my opinion. Disclaimer: Code Smells are my opinion . opinion Credits: Photo by Natural Photos on Unsplash Credits: Photo by Natural Photos on Unsplash Natural Photos Unsplash Immutability changes everything. Immutability changes everything. Pat Helland Pat Helland 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 268 - Ternary Metaprogramming

Code Smell 266 - Collection Aliasing

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 267 - Objects Aliasing

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

10 Predictions About the Future of Finance

AI-Assisted Coding with Tabnine

DOE v. Github: Code Stored on GitHub Ultimately Belong to Their Authors

DOE v. Github: Defendants' Conduct Raises Questions Related to DMCA Violations, Privacy, Data Breach

DOE v. Github: Defendants Never Sought Permission to Use Others' Code to Train Codex or Copilot

10 Predictions About the Future of Finance

AI-Assisted Coding with Tabnine

DOE v. Github: Code Stored on GitHub Ultimately Belong to Their Authors

DOE v. Github: Defendants' Conduct Raises Questions Related to DMCA Violations, Privacy, Data Breach

DOE v. Github: Defendants Never Sought Permission to Use Others' Code to Train Codex or Copilot

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps