Software Engineering Stack Exchange is a question and answer site for professionals, academics, and students working within the systems development life cycle. It only takes a minute to sign up.
Sign up to join this community
As I understand it, writing your objects in an immutable style can help the performance of your program for compiled languages, as the compiler tends to rewrite your code in single static assignment form under the hood anyway.
Is there a performance benefit to using immutable objects in an interpreted language like Python or PHP?
I understand there may be readability or code quality benefits from immutability, but I am asking specifically about performance.
In CPython, allocation of tuples (basically immutable lists) can be slightly faster than an allocation of the equivalent mutable type with the same items. I vaguely remember similar rumors about immuable sets, but timeit didn't confirm it. Tuples can also be smaller than lists, from a few bytes to 50% (if you hit a spot where the list had to resize, and doubled its capacity to speed up future growth). Moreover, tuples and sets are - in some contexts - subject to peephole optimizations which allow creating the object once and re-using it instead of re-building it every time.
But that's mostly peanuts. It's not why we use these types, at least usually. If ever, these differences are only invoked when seriously optimizing. It's not an aspect I usually consider when deciding for either, especially since there are other benefits, not to mention the enormous semantic impact.
The major benefit of immutable variables come the moment you go distributed and have your data spread over several computers. Mutable data needs elaborate mechanisms to ensure that when data is updated, all copies in various caches are updated too, which besides being elaborate also take time.
Immutable data can be copied and cached as much as is needed. You are guaranteed that the data will not change.
I do not know if Jython supports multi-threading, if so, it would be an advantage on heavily multithreaded, multi-core applications.
In Python there is nothing in the language itself to mark an object as immutable so no hints can be given to the interpreter for optimization.
If the process is threaded and the object has "protected" properties then programmers don't need to worry about synchronization when using that object so there could be a performance gain.
in Python and PHP there's very little benefit, most of it because immutable structures are usually simpler and smaller because they don't have to support any modifying feature.
OTOH, modern JITs (like LuaJIT or any modern JavaScript) could take advantage of any opportunity to constrain possibilities and produce tighter code (similar to what compilers do, but way more aggressively).
