Erlang's defining characteristics aren't lightweight processes and message passing, but rather its error handling philosophy. The author argues that Erlang's true power comes from embracing failure as inevitable and providing mechanisms to isolate and manage it. This is achieved through the "let it crash" philosophy, where individual processes are allowed to fail without impacting the overall system, combined with supervisor hierarchies that restart failed processes and maintain system stability. The lightweight processes and message passing are merely tools that facilitate this error handling approach by providing isolation and a means for asynchronous communication between supervised components. Ultimately, Erlang's strength lies in its ability to build robust and fault-tolerant systems.
F# offers a compelling blend of functional and object-oriented programming, making it suitable for diverse tasks from scripting and data science to full-fledged applications. Its succinct syntax, strong type system, and emphasis on immutability enhance code clarity, maintainability, and correctness. Features like type inference, pattern matching, and computational expressions streamline development, enabling developers to write concise yet powerful code. While benefiting from the .NET ecosystem and interoperability with C#, F#'s distinct functional-first approach fosters a different, often more elegant, way of solving problems. This translates to improved developer productivity and more robust software.
Hacker News users discuss the merits of F#, often comparing it to other functional languages like OCaml, Haskell, and Clojure. Some commenters appreciate F#'s practicality and ease of use, especially within the .NET ecosystem, highlighting its strong typing and tooling. Others find its functional purity less strict than Haskell's, viewing it as both a benefit (pragmatism) and a drawback (potential for less elegant code). The discussion touches on F#'s suitability for specific domains like data science and web development, with some expressing enthusiasm while others note the prevalence of C# in those areas within the .NET world. Several comments lament the comparatively smaller community and ecosystem surrounding F#, despite acknowledging its technical strengths. The overall sentiment appears to be one of respect for F# but also a recognition of its niche status.
This post advocates for using Ruby's built-in features, specifically Struct, to create value objects. It argues against using gems like Virtus or hand-rolling complex classes, emphasizing simplicity and performance. The author demonstrates how Struct provides concise syntax for defining immutable attributes, automatic equality comparisons based on attribute values, and a convenient way to represent data structures focused on holding values rather than behavior. This approach aligns with Ruby's philosophy of minimizing boilerplate and leveraging existing tools for common patterns. By using Struct, developers can create lightweight, efficient value objects without sacrificing readability or conciseness.
HN commenters largely criticized the article for misusing or misunderstanding the term "value object." They argued that true value objects are defined by their attributes and compared by value, not identity, using examples like 5 == 5 even if they are different instances of the integer 5. They pointed out that the author's use of Comparable and overriding == based on specific attributes leaned more towards a Data Transfer Object (DTO) or a record. Some questioned the practical value of the approach presented, suggesting simpler alternatives like using structs or plain Ruby objects with attribute readers. A few commenters offered different ways to implement proper value objects in Ruby, including using the Values gem and leveraging immutable data structures.
The blog post "Gleam, Coming from Erlang" explores the author's experience transitioning from Erlang to Gleam, a newer language built on the Erlang Virtual Machine (BEAM). It highlights Gleam's similarities to Erlang, such as its functional nature, immutability, and the benefits of the BEAM ecosystem like concurrency and fault tolerance. However, the author emphasizes key differences, primarily Gleam's static typing, more approachable syntax inspired by Rust and Elm, and its focus on clearer error messages. While acknowledging some current limitations in tooling and library availability compared to Erlang's mature ecosystem, the post ultimately presents Gleam as a promising alternative for building robust, concurrent applications, particularly for developers coming from other statically-typed languages who might find Erlang's syntax challenging.
Hacker News commenters generally expressed interest in Gleam, praising its friendly syntax and the benefits it inherits from the Erlang ecosystem, like the BEAM VM. Some saw it as a potentially strong competitor to Elixir, appreciating its stricter type system and simpler tooling. A few users familiar with Erlang questioned the necessity of Gleam, suggesting that learning Erlang directly might be more worthwhile. Performance comparisons with Elixir and other BEAM languages were also a topic of discussion, with some expressing hope for benchmarks. A recurring sentiment was curiosity about Gleam's potential to attract a larger community and gain wider adoption. Several commenters also appreciated the author's candid comparison between Gleam and Erlang, finding the article helpful for understanding Gleam's niche.
Clojure offers a compelling blend of practicality and powerful abstractions. Its Lisp syntax, while initially daunting, promotes code clarity and conciseness once mastered. Immutability by default simplifies reasoning about code and facilitates concurrency, while the dynamic nature allows for rapid prototyping and interactive development. Leveraging the vast Java ecosystem provides stability and performance, and the focus on functional programming principles encourages robust and maintainable applications. Ultimately, Clojure empowers developers to build complex systems with elegance and efficiency.
HN commenters generally agree with the author's points on Clojure's strengths, particularly its simple, consistent syntax, powerful data structures, and the benefits of immutability and functional programming for concurrency. Some discuss practical advantages in their own work, citing increased productivity and fewer bugs. A few caution that Clojure's unique features have a learning curve and can make debugging more challenging. Others mention Lisp's historical influence and the powerful REPL as key benefits, while some debate the practicality of Clojure's immutability and the ecosystem's reliance on Java. Several commenters highlight Clojure's suitability for specific domains like data processing and web development. There's also discussion around tooling, with some praise for Clojure's tooling and others mentioning room for improvement.
This paper argues that immutable data structures, coupled with efficient garbage collection and data sharing, fundamentally alter database design and offer significant performance advantages. Traditional databases rely on mutable updates, leading to complex concurrency control mechanisms and logging for crash recovery. Immutability simplifies these by allowing readers to operate without locks and recovery to become merely restarting the latest transaction. The authors present a prototype system, ImmuDB, demonstrating these benefits with comparable or superior performance to mutable systems, particularly in read-dominated workloads. ImmuDB uses an append-only storage structure, multi-version concurrency control, and employs techniques like path copying for efficient data modifications. The paper concludes that embracing immutability unlocks new possibilities for database architectures, enabling simpler, more scalable, and potentially faster databases.
Hacker News users discuss the benefits and drawbacks of immutability in databases, particularly in the context of the linked paper. Several commenters praise the performance advantages and simplified reasoning that immutability offers, echoing the paper's points. Some highlight the potential downsides, such as increased storage costs and the complexity of implementing efficient versioning. One commenter questions the practicality of truly immutable databases in real-world scenarios requiring updates, suggesting the term "append-only" might be more accurate. Another emphasizes the importance of understanding the nuances of immutability rather than viewing it as a simple binary concept. There's also discussion on the different types of immutability and their respective trade-offs, with mention of Datomic and its approach to immutability. A few users express skepticism about widespread adoption, citing the inertia of existing relational database systems.
Summary of Comments ( 164 )
https://news.ycombinator.com/item?id=43655221
Hacker News users discussed the meaning and significance of "lightweight processes and message passing" in Erlang. Several commenters argued that the author missed the point, emphasizing that the true power of Erlang lies in its fault tolerance and the "let it crash" philosophy enabled by lightweight processes and isolation. They argued that while other languages might technically offer similar concurrency mechanisms, they lack Erlang's robust error handling and ability to build genuinely fault-tolerant systems. Some commenters pointed out that immutability and the single assignment paradigm are also crucial to Erlang's strengths. A few comments focused on the challenges of debugging Erlang systems and the potential performance overhead of message passing. Others highlighted the benefits of the actor model for concurrency and distribution. Overall, the discussion centered on the nuances of Erlang's design and whether the author adequately captured its core value proposition.
The Hacker News post titled "Erlang's not about lightweight processes and message passing (2023)" generated several comments discussing the author's viewpoint on Erlang's core strengths.
Several commenters agreed with the author's assertion that immutability is a crucial aspect of Erlang, enabling easier reasoning about code and simplifying debugging. One commenter highlighted the benefits of immutability in concurrent programming, suggesting that it allows developers to avoid many of the pitfalls associated with shared mutable state. Another emphasized the significance of immutability by drawing a parallel to functional programming paradigms and their advantages.
The discussion also explored the concept of "behavior" as a core component of Erlang. Some commenters saw this as a powerful abstraction for building concurrent systems, allowing developers to define patterns of interaction between processes in a structured way. This view was further supported by a commenter who pointed out the similarities between Erlang's behaviors and the actor model, where actors communicate through message passing.
The notion of lightweight processes and message passing, while acknowledged as part of Erlang, was not considered the primary defining characteristic by several commenters. They argued that these features, while important for concurrency, are mechanisms to achieve higher-level goals like fault tolerance and scalability, which are ultimately what make Erlang unique. One commenter specifically stated that the real strength of Erlang lies in its ability to build robust and resilient systems, rather than just its implementation details.
There was also discussion about the learning curve associated with Erlang and its suitability for different types of projects. While some commenters acknowledged its complexity, others emphasized the value of the robustness and reliability it offers, especially for critical systems.
Some commenters also drew comparisons between Erlang and other languages like Smalltalk, highlighting similarities in their approach to message passing and concurrency. This comparison prompted further discussion about the historical context and influences on Erlang's design.
Finally, a few comments touched upon alternative approaches to concurrency, such as using shared memory and mutexes, and discussed their trade-offs compared to Erlang's message-passing model. These comments offered a broader perspective on concurrency models and their applicability in different scenarios.