Clojure 1.11.4
Clojure 1.11.4 is now available with the following fixes: CLJ-2145 Fix clearing of closed overs in ^:once fns In some cases (see the ticket for details), functions that closed-over bindings in the outer scope were not clearing the use of those bindings in the inner function scope, which could potentially cause head-holding. These closed-overs are now clearable for garbage collection. CLJ-2317 recur to head of :once fn cancels once The :once function metadata is a hint to the compiler that a function will only be run once, and thus closed-over fields may be cleared. It is nonsensical to recur to the head of a :once fn (as that implies running it more than once), but this situation can arise through the use of macros that apply wrap arbitrary bodies in :once fns. In this case closed-over fields would sometimes be cleared prior to the recur. Now, use of recur to the head of a :once fn will ignore the :once flag and closed-over fields will not be cleared in the fn. Clearing of other local fields (not closed-over) is unchanged.
Clojure 1.11.4 has been released, bringing two significant fixes that address issues related to garbage collection and function behavior in the Clojure programming language. These updates are crucial for developers who rely on Clojure's unique features, such as the `:once` function metadata and `^:once` special forms, which help optimize performance by allowing the compiler to clear closed-over fields.
The first fix, CLJ-2145, resolves a problem with clearing closed-over bindings in `^:once` functions. In certain scenarios, functions that closed-over bindings in the outer scope were not properly clearing the use of those bindings in the inner function scope. This could lead to head-holding, a situation where memory cannot be garbage collected because the inner function still holds a reference to the outer scope. By addressing this issue, Clojure 1.11.4 ensures that these closed-overs are now clearable for garbage collection, preventing such memory leaks and improving overall performance.
The second fix, CLJ-2317, tackles a situation where using `recur` to jump to the head of a `:once` function would inadvertently clear closed-over fields. The `:once` metadata is a hint to the compiler that a function will only be run once, allowing it to clear closed-over fields. However, it is nonsensical to `recur` to the head of a `:once` function, as this implies running it more than once. This scenario can arise through the use of macros that wrap arbitrary bodies in `:once` functions. In previous versions, using `recur` in such cases would sometimes clear closed-over fields before the `recur`, causing unintended behavior.
In Clojure 1.11.4, using `recur` to the head of a `:once` function now ignores the `:once` flag, ensuring that closed-over fields are not cleared in the function. This change preserves the intended behavior of `:once` functions while avoiding unintended side effects. The clearing of other local fields, which are not closed-over, remains unchanged.
These updates not only fix critical issues but also enhance the reliability and performance of Clojure applications. Developers who have encountered the problems addressed by CLJ-2145 and CLJ-2317 will benefit from the improved garbage collection and function behavior. Additionally, Clojure 1.11.4 provides a more stable environment for those leveraging Clojure's unique features, allowing them to write efficient and maintainable code.
For those unfamiliar with Clojure's `:once` and `^:once` features, it's worth noting that they are designed to optimize performance by allowing the compiler to clear closed-over fields once a function has been executed. This can be particularly useful in scenarios where a function is intended to be run only once, such as during initialization or setup. By ensuring that these features work as expected, Clojure 1.11.4 further solidifies its reputation as a powerful and efficient language for building scalable and robust applications.
In conclusion, the release of Clojure 1.11.4 is a welcome update for developers who rely on the language's unique features. The fixes for CLJ-2145 and CLJ-2317 address critical issues related to garbage collection and function behavior, leading to improved performance and stability. As Clojure continues to evolve, these updates highlight the language's commitment to refining and enhancing its capabilities, making it an even more attractive choice for developers seeking to build innovative and efficient applications.
