3 ms·

Dismissing a well-written and elaborate post in a one-liner with no convincing arguments is usually considered bad form. Cargo cult programming itself seems to

• Rusky 15y ago
  The application of monads to C++ metaprogramming could be described as cargo cult programming, even if this post is a well-thought-out explanation of how it works. While it is true that they work to help organize libraries like Boost Proto, it is questionable whether that's the best or even a good way to accomplish that library's goals. There's a reason the metaprogramming-heavy parts of Boost are still generally avoided in many parts of the programming world. I see this as cargo cult because it appears as "monads are cool, and C++ templates are a weird functional language, let's do it that way" without much regard to whether monads, template metaprogramming or EDSLs are the right tools here.
• Miky 15y ago
  I guess we're using the term “cargo cult programming” about different things. I'm not arguing that the author of this post doesn't have a very good knowledge of C++, and a somewhat good knowledge of how monads are sometimes used in Haskell. The problem is that the way monads are sometimes used in Haskell is cargo cult mathematics (I'll explain in a moment), and the way he implements monads in C++ gains absolutely none of the benefits yielded by their use in Haskell, adding only useless complexity to his code. While this isn't an example of the incompetence you have witnessed, it is an example of ritual inclusion of program structures that do not yield any benefits. Monads are an example of using patterns from category theory in programming. This can be done nicely in languages with the facilities to do so, like Haskell. For instance, Functors, Monoids, and Comonads are patterns that are sometimes used in Haskell that are taken from category theory. However, the way monads are often used in Haskell is cargo cult mathematics. Here's why. In category theory, monads are defined as functors with two associated natural transformations. However, in Haskell, the typeclass Monad is not even defined as a subclass of Functor. Additionally, one of the two natural transformations is swapped out for another (join is replaced by bind), and both are misleadingly renamed (return and bind don't suggest their actual meanings). Also, monads are often overkill for the problems they are applied to. Rather than think carefully about which pattern to apply to the problem, programmers echo the trumpeted “Monads are the fundamental method of abstraction!” and use them in their code, for that is the right thing to do. Monads are not actions. Monads are not defined as a way to thread state through code. The type IO a in Haskell is an action, and since the interface provided to this abstract data type is monadic, there is a great deal of confusion about what the properties of a monad are and what the properties of the IO a type are. This blog post confuses them. Even though monads are misused in this way in Haskell, their use still brings benefits. This is because Haskell gives the programmer facilities to write code that works over every monad. However, this is not the case in this blog post. The code in this blog post is parametrized over the types returned by the actions, but not over the actual type of action. One can see where he is looking at Haskell implementations of the functions to translate into C++ that they aren't. This basically renders the monads useless. Another telling example of how these aren't really monads is when he says “You might have noticed that I use the words “action” and “program” interchangeably, although, strictly speaking, an action is the contents of a program. However, this distinction is an artifact or a Haskell quirk — a monad can’t be defined using a type alias, so we need the Prog type to encapsulate the action. Curiously, we won’t have this problem in C++.” In Haskell, an instance of Monad needs to be a container type, because the two functions that are the fundamental definition of a monad operate on nested containers (unit puts anything into a container, and join makes a container of containers into a single container). Since his C++ code isn't doing anything like this, he hasn't made a monad at all. He's simply made an extra layer of complexity in compiling an AST into actual code at compile-time, a task which has nothing to do with the nature of a monad. I'd reckon one could write code for compile-time EDSL's in C++ using no monads at all that would be much cleaner. Sure, you can make a structure and slap the label monad on it and use return and bind functions (which aren't really what a monad fundamentally is) to put together your code, but if you can't write code that works as well on that monad as on other monads without changes, you've accomplished nothing but useless complexity. In other words, including program structures because they are accepted as good rather than because they have any benefit.
  • BartoszMilewski 15y ago
    @miky: I responded to (the copy of) this comment on reddit: http://www.reddit.com/r/programming/comments/in84h/monads_in_c/ http://www.reddit.com/r/programming/comments/in84h/monads_in... .