What are pure functions?

A pure function is a function that always produces the same output for the same input and has no side effects. Let's break down these characteristics:

1
Deterministic Output: A pure function's output is solely determined by its input parameters. If you provide the same inputs to a pure function multiple times, it will always return the same output. There is no randomness or unpredictability involved.
2
No Side Effects: A pure function doesn't modify any data outside of its scope. It doesn't interact with external systems, mutates global variables, or modify data structures. This ensures that calling the function doesn't affect anything beyond its own internal computations.

Pure functions offer several advantages:

1
Predictability: Since the output is solely determined by the input, pure functions are highly predictable and reliable. They make code easier to reason about and debug.
2
Testability: Due to their deterministic nature, pure functions are easy to test. You can provide specific inputs and check the corresponding outputs without worrying about external factors.
3
Parallelization: Because pure functions have no side effects, they can be safely executed in parallel or concurrently without causing conflicts.
4
Memoization: Since the output only depends on the input, the results of pure function calls can be cached (memoized) to improve performance.

The `add` function is pure because it takes two parameters and returns their sum, without modifying any external state or relying on any external data.

In this case, the `addToTotal` function modifies the `total` variable outside its scope, which makes it impure. It also relies on external data (`total`) to calculate its output.

In functional programming and libraries like Redux, pure functions are highly preferred, as they contribute to a more predictable and maintainable codebase by minimizing side effects and reducing complexity.

Difficulty: 4/10

Topics: immutability, side effects, referential transparency

Scenario Questions

0-2 years experience

1
If you need to calculate the total price of items in a shopping cart, how would you write a function that adds tax without mutating the original cart array?
2
What would happen if you called a function that mutates a global variable inside a loop that processes user input? How does that differ from a pure function?
3
Given a helper that reads a user setting from localStorage, how could you restructure it so the core logic stays pure?

2-5 years experience

1
Your team noticed that a date‑formatting utility started returning wrong values after a recent change. How would you investigate whether impurity is the cause?
2
When adding a caching layer, you consider memoizing a function. What trade‑offs do you evaluate before memoizing a pure function in production?
3
You need to compose several data‑transform steps to build a report. How do you ensure each step remains pure, and what problems arise if one step accesses external state?

5-8 years experience

1
Design a high‑throughput event‑processing pipeline. How would you use pure functions to improve testability and parallelism, and what limitations might you encounter?
2
Your microservice mixes logging with business logic, causing flaky tests. How would you refactor to isolate side effects, and what architectural changes are required?
3
Explain how you would use pure functions to enable deterministic replay of user actions in a collaborative editor, considering performance and memory constraints.

8+ years experience

1
The company wants to migrate a large legacy codebase to a functional style to reduce bugs. What strategy would you propose for introducing pure functions across multiple teams while minimizing disruption?
2
When building a cross‑service data‑synchronization platform, how does enforcing pure functions at service boundaries affect contract stability and observability?
3
Discuss the long‑term maintenance implications of mandating pure functions in a polyglot environment. How would you handle cases where side effects are unavoidable, like I/O?

Follow-up Questions

❓Can you walk me through a recent function you wrote that is pure?
❓How would you verify that a given function is pure?
❓What trade‑offs might arise when you force a function to be pure?