Steve Losh's blog post explores leveraging the Common Lisp Object System (CLOS) for dependency management within Lisp applications. Instead of relying on external systems, Losh advocates using CLOS's built-in dependent maintenance protocol to automatically track and update derived values based on changes to their dependencies. He demonstrates this by creating a depending macro that simplifies defining these dependencies and automatically invalidates cached values when necessary. This approach offers a tightly integrated, efficient, and inherently Lisp-y solution to dependency tracking, reducing the need for external libraries or complex build processes. By handling dependencies within the language itself, this technique enhances code clarity and simplifies the overall development workflow.
The blog post "Inheritance and Subtyping" argues that inheritance and subtyping are distinct concepts often conflated, leading to inflexible and brittle code. Inheritance, a mechanism for code reuse, creates a tight coupling between classes, whereas subtyping, focused on behavioral compatibility, allows substitutability. The author advocates for composition over inheritance, suggesting interfaces and delegation as preferred alternatives for achieving polymorphism and code reuse. This approach promotes looser coupling, increased flexibility, and easier maintainability, ultimately leading to more robust and adaptable software design.
Hacker News users generally agree with the author's premise that inheritance is often misused, especially when subtyping isn't the goal. Several commenters point out that composition and interfaces are generally preferable, offering greater flexibility and avoiding the tight coupling inherent in inheritance. One commenter highlights the "fragile base class problem," where changes in a parent class can unexpectedly break child classes. Others discuss the nuances of Liskov Substitution Principle and how it relates to proper inheritance usage. One user specifically calls out Java's overuse of inheritance, citing the infamous AbstractSingletonProxyFactoryBean. A few dissenting opinions mention that inheritance can be a useful tool when used judiciously, especially in domains like game development where hierarchical relationships are naturally occurring.
Summary of Comments ( 2 )
https://news.ycombinator.com/item?id=43176358
Hacker News users discussed the complexity of Common Lisp's dependency system, particularly its use of the CLOS dependent maintenance protocol. Some found the system overly complex for simple tasks, arguing simpler dependency tracking mechanisms would suffice. Others highlighted the power and flexibility of CLOS for managing complex dependencies, especially in larger projects. The discussion also touched on the trade-offs between declarative and imperative approaches to dependency management, with some suggesting a hybrid approach could be beneficial. Several commenters appreciated the blog post for illuminating a lesser-known aspect of Common Lisp. A few users expressed interest in exploring other dependency management solutions within the Lisp ecosystem.
The Hacker News post titled "Depending in Common Lisp – Using the CLOS dependent maintenance protocol (2022)" has generated a modest number of comments, offering some interesting perspectives on dependency management in Common Lisp and comparing it to other systems.
One commenter highlights the elegance and power of the CLOS dependent maintenance protocol, arguing that it represents a sophisticated approach to dependency tracking and update propagation, surpassing the capabilities of many other dependency systems. They emphasize the seamless integration with the object system and the ability to define custom dependency relationships.
Another comment draws a parallel between the described Common Lisp system and the reactive programming paradigm, observing that the automatic update mechanism resembles the behavior of reactive frameworks. They suggest that this inherent reactivity simplifies complex application logic by automatically handling state changes and updates.
A separate comment chain discusses the trade-offs between the dynamic nature of Common Lisp and the static approaches found in languages like Java. Some argue that the dynamic nature allows for greater flexibility and rapid prototyping, while others express concerns about the potential for runtime errors and debugging challenges. The discussion touches on the benefits of both approaches, acknowledging the value of static analysis for catching errors early but also recognizing the power of dynamic systems for adapting to changing requirements.
One commenter questions the necessity of a separate dependency system within Common Lisp, proposing that the core language features already provide sufficient mechanisms for managing dependencies. They suggest that leveraging macros and functions can achieve similar results without introducing additional complexity. This sparks a brief discussion about the merits of specialized dependency management tools versus relying on fundamental language constructs.
Finally, a few comments provide additional context by mentioning related libraries and tools in the Common Lisp ecosystem, further enriching the understanding of dependency management in this context. They offer pointers to alternative approaches and resources for those interested in exploring the topic further.