In the functional programming paradigm, immutability stands as a fundamental concept that might initially surprise many budding programmers. Unlike other paradigms like object-oriented or procedural programming, where you can change a variable's value at will, functional programming takes a different approach.
When we declare that a variable 'x' equals 5 in functional programming, it means 'x' will forever remain 5 throughout the program's execution. Conceptually, it's as if 'x' is locked in at 5, and there's no way to alter it.
Immutability, in essence, treats most values in our program as constants. Unlike some other languages, Python lacks a dedicated constant keyword to prevent variable changes. Therefore, we must be vigilant not to modify variables once we've assigned them.
We Don't Assign; We Define!
Think of it this way: In object-oriented and procedural programming, variables act like buckets that can hold different values at different times. We call this assigning values to variables. So, at one moment, 'x' might contain the value 3, and later it could hold -4, and so on.
On the contrary, in functional programming, we don't assign; we define. Instead of naming containers that hold different values, we name the values themselves. When we say 'x equals 3,' we mean 'x' is essentially another name for 3. It's akin to how 'pi' is just another name for 3.14159. We'd never think of changing the value of pi. Functional programming treats all values as concrete and unchanging, much like mathematical constants.
At first glance, this concept may seem peculiar to most programmers. After all, what's the use of a program where nothing can change? How can it be useful? Well, consider a quick example: Suppose we have an employee in a theoretical program, and we want to give them a raise.
In object-oriented programming, we can directly change the salary value, either by setting it to a new value or by calling a member function. In functional programming, however, we define a new constant representing the updated data and use it in future calculations.
Notice that in this example, we aren't creating a new object, as is common in object-oriented programming. Instead, we're defining our data using a dictionary (we'll explore why later on).
Immutability's advantage, and the reason functional programming places such importance on it, lies in its ability to free us from dealing with constant state changes. In programs with many variables changing frequently, it becomes challenging to know the program's state at any given time.
As programs grow in size with thousands or even millions of variables constantly changing, it leads to hard-to-detect bugs and a fragile codebase that programmers hesitate to modify. Even test-driven development struggles to solve this issue entirely, as testing all possible states in large programs is nearly impossible.
Functional programming starts with an immutable dataset as the source of truth, retrieved from a database or similar storage. It then uses functions to piece together and transform this data into information. This approach offers two powerful advantages:
- First, the original data in a program remains intact, making bugs easier to identify.
- Second, such programs are more manageable because you can focus on individual pieces without worrying about the entire system. Each piece's output depends solely on its input.
If immutability's concept isn't crystal clear yet, or its advantages aren't immediately apparent, don't fret. In later post sections, we'll delve into more immutability examples.
For now, remember that functional programming treats all data as immutable—once you've assigned a value to a variable, resist the urge to change it.