Pure functions produce the same output for the same input and have no side effects

TL;DR: Your functions should be replaceable by the computation result.

Problems

Readability
Principle of least astonishment violation
Testability
Coupling

Solutions

Avoid side effects and erratic behavior

Context

Breaking referential transparency occurs when the code introduces side effects or relies on a mutable state.

This violates the principle that an expression or function can be replaced with its value without changing the program's behavior.

Sample Code

Wrong

# Global mutable variable
counter = 0

# Function with side effect
def increment_counter():
    global counter
    counter += 1
    return counter

# Function with implicit dependency and non-deterministic
def get_random_number():
    import random
    return random.randint(1, 100)

# Function with non-deterministic behavior
def get_current_time():
    import time
    return time.time()

Right

import random
import time

# Function without side effects
def increment_counter(counter):
    return counter + 1

# Function without side effects (but not deterministic)
def get_random_number():
    return random.randint(1, 100)

# Function without side effects (can also be injected)
def get_current_time(timesource):
    return timesource.time()

Detection

[X] Semi-Automatic

Many linters warn you when you violate referential transparency

Level

[x] Intermediate

AI Assistants

Most AI assistants will avoid violating referential transparency.

Conclusion

Functional programming is known for its ability to enable concise, expressive, and maintainable code, as well as facilitating parallel and concurrent programming due to its emphasis on immutable data and pure functions.

There are many concepts to borrow from it.

Relations

Code Smell 209 - Side Effects

Maxi Contieri ・ Apr 28 '23

#webdev #javascript #beginners #programming

More Info

Coupling: The one and only software design problem

Maxi Contieri ・ Feb 6 '21

#webdev #programming #oop #tutorial

Disclaimer

Code Smells are my opinion.

Credits

Photo by Wilhelm Gunkel on Unsplash

Referential transparency is a very desirable property: it implies that functions consistently yield the same results given the same input, irrespective of where and when they are invoked.

Edward Garson

Software Engineering Great Quotes

Maxi Contieri ・ Dec 28 '20

#codenewbie #programming #quotes #software

This article is part of the CodeSmell Series.

How to Find the Stinky parts of your Code

Maxi Contieri ・ May 21 '21

#codenewbie #tutorial #codequality #beginners

Code Smell 241- Referential Transparency Violation