The blog post argues against using generic, top-level directories like .cache, .local, and .config for application caching and configuration in Unix-like systems. These directories quickly become cluttered, making it difficult to manage disk space, identify relevant files, and troubleshoot application issues. The author advocates for application developers to use XDG Base Directory Specification compliant paths within $HOME/.cache, $HOME/.local/share, and $HOME/.config, respectively, creating distinct subdirectories for each application. This structured approach improves organization, simplifies cleanup by application or user, and prevents naming conflicts. The lack of enforcement mechanisms for this specification and inconsistent adoption by applications are acknowledged as obstacles.
The blog post analyzes Caffeine, a Java caching library, focusing on its performance characteristics. It delves into Caffeine's core data structures, explaining how it leverages a modified version of the W-TinyLFU admission policy to effectively manage cached entries. The post examines the implementation details of this policy, including how it tracks frequency and recency of access through a probabilistic counting structure called the Sketch. It also explores Caffeine's use of a segmented, concurrent hash table, highlighting its role in achieving high throughput and scalability. Finally, the post discusses Caffeine's eviction process, demonstrating how it utilizes the TinyLFU policy and window-based sampling to maintain an efficient cache.
Hacker News users discussed Caffeine's design choices and performance characteristics. Several commenters praised the library's efficiency and clever implementation of various caching strategies. There was particular interest in its use of Window TinyLFU, a sophisticated eviction policy, and how it balances hit rate with memory usage. Some users shared their own experiences using Caffeine, highlighting its ease of integration and positive impact on application performance. The discussion also touched upon alternative caching libraries like Guava Cache and the challenges of benchmarking caching effectively. A few commenters delved into specific code details, discussing the use of generics and the complexity of concurrent data structures.
Summary of Comments ( 41 )
https://news.ycombinator.com/item?id=42945109
HN commenters largely agree that standardized cache directories are a good idea in principle but messy in practice. Several point out inconsistencies in how applications actually use
$XDG_CACHE_HOME, leading to wasted space and difficulty managing caches. Some suggest tools likebcachecould help, while others advocate for more granular control, like per-application cache directories or explicit opt-in/opt-out mechanisms. The lack of clear guidelines on cache eviction policies and the potential for sensitive data leakage are also highlighted as concerns. A few commenters mention that directories starting with a dot (.) are annoying for interactive shell users.The Hacker News post "The practical (Unix) problems with .cache and its friends" (https://news.ycombinator.com/item?id=42945109) has generated several comments discussing the merits and drawbacks of the XDG Base Directory Specification, particularly concerning the
.cachedirectory.Several commenters agree with the author of the linked blog post that while the specification is well-intentioned, its implementation has created practical issues. One commenter points out the annoyance of having numerous hidden directories cluttering their home directory, making navigation and management more cumbersome. They argue for a simpler, less fragmented approach to storing application data.
Another commenter echoes this sentiment, suggesting that the proliferation of these directories complicates tasks like backups and disk space analysis. They wish for a more consolidated approach, perhaps allowing applications to store cache data within their own installation directories, provided appropriate permissions are managed. This approach is countered by another user who highlights the security implications, stating that allowing applications write access to their installation directories could create vulnerabilities if those directories are shared by multiple users or if the application itself is compromised.
The discussion also touches upon the inconsistent adoption of the standard across different applications. Some commenters note that many applications still create their own application-specific directories within the home directory, rendering the XDG specification somewhat ineffective. They suggest that stronger enforcement or clearer guidelines are needed for developers to adhere to the standard.
One commenter offers a practical workaround by using symbolic links to relocate the
.cachedirectory to a dedicated partition or directory, allowing them to manage cache data separately. Another user suggests employing a tool liketrash-clito easily purge the contents of these directories when necessary.Some users express skepticism about the overall benefit of the standard, questioning whether the complexity introduced outweighs the advantages. They argue that the original intent – separating different types of application data – hasn't been fully realized, leading to a situation where users are burdened with managing a multitude of hidden directories without significant practical gain.
A few commenters suggest alternative solutions, such as utilizing a dedicated
/var/cachedirectory for all applications or leveraging more advanced filesystem features for managing temporary data. The idea of having package managers automatically clean up cache directories associated with uninstalled applications is also raised.In essence, the comments reflect a mixed reaction to the XDG Base Directory Specification and its implementation. While acknowledging the theoretical benefits of separating application data, many commenters express frustration with the practical implications of the standard, particularly the proliferation of hidden directories and inconsistent adoption across applications. Several workarounds and alternative approaches are suggested, highlighting a desire for a simpler, more streamlined approach to managing application data on Unix-like systems.